Introduction to Java Programming

Lesson 1: Introduction to Java

• Java is a widely used, general-purpose, object-oriented, and platform-independent programming language.
• Java supports application development from desktop software to web applications, mobile apps, and enterprise systems.
• The "Write Once, Run Anywhere" (WORA) principle allows Java programs to run on any platform with a Java Virtual Machine (JVM).
• James Gosling developed Java at Sun Microsystems in 1995; Oracle Corporation now maintains it.
• Java is designed to be easy to use, learn, and powerful enough for robust applications.
• Java is used in web, mobile (Android), and desktop application development, as well as enterprise systems and game development.
• Object-Oriented Programming (OOP) principles organize software design around data (objects) rather than functions and logic.
• Java programs can run on any device with a Java Virtual Machine (JVM).
• Java is secure due to the elimination of certain low-level programming constructs which reduces risk of errors
• Java has strong memory management, automatic garbage collection, and exception handling features.
• Built-in support for multithreading allows multiple threads to run concurrently.
• Java's syntax is similar to C-based languages like C++ and C#.

How Java Programs Work

• Java programs undergo several steps before execution.
• The code is written in a text editor or IDE and saved with a .java extension.
• Java programs are compiled into bytecode by the Java compiler (javac).
• The compilation process translates human-readable Java code into platform-independent bytecode, which is saved in a .class file.
• The Java Virtual Machine (JVM) interprets and runs the bytecode on any platform.

Setting up the Development Environment

• Java Development Kit (JDK) includes the Java Runtime Environment (JRE), Java compiler, and other tools.
• Set up JAVA_HOME environment variable and update the PATH variable to compile and run Java programs from the command line.
• Open the Control Panel > System and Security > System > Advanced system settings, then click on "Environment Variables."
• Click "New" to create a new variable, naming it JAVA_HOME and setting the value to the JDK installation path.
• Find the Path variable, select it, and click "Edit," adding a new entry for %JAVA_HOME%\bin.
• Alternatives when using MacOS/Linux: Open a terminal and edit the shell profile file (~/.bashrc, ~/.zshrc, etc.).
• Adding export JAVA_HOME=/path/to/your/jdk and export PATH=$JAVA_HOME/bin: to the file
• Afterwards save the file and run source ~/.bashrc (or source ~/.zshrc) to apply the changes.
• Alternatives for integrated development environments: Netbeans, IntelliJ, Eclipse, and VSCode.
• Verify installation by opening a terminal or command prompt and typing java -version.
• To test the installation, open an IDE or code editor and create a simple Java program.
• Without an IDE: Create a file named HelloWorld.java, save it, open a command prompt in the same directory, and type javac HelloWorld.java.
• This compiles the program to a class file named HelloWorld.class.
• Run the class file with: java HelloWorld.

Lesson 2: Class Declaration and Keywords in Java

• Object-Oriented Programming (OOP) is a way of organizing and designing software by modeling it after real-world objects and their interactions.
• OOP helps developers write modular, reusable, and scalable code, making programming more efficient.
• OOP makes programming easier to modify, scale and understand
• The four core principles of OOP are encapsulation, abstraction, inheritance, and polymorphism.
• Encapsulation hides internal details and exposes only necessary parts.
• Abstraction shows only relevant details and hides implementation.
• Inheritance creates new classes based on existing ones.
• Polymorphism allows one function to behave differently in different contexts.
• A class is a blueprint for creating objects, defining attributes (variables) and behaviors (methods).
• An object is an instance of a class with its own unique properties and behaviors.
• Analogy: Imagine a car manufacturer with a blueprint (class) for creating cars. Each car they produce (object) is built based on that blueprint.
• Encapsulation in a car: Certain components are hidden and protected, accessible only through car's controls (methods).
• Abstraction driving a car: You don't need to understand workings of the engine; you only need to know how to use the controls.
• Inheritance in car manufacturing: Create a truck based off existing car blueprint (superclass) and add custom truck (subclass) features.
• Polymorphism: Vehicle itself figures out the right way to start its engine. This means you can treat all vehicles the same, even though they might have different starting methods.
• Java keywords are reserved words that have a predefined meaning and can't be used for naming identifiers.
• class keyword defines a new class.
• public modifier means any other class/method/variable can access from anywhere
• static keyword means that a class, field, method, or field belongs to the class itself rather than each instances
• void keyword specifies that a method not return a value
• int data type represents a 32 bit integer (whole number)
• double data type is double-precision, 64-bit, floating-point number
• boolean data is true or false
• if used to execute code with if the condition is met.
• else executs code if the previous conditions was not met
• for perform a block of code for a number of times
• while block of code executes only when the given condition is true
• return exits from method, optionally returns value
• new creates an object
• this refers to current class instance
• super refers to current class superclass
• try first block of code that test for exceptions
• catch manages thrown exceptions in try block
• finally always executes code after try and catch, regardless of exception
• abstract cannot instantiate method, provides default implementation
• interface an implementation to be implemented by classes

Lesson 3: Datatypes and Operators in Java

• Datatypes classify the kind of data, and operation that can be applied to it

• Operators are symbols performing operation on values from a data type

• Primitive datatypes are basic and most common ** byte stores whole numbers ** short stores larger whole numbers ** int stores whole numbers ** long stores very large whole numbers ** float stores decimal numbers with less precision ** double stores decimal numbers with more precision

• Non-primitive datatypes (reference types) store objects ** String sequence of characters ** Array a collection of same type values ** Class a template/blueprint for objects

• Operators are symbols which performs function on code from data types ** Arithmetic (performs basic maths) ** Relational (compare two values with boolean result) ** Increment/Decrement (value of a variable increase or decrease by 1) ** Logical (combines boolean expressions) *** AND true when both are true *** OR true if one of the operands are true *** NOT reverses boolean

• Pre-increment and pre-decrement operators in Java increase or decrease the value of a variable by 1

• Bitwise Operators work at binary level for hardware/performance ** AND bitwise and values ** OR bitwise or values ** NOT bitwise not value

• Operator Precedence in Java determines the order in which operations are performed in an expression. Operators with higher precedence are executed first

• Multiplication Example 1: Multiplication vs. Addition

Lesson 4: Control Structures in Java

• Control structures are essential to programs. They allow programs to make logical decisions.
• Without control structures, programs would run in a top-to-bottom fashion.
• There are 3 main control structure types: sequential execution, selection statements, and iteration (loops).
• Sequential execution (by default) means code starts at very top running in a top-to-bottom fashion
• Selection statements include: if, else, else if, switch
• Iteration (ex: loops) include: for, while, do-while
• if-else statement condition performs logic: if condition met, code executes, if not, skip to else
• if-else-if when you have conditions, else if statement is used
• switch is when you have too many fixed-type check conditions
• Iteration statements (ex: loops) repeats block of code for all items found in that list
• for useful when you want a fixed, specific item in the list
• while loop runs until a condition is false

Lesson 5: Strings and Arrays in Java

• Strings and Arrays are fundamental data structures for storing and manipulating data efficiently.
• Strings are sequences of characters used for text processing.
• Strings are immutable, meaning their values cannot be changed once created.
• Arrays are collections of elements of the same type, stored in a fixed-size structure.
• Creating strings can be done through a String literal or String class
• Common string manipulations: ** Concatenation (combining strings into one string) ** Length (number of characters) ** Substring (part of string) ** Replace (replacing all instances of characters with another) ** Equals (comparing strings for equality) *** EqualsIgnoreCase (comparing strings with no case) ** Trim (removing white space from both ends) ** Split (splitting strings array by given delimiter) ** ToUppercase or Tolowercase (coverting chars) ** StartsWith or EndsWith (prefix or suffix start or ends)
• Arrays ** A fixed size lists with same data (ex: prices, names)

Lesson 6: Class Scope and Different Access Modifiers

• Classes and Objects are key components of Java; they are blueprints and instances that allow organized, reusable and efficient code.

• Scope means Java accessibility of used variables/methods ** To examine the concepts surrounding creating and using classes ** Understanding scope and accessibility ** Access modifiers (ex: public, private, protected, default) that allow data access

• Class determines where a class is accessed and used through your program ** Managed by where the class is declared and used ** The access modifier is what helps with this.

• Access modifiers are public, private, and protected ** Public can be accessed from any class/method/field ** Protected it is accessed by subclasses ** Default if you don't specify, then package has private access/default access where it can only be access by classes with the same page ** Private restricts access to same class only

• Scope includes Static, Instance, Local, Block ** Static Class scope (has its variables, declared for it to use if you call from said class) ** Instance Non-Static (Variables can be accessed by a number of time, as long as you can keep the variable) ** Local Accessible for method, constructor, and initializer block (only) ** Block Scope to its code

Lesson 7: Methods in Java

• Essential part of Java programming, allowing developers to write resuable and organized code ** a block of code the performs specific task. A good method removes redundancy, promotes readability, and makes debugging easier ** methods allows code to write to scale easier when needing more

• static and instance are two types of methods ** static makes it so you can called it without having to call an object. ** example is a calculator, no matter what, you need to clear all of it no matter the class

• Naming methods: ** be descriptive and choose a clear and effective name describing the method does ex: "calculateSum". ** Use Herb-none Structure: start with bird with followed buy her face as a noun for describing the transaction ex: "getUserDetails" or "updateInventory" ** Follow naming conventions and use camel casing for naming method in jobs. ** indicate a clear behavior is use name that implies expected behavior as example:"isAvailable()" when doing method for what is available or getBalance when retrieving said data or reset setting during an action.

Lesson 8: Constructors in Java

• Special methods in Java which helps initialize objects

• Set values for attributes in all objects

• Constructors includes/has : ** Invoked automatically ** Class name from Constructor is same as class ** Not returned (not even void) ** Used to initialize (variables)

• Types of Constructors ** Default (no-argument constructor -- assigns standard values/nulls/0) ** Parameterized (allows you to input information on creation for assigned creation/object type) ** Copy Constructor -- copies its object in a new object

Lesson 9: Overloading Constructors in Java

• Overloading in Java's constructor are useful which has diff parameters, allowing you to make objects in various forms based on arguments, improve flexibility

• Overloading allows flexibility, reusability, and simplification

• The Constructors must have the following for overloaded constructors ** Diff number of parameters vs ** Types of parameters against Product (int #, boolean #) vs

• You can call a constructor from Another. Sometimes, constructors may share similar step instead of repeat code we can call one construct from another that you use ex:, this();

• Constructors allows objects created are able to adapt to various required values.

Lesson 10: Inheritance in Java

• Inheritance is the a way to acquire properties from outside base into your own class. Makes programs organized and efficient.
• Allows easier to reuse old projects
• Think of it as a tree
• Characteristics as eye to height
• Super class = Parent class whose properties are inherited
• Sub class = child class that has the above properties
• Keyword is extends (to establish the above connection)
• You can alter that connection by method overriding
• Sub class can alter/provide specific implementation
• Types of connections ** One class inherits from another, Multilevel where a class has connection/inherits of inheritance,

Lesson 11: Encapsulation

• One of the four principles : inheritance abstraction polymorphism ** bundling from data and methods into an OOP environment aka CLASS. Protect data that is only accessed through Getter/Setters ** Main part of encapsulation is data hiding which is sensitive ** Improves security
• For ATM machine ** Inner ATM locked and secure and hidden ** Users can interact through the machine with pin ** Protected via ATM methods
• Implementing is use with Access Modifiers, Getter and Setters *** Prevents direct mod

Lesson 12: Method Overloading and Overriding

• Method Overloading: in same class methods, with param, same

• Method Overriding: provides specific implementation defined in its parent class ** Polymorphism comes down to single method interfaces which have distinct datatypes *** What happens above creates maintainable code (readable/flexible as well)

• Methods can have overloading and overriding * * has multiple parameters * method signature is key * return does not affect overloading **** Overriding = signatures(same names with all aspects match, including access. annotations

Lesson 13: Polymorphism

• 1 in 4 parts with above as : Encapsulation Inheritance abstraction ** Allows objects as parent class ** Ability to do behaviours, more usable reuslts and maintenance

• 2 components ** Compile vs Run Time / can override

• Compile vs Run, understand Polymorph's role - use scale Java

• Multi functions * Ability to create new ones ** Run time = super vs change

• Run with above you make Java easier through reuse !