1. Introduction to Java Programming Language

#

1.1. Java Overview

#

Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It was originally developed by James Gosling at Sun Microsystems (which is now a subsidiary of Oracle Corporation) and released in 1995 as a core component of Sun Microsystems’ Java platform.

1.1.1. Brief History & Evolution of Java

#

• Inception (1991): Sun Microsystems initiated the Java project under James Gosling, aiming for embedded devices. Java was originally called “Oak”.
• Public Debut (1995): Java was unveiled, focusing on web applets and its “Write Once, Run Anywhere” (WORA) philosophy.
• Growth & Refinement: Subsequent releases (Java 2 and beyond) introduced major platforms (J2SE, J2EE, J2ME), significant language improvements, and vast libraries.
• Oracle Acquisition (2010): Oracle took ownership, driving Java’s evolution.
• Modern Era: Java remains a powerhouse, adapting to cloud computing, big data, and modern development paradigms.

1.1.2. Java Features

#

• Platform Independent: Java code is compiled into bytecode, which can run on any device equipped with a JVM, enabling the famous principle of “write once, run anywhere” (WORA).

• Object-Oriented: Java strictly follows the object-oriented programming model, including concepts like inheritance, encapsulation, polymorphism, and abstraction.

• Robust and Secure: Java offers strong memory management, exception handling, and type-checking mechanisms. Its security features include the sandbox environment of the JVM.

• Multithreaded: Java supports multithreaded programming, allowing developers to build applications that can perform multiple tasks simultaneously.

• Rich API: Java provides a comprehensive standard library (API) that includes tools for networking, I/O, data structures, concurrency, and more.

• High Performance: While the early versions were criticized for performance, Java has significantly improved with the introduction of Just-In-Time (JIT) compilation and various optimization techniques.

1.1.3. Java Applications

#

• Desktop Applications: Java is used to develop cross-platform desktop applications. Swing and JavaFX are notable APIs for creating rich graphical user interfaces.
• Web Applications: Java is widely used in web development, with technologies such as Servlets, JSPs (JavaServer Pages), and frameworks like Spring and Hibernate facilitating the development of robust web applications.
• Mobile Applications: Java was the official language for Android app development until the introduction of Kotlin as an alternative. It remains widely used for Android development.
• Enterprise Applications: Java EE (Enterprise Edition) provides APIs and runtime environments for developing and running large-scale, multi-tiered, scalable, and secure network applications.
• Big Data: Tools within the Java ecosystem (like Hadoop, Spark) are widely used for processing vast datasets.
• Embedded Systems: Java finds use in certain embedded systems and IoT (Internet of Things) devices.
• Scientific Applications: Popular for computation, modeling, and simulation.

Java’s versatility, robustness, and widespread adoption have cemented its place as a cornerstone of modern software development, covering a wide array of computing platforms from embedded devices to enterprise servers and supercomputers.

1.2. Java Environment Setup & Basic Java Syntax

#

1.2.1. Java Components

#

• JVM (Java Virtual Machine): JVM is an abstract computing machine that enables Java bytecode to be executed on different platforms. It interprets the bytecode into machine-specific instructions.

• JRE (Java Runtime Environment): A subset of the JDK, focused on running Java programs. JRE includes JVM along with libraries and other components required to run Java applications but does not include development tools.

• JDK (Java Development Kit): The essential package for developing Java applications. JDK is a full-featured software development kit that includes JRE, compilers, debuggers, and other tools necessary for developing Java applications.

1.2.2. Setting up Java Development Environment

#

To set up a Java development environment:

1. Download JDK: Visit the official Oracle website or adopt openJDK distributions and download the JDK appropriate for your operating system.

2. Install JDK: Follow the installation instructions provided by Oracle or the respective distribution. This usually involves running an installer program.

3. Set up Environment Variables: Set the JAVA_HOME environment variable to point to the JDK installation directory and add the JDK’s bin directory to the PATH environment variable.

4. Verify Installation: Open a command prompt or terminal and type java -version and javac -version to verify that Java and the Java compiler are installed correctly.

1.2.3. Structure of a Java Program

#

A basic Java program consists of:

public class MyFirstProgram {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); // Output 
    }
}

1.2.3.1. Class Declaration

#

Every Java program begins with a class declaration. The class name should match the filename.

1.2.3.2. Main Method

#

The main method is the entry point of a Java program. It has the following syntax:

• ‘Public’ means the class/method is accessible from anywhere.
• ‘static’ allows the JVM to call this method without creating an object of the class.
• ‘void’ means the method doesn’t return a value.
• ‘main’ is a special method name.

public static void main(String[] args) {
    // Program logic goes here
}

1.2.3.3. Output in Java

#

Output in Java is typically achieved using the System.out.println() method. System is a built-in Java class that contains useful members, such as out, which is short for “output”.

1.2.3.3.1. The println() Method

#

The println() method, short for “print line”, is used to print a value to the screen (or a file). You should also note that each code statement must end with a semicolon (;).

System.out.println("Hello, World!");

1.2.3.3.2. The print() Method

#

There is also a print() method, which is similar to println(). The only difference is that it does not insert a new line at the end of the output:

System.out.print("Hello World! ");
System.out.print("I will print on the same line.");

You can also use the println() method to print numbers. However, unlike text, we don’t put numbers inside double quotes:

System.out.println(3);
System.out.println(358);
System.out.println(50000);
System.out.println(3 + 3);
System.out.println(2 * 5);

1.2.3.4. Comments

#

Java supports single-line (//) and multi-line (/* */) comments for documenting code.

Comments can be used to explain Java code, and to make it more readable. It can also be used to prevent execution when testing alternative code.

1.2.3.4.1. Single-line Comments

#

Single-line comments start with two forward slashes (//). Any text between // and the end of the line is ignored by Java (will not be executed). This example uses a single-line comment before a line of code:

// This is a comment
System.out.println("Hello World");

This example uses a single-line comment at the end of a line of code:

System.out.println("Hello World"); // This is a comment

1.2.3.4.2. Multi-line Comments

#

Multi-line comments start with /* and ends with */. Any text between /* and */ will be ignored by Java. This example uses a multi-line comment (a comment block) to explain the code:

/* The code below will print the words Hello World
to the screen, and it is amazing */
System.out.println("Hello World");

1.2.4. Compilation and Execution of Java Program

#

To compile and execute a Java program:

1. Write Code: Create a Java source file with the .java extension containing the Java code.

2. Compile Code: Open a terminal or command prompt, navigate to the directory containing the Java file, and use the javac command to compile the code:

   javac YourProgram.java
   

3. Execute Program: After successfully compiling, use the java command followed by the name of the class containing the main method (without the .class extension) to execute the program:

   java YourProgram
   

1.2.5. Importance of Bytecode & Garbage Collection

#

• Bytecode: Java source code is compiled into bytecode, which is a platform-independent intermediate representation. This bytecode can be executed on any device with a JVM, enabling Java’s “write once, run anywhere” capability.

• Garbage Collection: Java employs automatic memory management through garbage collection. It automatically deallocates memory occupied by objects that are no longer in use, preventing memory leaks and simplifying memory management for developers. Garbage collection helps ensure memory efficiency and program stability in Java applications.

1.3. Data Types

#

A variable in Java must be a specified data type:

int myNum = 5;               // Integer (whole number)
float myFloatNum = 5.99f;    // Floating point number
char myLetter = 'D';         // Character
boolean myBool = true;       // Boolean
String myText = "Hello";     // String

Data types are divided into two groups:

• Primitive data types - includes byte, short, int, long, float, double, boolean and char
• Non-primitive data types - such as String, Arrays and Classes.

1.3.1. Primitive Data Types

#

A primitive data type specifies the size and type of variable values, and it has no additional methods. There are eight primitive data types in Java.

• Numeric:
  • Integer Types:
    • byte (8 bits): The byte data type can store whole numbers from -128 to 127. This can be used instead of int or other integer types to save memory when you are certain that the value will be within -128 and 127
    • **short (16 bits):**The short data type can store whole numbers from -32768 to 32767:
    • int (32 bits): The int data type can store whole numbers from -2147483648 to 2147483647. In general, and in our topic, the int data type is the preferred data type when we create variables with a numeric value.
    • **long (64 bits):**The long data type can store whole numbers from -9223372036854775808 to 9223372036854775807. This is used when int is not large enough to store the value. Note that you should end the value with an “L”:
  • Floating-Point Types: You should use a floating point type whenever you need a number with a decimal, such as 9.99 or 3.14515. The float and double data types can store fractional numbers. Note that you should end the value with an “f” for floats and “d” for doubles:
    • float (32-bit single precision):
    • double (64-bit double precision):
• Character:
  • char (16-bit Unicode character): The char data type is used to store a single character. The character must be surrounded by single quotes, like ‘A’ or ‘c’:
• Boolean:
  • boolean (true or false): Very often in programming, you will need a data type that can only have one of two values, like: YES / NO, ON / OFF, TRUE / FALSE. For this, Java has a boolean data type, which can only take the values true or false

1.3.2. Non-Primitive Data Types

#

Non-primitive data types are called reference types because they refer to objects. The main difference between primitive and non-primitive data types are:

• Primitive types are predefined (already defined) in Java. Non-primitive types are created by the programmer and is not defined by Java (except for String).
• Non-primitive types can be used to call methods to perform certain operations, while primitive types cannot.
• A primitive type has always a value, while non-primitive types can be null.
• A primitive type starts with a lowercase letter, while non-primitive types starts with an uppercase letter.

Examples of non-primitive types are Strings, Arrays, Classes, Interface, etc.

1.3.3. Type Conversion and Casting

#

1.3.3.1. Implicit Conversion (Widening)

#

Java automatically converts smaller data types to larger ones to prevent loss of data. For example, int can be implicitly converted to long.

byte -> short -> char -> int -> long -> float -> double

public class Main {
  public static void main(String[] args) {
    int myInt = 9;
    double myDouble = myInt; // Automatic casting: int to double

    System.out.println(myInt);      // Outputs 9
    System.out.println(myDouble);   // Outputs 9.0
  }
}

1.3.3.2. Explicit Conversion (Narrowing)

#

When converting larger data types to smaller ones, explicit casting is required to avoid loss of data. For example: int myInt = (int) 3.14;

double -> float -> long -> int -> char -> short -> byte

public class Main {
  public static void main(String[] args) {
    double myDouble = 9.78d;
    int myInt = (int) myDouble; // Manual casting: double to int

    System.out.println(myDouble);   // Outputs 9.78
    System.out.println(myInt);      // Outputs 9
  }
}

1.4. Identifiers

#

Identifiers are names given to classes, methods, variables, etc., in Java. They must start with a letter, underscore (_), or dollar sign ($), followed by letters, digits, underscores, or dollar signs.

1.4.1. Naming Rules & Conventions

#

1.4.1.1. Naming Rules

#

• Names can contain letters, digits, underscores, and dollar signs

• Names must begin with a letter

• Names should start with a lowercase letter, and cannot contain whitespace

• Names can also begin with $ and _ (but we will not use it here)

• Names are case-sensitive (“myVar” and “myvar” are different variables)

• Reserved words (like Java keywords, such as int or boolean) cannot be used as names

1.4.1.2. Naming Conventions

#

• Class names should start with an uppercase letter and follow CamelCase (e.g., MyClass).
• Variable and method names should start with a lowercase letter and follow camelCase (e.g., myVariable, myMethod).
• Constants should be all uppercase with underscores separating words (e.g., MAX_SIZE).

1.4.2. Variables

#

• Variable Declaration: Variables are containers for storing data values. Variables are declared with a data type followed by a name:

  int myVariable;
  

• Variable Initialization: Variables can be initialized at the time of declaration or later in the code:

  int myVariable = 10; // Initialization at declaration
  myVariable = 20;     // Later initialization
  

• Declare Many Variables: To declare more than one variable of the same type, you can use a comma-separated list:

  int x = 5, y = 6, z = 50;
  System.out.println(x + y + z);
  

• One Value to Multiple Variables: You can also assign the same value to multiple variables in one line:

  int x, y, z;
  x = y = z = 50;
  System.out.println(x + y + z);
  

1.4.3. Constants (final Keyword)

#

If you don’t want others (or yourself) to overwrite existing values, use the final keyword (this will declare the variable as “final” or “constant”, which means unchangeable and read-only):

• Declaration: Constants in Java are declared using the final keyword.

  final int myNum = 15;
  myNum = 20;  // will generate an error: cannot assign a value to a final variable
  

• Immutable: The value of a constant cannot be changed once initialized.

• By convention, constant names are written in uppercase letters with underscores separating words.

1.4.4. Scope of Variables

#

• Instance Variables: Variables declared within a class but outside any method are instance variables. They exist as long as the object they belong to exists.

• Local Variables: Variables declared within a method or block have local scope. They exist only within the method or block where they are declared.

public class Main {
  public static void main(String[] args) {
    // Code here CANNOT use x
    { // This is a block
      // Code here CANNOT use x
      int x = 100;
      // Code here CAN use x
      System.out.println(x);
    } // The block ends here
  // Code here CANNOT use x
  }
}

• Class Variables (Static Variables): Variables declared with the static keyword within a class are class variables. They are shared among all instances of the class.

1.5. Arrays

#

An array is a data structure that stores a fixed-size collection of elements of the same data type. Each element is accessed by its index (position) within the array.

1.5.1. One-dimensional Arrays

#

• Declaration: To declare a one-dimensional array, specify the type of elements followed by square brackets []:

  int[] numbers;
  

• Initialization: Arrays can be initialized using the new keyword followed by the type and the number of elements, or directly with values enclosed in curly braces {}:

  int[] numbers = new int[5]; // Initializing with size
  int[] numbers = {1, 2, 3, 4, 5}; // Initializing with values
  

• Accessing Elements: Elements of an array are accessed using the index (starting from 0):

  int[] numbers = {1, 2, 3, 4, 5};
  int firstElement = numbers[0]; // Accessing first element
  

• Key points

  • Array indices start at 0 and go up to the length of the array minus 1.

  • Trying to access an element outside the array bounds will result in an ArrayIndexOutOfBoundsException.

1.5.2. Multidimensional Arrays

#

• Declaration: To declare a two-dimensional array, specify the type of elements followed by two sets of square brackets [][]:

  int[][] matrix;
  

• Initialization: Two-dimensional arrays can be initialized similarly to one-dimensional arrays, with each row enclosed in curly braces {}:

  int[][] matrix = new int[3][3]; // Instantiation with size
  int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // Initializing with values
  

• Accessing Elements: Elements of a two-dimensional array are accessed using row and column indices:

  int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
  int element = matrix[1][2]; // Accessing element at row 1, column 2 (value: 6)
  

• Iterating Through a Two-dimensional Array: Nested loops are commonly used to iterate through all elements of a two-dimensional array:

  for (int i = 0; i < matrix.length; i++) {
      for (int j = 0; j < matrix[i].length; j++) {
          // Accessing each element using matrix[i][j]
          System.out.println(matrix[i][j]);
      }
  }
  

Things to remember

• Multidimensional arrays can have more than two dimensions.
• Rows and columns in a multidimensional array can have different lengths.
• Two-dimensional arrays can represent matrices, tables, grids, etc., and are useful for storing and processing structured data in Java.

1.6. Operators

#

Operators are used to perform operations on variables and values. In the example below, we use the + operator to add together two values:

int x = 100 + 50;

Although the + operator is often used to add together two values, like in the example above, it can also be used to add together a variable and a value, or a variable and another variable:

int sum1 = 100 + 50;        // 150 (100 + 50)
int sum2 = sum1 + 250;      // 400 (150 + 250)
int sum3 = sum2 + sum2;     // 800 (400 + 400)

Java divides the operators into the following groups:

• Arithmetic operators
• Assignment operators
• Comparison operators
• Logical operators
• Bitwise operators

1.6.1. Arithmetic Operators

#

Arithmetic operators are used to perform mathematical operations.

int a = 10;
int b = 3;
int sum = a + b;        // Addition
int difference = a - b; // Subtraction
int product = a * b;    // Multiplication
int quotient = a / b;   // Division
int remainder = a % b;  // Modulus (remainder)

1.6.2. Assignment Operators

#

Assignment operators are used to assign values to variables.

int a = 10;
a += 5; // Equivalent to a = a + 5;

1.6.3. Relational (Comparison) Operators

#

Relational operators are used to establish relationships between two values. This is important in programming, because it helps us to find answers and make decisions. The return value of a comparison is either true or false. These values are known as Boolean values, and you will learn more about them in the Booleans and If..Else topic.

int a = 10;
int b = 5;
boolean greater = a > b;
boolean lesserOrEqual = a <= b;
boolean isEqual = a == b;
boolean notEqual = a != b;

1.6.4. Logical Operators

#

You can also test for true or false values with logical operators. Logical operators are used to determine the logic between variables or values.

boolean x = true;
boolean y = false;
boolean result1 = x && y; // Logical AND
boolean result2 = x || y; // Logical OR
boolean result3 = !x;     // Logical NOT (negation)

1.6.5. Bitwise Operators

#

Bitwise operators perform bitwise operations on integer operands.

int a = 5;  // Binary: 101
int b = 3;  // Binary: 011
int bitwiseAnd = a & b;       // Bitwise AND
int bitwiseOr = a | b;        // Bitwise OR
int bitwiseXor = a ^ b;       // Bitwise XOR
int bitwiseComplement = ~a;   // Bitwise complement
int leftShift = a << 1;       // Left shift
int rightShift = a >> 1;      // Right shift

1.6.6. Conditional (Ternary) Operator

#

The conditional operator is a ternary operator that evaluates a boolean expression and returns one of two values depending on whether the expression is true or false.

• This is also called as a short-hand if else.
• It is known as the ternary operator because it consists of three operands.
• It can be used to replace multiple lines of code with a single line, and is most often used to replace simple if else statements:

Syntax: \*variable\* = (\*condition\*) ? \*expressionTrue\* : \*expressionFalse\*;

Instead of writing:

int time = 20;
if (time < 18) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}

You can simply write:

int time = 20;
String result = (time < 18) ? "Good day." : "Good evening.";
System.out.println(result);

These operators are fundamental in Java for performing various operations and making decisions based on conditions.

1.6.7. Operator Precedence

#

Java follows a specific order for evaluating expressions with multiple operators (similar to mathematical order of operations). You can find a detailed precedence table online.

int x = 5 + 3 * 2;  // x will be 11 (Multiplication first)
boolean isGreater = 10 >= 5; // isGreater will be true 
int y = 10;
y++; // Postfix increment, y is now 11
++y; // Prefix increment, y is now 12 
int result = (2 > 3) ? 10 : 20; // result will be 20

1.7. Control Flow Statements

#

Control flow statements in Java are used to control the flow of execution in a program based on certain conditions or loops.

1.7.1. Selection Statements

#

Java has the following conditional statements:

• Use if to specify a block of code to be executed, if a specified condition is true
• Use else to specify a block of code to be executed, if the same condition is false
• Use else if to specify a new condition to test, if the first condition is false
• Use switch to specify many alternative blocks of code to be executed

1.7.1.1. The if Statement

#

Use the if statement to specify a block of Java code to be executed if a condition is true.

//  Syntax
if (condition) {
  // block of code to be executed if the condition is true
}

Note that if is in lowercase letters. Uppercase letters (If or IF) will generate an error.

In the example below, we test two values to find out if 20 is greater than 18. If the condition is true, print some text:

// Example
if (20 > 18) {
  System.out.println("20 is greater than 18");
}

We can also test variables:

int x = 20;
int y = 18;
if (x > y) {
  System.out.println("x is greater than y");
}

In the example above we use two variables, x and y, to test whether x is greater than y (using the > operator). As x is 20, and y is 18, and we know that 20 is greater than 18, we print to the screen that “x is greater than y”.

1.7.1.2. The if-else Statement

#

Use the else statement to specify a block of code to be executed if the condition is false.

// Syntax
if (condition) {
  // block of code to be executed if the condition is true
} else {
  // block of code to be executed if the condition is false
}

// Example
int time = 20;
if (time < 18) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}
// Outputs "Good evening."
 

In the example above, time (20) is greater than 18, so the condition is false. Because of this, we move on to the else condition and print to the screen “Good evening”. If the time was less than 18, the program would print “Good day”.

1.7.1.3. The if-else-if Ladder

#

Use the else if statement to specify a new condition if the first condition is false.

// Syntax
if (condition1) {
  // block of code to be executed if condition1 is true
} else if (condition2) {
  // block of code to be executed if the condition1 is false and condition2 is true
} else {
  // block of code to be executed if the condition1 is false and condition2 is false
}

// Example
int time = 22;
if (time < 10) {
  System.out.println("Good morning.");
} else if (time < 18) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}
// Outputs "Good evening."
 

In the example above, time (22) is greater than 10, so the first condition is false. The next condition, in the else if statement, is also false, so we move on to the else condition since condition1 and condition2 is both false - and print to the screen “Good evening”.

However, if the time was 14, our program would print “Good day.”

1.7.1.4. Switch-Case Statements

#

Instead of writing many if..else statements, you can use the switch statement.

The switch statement selects one of many code blocks to be executed:

// Syntax
switch(expression) {
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
    // code block
}

This is how it works:

• The switch expression is evaluated once.
• The value of the expression is compared with the values of each case.
• If there is a match, the associated block of code is executed.
• The break and default keywords are optional, and will be described later here

The example below uses the weekday number to calculate the weekday name:

// Example
int day = 4;
switch (day) {
  case 1:
    System.out.println("Monday");
    break;
  case 2:
    System.out.println("Tuesday");
    break;
  case 3:
    System.out.println("Wednesday");
    break;
  case 4:
    System.out.println("Thursday");
    break;
  case 5:
    System.out.println("Friday");
    break;
  case 6:
    System.out.println("Saturday");
    break;
  case 7:
    System.out.println("Sunday");
    break;
}
// Outputs "Thursday" (day 4)

1.7.1.4.1. break Keyword

#

When Java reaches a break keyword, it breaks out of the switch block.

1.7.1.4.2. default Keyword

#

The default keyword specifies some code to run if there is no case match:

int day = 4;
switch (day) {
  case 6:
    System.out.println("Today is Saturday");
    break;
  case 7:
    System.out.println("Today is Sunday");
    break;
  default:
    System.out.println("Looking forward to the Weekend");
}
// Outputs "Looking forward to the Weekend"
 

Note that if the default statement is used as the last statement in a switch block, it does not need a break.

1.7.2. Looping Statements

#

Loops can execute a block of code as long as a specified condition is reached. Loops are handy because they save time, reduce errors, and they make code more readable.

1.7.2.1. While Loop

#

The while loop loops through a block of code as long as a specified condition is true:

// Syntax
while (condition) {
  // code block to be executed
}

In the example below, the code in the loop will run, over and over again, as long as a variable (i) is less than 5:

int i = 0;
while (i < 5) {
  System.out.println(i);
  i++;
}

Note: Do not forget to increase the variable used in the condition, otherwise the loop will never end!

1.7.2.2. Do/While Loop

#

The do/while loop is a variant of the while loop. This loop will execute the code block once, before checking if the condition is true, then it will repeat the loop as long as the condition is true.

// Syntax
do {
  // code block to be executed
}
while (condition);

The example below uses a do/while loop. The loop will always be executed at least once, even if the condition is false, because the code block is executed before the condition is tested:

int i = 0;do {
  System.out.println(i);
  i++;
}
while (i < 5);

Do not forget to increase the variable used in the condition, otherwise the loop will never end!

1.7.2.3. For Loop

#

When you know exactly how many times you want to loop through a block of code, use the for loop instead of a while loop:

// Syntax
for (statement 1; statement 2; statement 3) {
  // code block to be executed
}

Statement 1 is executed (one time) before the execution of the code block. Statement 2 defines the condition for executing the code block. Statement 3 is executed (every time) after the code block has been executed.

The example below will print the numbers 0 to 4:

for (int i = 0; i < 5; i++) {
  System.out.println(i);
}

Statement 1 sets a variable before the loop starts (int i = 0). Statement 2 defines the condition for the loop to run (i must be less than 5). If the condition is true, the loop will start over again, if it is false, the loop will end. Statement 3 increases a value (i++) each time the code block in the loop has been executed.

This example will only print even values between 0 and 10:

for (int i = 0; i <= 10; i = i + 2) {
  System.out.println(i);
}

1.7.2.4. The For-Each Loop

#

The for-each loop, also known as the enhanced for loop, provides a simple way to iterate over collections and arrays in Java.

The following example outputs all elements in the cars array, using a “for-each” loop:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (String i : cars) {
  System.out.println(i);
}

The for-each loop iterates over each element in the collection sequentially, without the need for explicit indexing or iterators.

ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

for (String language : list) {
    System.out.println(language);
}

1.7.2.5. Nested Loops

#

It is also possible to place a loop inside another loop. This is called a nested loop. The “inner loop” will be executed one time for each iteration of the “outer loop”:

// Outer loop
for (int i = 1; i <= 2; i++) {
  System.out.println("Outer: " + i); // Executes 2 times
  
  // Inner loop
  for (int j = 1; j <= 3; j++) {
    System.out.println(" Inner: " + j); // Executes 6 times (2 * 3)
  }
} 

1.7.3. Jump Statements

#

1.7.3.1. break Statement

#

Terminates the loop or switch statement and transfers control to the statement immediately following the loop or switch.

for (int i = 0; i < 5; i++) {
    if (i == 3) {
        break; // Terminates the loop when i equals 3
    }
    System.out.println("Iteration: " + i);
}

1.7.3.2. continue Statement

#

The continue statement breaks one iteration (in the loop), if a specified condition occurs, and continues with the next iteration in the loop.

for (int i = 0; i < 5; i++) {
    if (i == 3) {
        continue; // Skips iteration when i equals 3
    }
    System.out.println("Iteration: " + i);
}

1.7.3.3. return Statement

#

Exits the current method and returns a value (if applicable) to the caller.

public int add(int a, int b) {
    return a + b; // Returns the sum of a and b
}

These control flow statements provide essential mechanisms for directing the flow of execution in Java programs, allowing developers to implement conditional logic and repetitive tasks efficiently.

2. Object-Oriented Programming

#

2.1. Procedure-Oriented vs. Object-Oriented Programming

#

2.1.1. Characteristics

#

Procedure-Oriented Programming (POP):

1. Focus: POP focuses on functions or procedures that operate on data.
2. Data and Functions: Data and functions are separate entities.
3. Global Data: Relies heavily on global data, which can lead to data integrity issues.
4. Procedural Abstraction: Emphasizes procedural abstraction, breaking down a problem into a sequence of steps.
5. Top-Down Approach: Follows a top-down approach, where the problem is broken down into smaller sub-problems.
6. Examples: C, FORTRAN, Pascal, BASIC

Object-Oriented Programming (OOP):

1. Focus: OOP focuses on objects that encapsulate data and behavior.
2. Data Encapsulation: Data and functions are encapsulated within objects, promoting data hiding and encapsulation.
3. Class and Object: Relies on classes and objects to model real-world entities and interactions.
4. Inheritance and Polymorphism: Supports inheritance and polymorphism, enabling code reuse and flexibility.
5. Bottom-Up Approach: Often follows a bottom-up approach, where objects are identified and modeled to represent real-world entities.
6. Examples: Java, Python, C++, C#

2.1.2. Differences

#

In summary, while POP emphasizes procedures and functions, OOP revolves around objects and their interactions, offering better encapsulation, code reusability, and maintainability for complex software systems. The choice between them often depends on the nature and scale of the project, as well as the preferences of the development team.

2.2. OOP Concepts

#

Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of objects, which encapsulate data and behavior. OOP provides several key concepts to facilitate modular and organized software design.

2.2.1. Classes and Objects

#

• Class: A class is a blueprint for creating objects. It defines the properties (attributes) and behaviors (methods) that objects of the class will have.

  public class Car {
      String color;
      int speed;
  
      void accelerate() {
          // Method to increase speed
      }
  
      void brake() {
          // Method to decrease speed
      }
  }
  

• Object: An object is an instance of a class. It represents a real-world entity and encapsulates both data (attributes) and behavior (methods).

  Car myCar = new Car();
  myCar.color = "Red";
  myCar.speed = 60;
  myCar.accelerate();
  

2.2.2. Encapsulation

#

• Bundling: Combining data (attributes) and code (methods) that operates on that data within a single unit (class).
• Protection: Controlling the visibility of data members using access modifiers (public, private, protected) to protect data integrity and hide implementation details.

Example:

The attributes of a BankAccount object are encapsulated within the class, accessible and modifiable mainly through its methods.

public class BankAccount {
    private double balance;
    
    public void deposit(double amount) {
        // Method to deposit money
    }
    
    public void withdraw(double amount) {
        // Method to withdraw money
    }
}

2.2.3. Abstraction

#

Abstraction refers to the process of hiding the implementation details of a class and showing only the essential features to the outside world. It focuses on what an object does rather than how it does it.

• Simplification: Focusing on essential characteristics and hiding complex details. Exposing only the necessary interface.
• Levels of Abstraction: Can be achieved through classes, abstract classes, and interfaces.

Example:

interface Shape {
    void draw();
}

class Circle implements Shape {
    public void draw() {
        // Method to draw a circle
    }
}

class Rectangle implements Shape {
    public void draw() {
        // Method to draw a rectangle
    }
}

2.2.4. Inheritance

#

Inheritance is a mechanism in which a new class (derived class or subclass) inherits properties and behaviors from an existing class (base class or superclass). It promotes code reuse and establishes a hierarchical relationship between classes.

• Hierarchy: Creating new classes (subclasses) that inherit properties and behaviors of existing classes (superclasses)
• Code Reusability: Subclasses can reuse code from the superclass.
• Extensibility: Subclasses can add their own unique properties and behaviors.

Example:

class Animal {
    void eat() {
        // Method to eat
    }
}

class Dog extends Animal {
    void bark() {
        // Method to bark
    }
}

2.2.5. Polymorphism

#

Polymorphism allows objects to be treated as instances of their superclass or as instances of their subclass. It enables flexibility and dynamic behaviour in the program.

• Many Forms: The ability of an object to take on different forms or behaviours depending on the situation.
• Method Overloading: Multiple methods in a class with the same name but different parameters.
• Method Overriding: A subclass provides a specific implementation of a method inherited from its superclass.

Example:

class Animal {
    void makeSound() {
        // Method to make a generic animal sound
    }
}

class Dog extends Animal {
    void makeSound() {
        // Method to make a dog sound
    }
}

class Cat extends Animal {
    void makeSound() {
        // Method to make a cat sound
    }
}

These OOP concepts form the foundation of object-oriented design and programming. They enable developers to create modular, maintainable, and scalable software systems by modeling real-world entities and interactions in a structured and organized manner.

2.3. Classes and Objects

#

2.3.1. Creating Classes

#

In Java, a class is a blueprint for creating objects. It defines the structure and behavior of objects of that type.

Syntax

public class MyClass {
    // Class body
}

Example

public class Car { // 'public' allows access from anywhere
    // Fields (member variables) define attributes 
    private String model;  // 'private' limits access to within the class
    private int year;
    private String color;

    // Constructor: Special method to initialize an object
    public Car(String model, int year, String color) { 
        this.model = model; // 'this' refers to the current object
        this.year = year;
        this.color = color;
    }

    // Methods define behaviors
    public void startEngine() {
        System.out.println("Engine Starting...");
    }

    public void brake() {
        System.out.println("Braking..."); 
    }

    // Getters and setters (accessors and mutators) for controlled access 
    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    } 

    // ... more getters and setters
}

2.3.2. Creating Objects

#

In Java, an object is created from a class. Objects are instances of classes. They are created using the new keyword followed by the class constructor

To create an object of Main, specify the class name, followed by the object name, and use the keyword new: Create an object called “myObj” and print the value of x:

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}
 

2.3.2.1. Multiple Objects

#

You can create multiple objects of one class:

Create two objects of Main:

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj1 = new Main();  // Object 1
    Main myObj2 = new Main();  // Object 2
    System.out.println(myObj1.x);
    System.out.println(myObj2.x);
  }
}

2.3.2.2. Using Multiple Classes

#

You can also create an object of a class and access it in another class. This is often used for better organization of classes (one class has all the attributes and methods, while the other class holds the main() method (code to be executed)).

Remember that the name of the java file should match the class name. In this example, we have created two files in the same directory/folder:

• Main.java
• Second.java

//Main.java
public class Main {
  int x = 5;
}

//Second.java
class Second {
  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}

2.3.2.3. this Keyword

#

Inside a method or constructor, this refers to the current object. It is used to differentiate between instance variables and local variables with the same name.

public class Person {
    String name;
    
    public void setName(String name) {
        this.name = name; // Assigning the parameter value to the instance variable
    }
}

2.4. Class Attributes

#

Attributes are variables that define the state of objects. They represent the data associated with objects of the class.

Create a class called “Main” with two attributes: x and y:

public class Main {
  int x = 5;
  int y = 3;
}

Another term for class attributes is fields.

2.4.1. Accessing Attributes

#

You can access attributes by creating an object of the class, and by using the dot syntax (.):

The following example will create an object of the Main class, with the name myObj. We use the x attribute on the object to print its value:

Create an object called “myObj” and print the value of x:

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println(myObj.x);
  }
}

2.4.2. Modify Attributes

#

You can also modify attribute values: Set the value of x to 40:

public class Main {
  int x;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 40;
    System.out.println(myObj.x);
  }
}

Or override existing values: Change the value of x to 25:

public class Main {
  int x = 10;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 25; // x is now 25
    System.out.println(myObj.x);
  }
}
 

If you don’t want the ability to override existing values, declare the attribute as final:

public class Main {
  final int x = 10;

  public static void main(String[] args) {
    Main myObj = new Main();
    myObj.x = 25; // will generate an error: cannot assign a value to a final variable
    System.out.println(myObj.x);
  }
}
 

The final keyword is useful when you want a variable to always store the same value, like PI (3.14159…).

2.4.3. Attributes of Multiple Objects

#

If you create multiple objects of one class, you can change the attribute values in one object, without affecting the attribute values in the other: Change the value of x to 25 in myObj2, and leave x in myObj1 unchanged:

public class Main {
  int x = 5;

  public static void main(String[] args) {
    Main myObj1 = new Main();  // Object 1
    Main myObj2 = new Main();  // Object 2
    myObj2.x = 25;
    System.out.println(myObj1.x);  // Outputs 5
    System.out.println(myObj2.x);  // Outputs 25
  }
}

2.4.4. Multiple Attributes of same Object

#

You can specify as many attributes as you want:

public class Main {
  String fname = "John";
  String lname = "Doe";
  int age = 24;

  public static void main(String[] args) {
    Main myObj = new Main();
    System.out.println("Name: " + myObj.fname + " " + myObj.lname);
    System.out.println("Age: " + myObj.age);
  }
}

• Methods: Methods are functions that define the behavior of objects. They represent the actions that objects of the class can perform.

  public class Car {
      void accelerate() {
          // Method to increase speed
      }
  
      void brake() {
          // Method to decrease speed
      }
  }
  

2.5. Class Methods

#

• A method is a block of code which only runs when it is called.

• You can pass data, known as parameters, into a method.

• Methods are used to perform certain actions, and they are also known as functions.

• Why use methods? To reuse code: define the code once, and use it many times.

2.5.1. Create a Method

#

A method must be declared within a class. It is defined with the name of the method, followed by parentheses (). Java provides some pre-defined methods, such as System.out.println(), but you can also create your own methods to perform certain actions:

Create a method inside Main:

public class Main {
  static void myMethod() {
    // code to be executed
  }
}

• myMethod() is the name of the method
• static means that the method belongs to the Main class and not an object of the Main class. You will learn more about objects and how to access methods through objects later here.
• void means that this method does not have a return value. You will learn more about return values later here

2.5.2. Call a Method

#

To call a method in Java, write the method’s name followed by two parentheses () and a semicolon**;**

In the following example, myMethod() is used to print a text (the action), when it is called:

Inside main, call the myMethod() method:

public class Main {
  static void myMethod() {
    System.out.println("I just got executed!");
  }

  public static void main(String[] args) {
    myMethod();
  }
}

// Outputs "I just got executed!" 

A method can also be called multiple times:

public class Main {
  static void myMethod() {
    System.out.println("I just got executed!");
  }

  public static void main(String[] args) {
    myMethod();
    myMethod();
    myMethod();
  }
}

// I just got executed!
// I just got executed!
// I just got executed! 

2.5.3. Method Parameters and Arguments

#

Information can be passed to methods as parameter. Parameters act as variables inside the method.

Parameters are specified after the method name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma.

The following example has a method that takes a String called fname as parameter. When the method is called, we pass along a first name, which is used inside the method to print the full name:

public class Main {
  static void myMethod(String fname) {
    System.out.println(fname + " Refsnes");
  }

  public static void main(String[] args) {
    myMethod("Liam");
    myMethod("Jenny");
    myMethod("Anja");
  }
}
// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes 

When a parameter is passed to the method, it is called an argument. So, from the example above: fname is a parameter, while Liam, Jenny and Anja are arguments.

2.5.3.1. Multiple Parameters

#

You can have as many parameters as you like:

public class Main {
  static void myMethod(String fname, int age) {
    System.out.println(fname + " is " + age);
  }

  public static void main(String[] args) {
    myMethod("Liam", 5);
    myMethod("Jenny", 8);
    myMethod("Anja", 31);
  }
}

// Liam is 5
// Jenny is 8
// Anja is 31 

Note that when you are working with multiple parameters, the method call must have the same number of arguments as there are parameters, and the arguments must be passed in the same order.

2.5.4. Return Values

#

The void keyword, used in the examples above, indicates that the method should not return a value. If you want the method to return a value, you can use a primitive data type (such as int, char, etc.) instead of void, and use the return keyword inside the method:

public class Main {
  static int myMethod(int x) {
    return 5 + x;
  }

  public static void main(String[] args) {
    System.out.println(myMethod(3));
  }
}
// Outputs 8 (5 + 3)
 

This example returns the sum of a method’s two parameters:

public class Main {
  static int myMethod(int x, int y) {
    return x + y;
  }

  public static void main(String[] args) {
    System.out.println(myMethod(5, 3));
  }
}
// Outputs 8 (5 + 3)

You can also store the result in a variable (recommended, as it is easier to read and maintain):

public class Main {
  static int myMethod(int x, int y) {
    return x + y;
  }

  public static void main(String[] args) {
    int z = myMethod(5, 3);
    System.out.println(z);
  }
}
// Outputs 8 (5 + 3)

2.5.5. Access Methods With an Object

#

Create a Car object named myCar. Call the fullThrottle() and speed() methods on the myCar object, and run the program:

// Create a Main class
public class Main {
 
  // Create a fullThrottle() method
  public void fullThrottle() {
    System.out.println("The car is going as fast as it can!");
  }

  // Create a speed() method and add a parameter
  public void speed(int maxSpeed) {
    System.out.println("Max speed is: " + maxSpeed);
  }

  // Inside main, call the methods on the myCar object
  public static void main(String[] args) {
    Main myCar = new Main();   // Create a myCar object
    myCar.fullThrottle();      // Call the fullThrottle() method
    myCar.speed(200);          // Call the speed() method
  }
}

// The car is going as fast as it can!
// Max speed is: 200

2.5.6. Method Signatures

#

A method signature consists of the method name and the parameter list (type and order of parameters). The return type may also be considered part of the method signature, but it’s not required for method overloading.

The unique identifier of a method. It consists of:

• Name: What the method is called.
• Parameter List: The types and order of arguments the method accepts.
• Return Type: The type of value returned by the method (void if it doesn’t return anything).

public void methodName(int parameter1, String parameter2) {
    // Method body
}

2.5.7. Passing Arguments

#

• Passing by Value: Primitive data types are passed by value, meaning a copy of the value is passed to the method. Changes to the parameter inside the method do not affect the original value.

  public void modifyValue(int x) {
      x = x + 1; // Changes made to x are local to this method
  }
  

• Passing by Reference: Objects are passed by reference, meaning the reference to the object is passed to the method. Changes to the object’s state inside the method affect the original object.

  public void modifyObjectValue(MyObject obj) {
      obj.setValue(10); // Changes made to the object's state affect the original object
  }
  

2.5.8. Returning Values

#

Methods can return values using the return statement.

• The return statement exits the method and sends a value back to where the method was called.
• The return type in the method signature must match the data type of the value being returned.
• Methods with a void return type don’t return anything.

public int add(int a, int b) {
    return a + b;
}

These concepts help in organizing code, improving code reusability, and managing resources effectively in Java programs.

2.6. Constructors

#

A constructor in Java is a special method that is used to initialize objects. The constructor is called when an object of a class is created. It can be used to set initial values for object attributes

• Have the same name as the class.
• Do not have a return type, not even void.

// Create a Main class
public class Main {
  int x;  // Create a class attribute
  // Create a class constructor for the Main class
  public Main() {
    x = 5;  // Set the initial value for the class attribute x
  }
    
  public static void main(String[] args) {
    Main myObj = new Main(); // Create an object of class Main (This will call the constructor)
    System.out.println(myObj.x); // Print the value of x
  }
}

// Outputs 5