Java - Basics To Advanced

Java Roadmap Basics to Advanced
java roadmap to revise from basic concepts to advanced concepts ..include all topics
Here's a comprehensive Java roadmap that covers topics from basic to advanced concepts. This
roadmap is designed to help you revise your knowledge systematically.
1. Basics of Java
1.1. Introduction to Java
History and features of Java

Java Development Kit (JDK), Java Runtime Environment (JRE), and Java Virtual Machine (JVM)
Setting up the environment (Installation of JDK and IDE)
1.2. Basic Syntax
Structure of a Java program

Naming conventions
Keywords in Java
1.3. Data Types and Variables
Primitive data types (int, char, float, boolean, etc.)

Non-primitive data types (Strings, Arrays, etc.)
Type conversion and casting
Constants and final keyword
1.4. Operators
Arithmetic, Relational, Logical, Bitwise, and Assignment operators

Operator precedence and associativity
1.5. Control Statements
Decision-making (if, if-else, switch-case)

Looping statements (for, while, do-while)
Branching statements (break, continue, return)
1.6. Arrays
Single-dimensional arrays
Multidimensional arrays
Array manipulation
Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 1/60
2. Object-Oriented Programming (OOP)
2.1. Classes and Objects
Defining a class
Creating objects
Constructors (default, parameterized, and copy constructors)
2.2. Encapsulation
Access modifiers (private, public, protected, default)

Getters and setters
Benefits of encapsulation
2.3. Inheritance
Superclass and subclass

Method overriding
`super` keyword
Types of inheritance (single, multilevel, hierarchical)
2.4. Polymorphism
Compile-time polymorphism (method overloading)

Runtime polymorphism (method overriding)
Type casting with polymorphism
ìnstanceof` keyword
2.5. Abstraction
Abstract classes and methods

Interfaces
Difference between abstract class and interface
2.6. Inner Classes
Static inner class

Non-static inner class
Anonymous inner class
Local inner class
3. Advanced OOP Concepts

3.1. Packages
Built-in packages (java.lang, java.util, etc.)

User-defined packages
Importing packages
3.2. Exception Handling
Types of exceptions (checked and unchecked)
try-catch block
finally block
throw and throws keywords
Custom exceptions
3.3. File Handling
File I/O with `java.io` package

Reading and writing text files
FileReader, FileWriter, BufferedReader, BufferedWriter
Serialization and Deserialization
3.4. Multithreading and Concurrency
Creating threads using `Thread` class and `Runnable` interface

Thread lifecycle
Synchronization
Inter-thread communication (wait, notify, notifyAll)
Deadlock and how to avoid it
Executor framework
Concurrency utilities (`java.util.concurrent` package)
4. Collections Framework
4.1. Introduction to Collections
What is the Collections Framework?

Advantages over arrays
Commonly used interfaces (List, Set, Map)
4.2. List Interface
ArrayList, LinkedList, Vector, Stack

Operations (adding, removing, iterating)
4.3. Set Interface
HashSet, LinkedHashSet, TreeSet

Properties and operations
4.4. Map Interface
HashMap, LinkedHashMap, TreeMap, Hashtable

Key-value pairs, entry set
Iterating over a map
4.5. Queue Interface
PriorityQueue, LinkedList as Queue

Deque interface (ArrayDeque)
4.6. Utility Classes
Collections class (sorting, searching, etc.)

Arrays class (operations on arrays)
5. Java 8 and Beyond (Modern Java Features)

5.1. Functional Programming
Lambda expressions
Functional interfaces (Predicate, Consumer, Supplier, Function)
Method references
Constructor references
5.2. Stream API
Stream creation
Intermediate operations (filter, map, distinct, sorted, etc.)
Terminal operations (forEach, collect, reduce, etc.)
5.3. Optional Class
Handling null values

Creating and using Optional
Methods (isPresent, ifPresent, orElse, orElseGet, orElseThrow)
5.4. Date and Time API
`java.time` package
LocalDate, LocalTime, LocalDateTime, ZonedDateTime
Formatting and parsing dates
5.5. Default and Static Methods in Interfaces
Usage and purpose

Multiple inheritance problem with default methods
5.6. Nashorn JavaScript Engine
Introduction and use
6. Advanced Topics
6.1. Java Reflection API
Inspecting classes, interfaces, constructors, and methods at runtime

Creating objects and invoking methods dynamically
6.2. Java Annotations
Built-in annotations (@Override, @Deprecated, @SuppressWarnings)
Custom annotations
Annotations with reflection
6.3. Java Generics
Type parameters in classes, methods, and interfaces

Wildcards and bounds (`? extends`, `? super`)
Generic methods and constructors
6.4. Java Networking
Sockets and ServerSockets

URL and HttpURLConnection classes
Datagram and UDP communication
6.5. Java Database Connectivity (JDBC)
Connecting to a database
Executing SQL queries
ResultSet, Statement, PreparedStatement
Transactions and batch processing
6.6. JavaFX (Optional)
Building GUI applications

Scene graph, Stage, and Scene
Event handling and animations
7. Design Patterns
Singleton
Factory Method
Abstract Factory
Observer
Strategy
Builder
Prototype
Adapter, etc.
8. Testing in Java
JUnit basics
Writing test cases
Mocking with Mockito
Integration testing
9. Microservices and Spring Framework (Advanced)

9.1. Spring Core
Dependency injection and inversion of control
Bean lifecycle and scopes
9.2. Spring Boot
Building RESTful web services

Spring Data JPA
Spring Security
Microservices with Spring Cloud
9.3. Spring MVC
Building web applications

Controllers, views, and models
9.4. Spring Security
Authentication and authorization

OAuth2, JWT
10. Miscellaneous
Logging with Log4j or SLF4J
Memory management and garbage collection
Java Native Interface (JNI)
This roadmap should provide a structured approach to revising Java from basic to advanced topics.
Feel free to dive deeper into any specific area as needed!

History and features of Java
Java Development Kit (JDK), Java Runtime Environment (JRE), and Java Virtual Machine (JVM)
Setting up the environment (Installation of JDK and IDE)
1.1.1 History and Features of Java
1.1.1.1 History of Java:
1991: Java was originally developed by James Gosling, Mike Sheridan, and Patrick Naughton at
Sun Microsystems. It was initially called "Oak" after an oak tree outside Gosling's office.
1995: The name was changed to "Java," inspired by Java coffee. Sun Microsystems officially
launched Java 1.0, promoting it as "write once, run anywhere."
2009: Oracle Corporation acquired Sun Microsystems, and thus, Java became part of Oracle's
products.
Present: Java has evolved over the years, with numerous versions released, adding significant
new features and improvements.
1.1.1.2 Features of Java:
1. Simple: Java's syntax is similar to C++ but with simplified features. It removes complex features
like pointers and multiple inheritance.
2. Object-Oriented: Everything in Java is associated with objects and classes, which helps in
organizing the program into a clear structure.
3. Portable: Java code is platform-independent thanks to the bytecode generated by the compiler,
which can be run on any system with a JVM.
4. Platform Independent: Java programs are compiled into bytecode that can run on any platform
with a JVM, making it platform-independent.
5. Secure: Java has built-in security features like bytecode verification, exception handling, and
sandboxing to protect against malicious code.
6. Robust: Java emphasizes strong memory management, exception handling, and garbage
collection, reducing the chances of crashes and exceptions.
7. Multithreaded: Java supports multithreading, allowing the development of programs that can
perform multiple tasks simultaneously.
8. Architecture-neutral: The compiled bytecode is machine-independent, making Java applications
portable across different architectures.
9. Interpreted and High Performance: Java uses an intermediate bytecode format that is then
executed by the JVM, providing faster performance.
10. Dynamic: Java can dynamically load classes at runtime, which means it can support changes and
enhancements on the fly.
1.1.2 Java Development Kit (JDK), Java Runtime Environment (JRE), and Java Virtual Machine
(JVM)
1.1.2.1 Java Virtual Machine (JVM):
JVM is an abstract machine that provides a runtime environment to execute Java bytecode.
It is platform-dependent, meaning each operating system has its own JVM implementation.
JVM performs tasks such as loading code, verifying code, executing code, and providing runtime
environment.
Components of JVM:
Class Loader: Loads class files into memory.

Memory Area: Divided into several sections like Heap, Stack, Method Area, and others to
manage memory effectively.
Execution Engine: Executes the bytecode, which includes an interpreter and Just-In-Time (JIT)
compiler.
Garbage Collector: Automatically deallocates memory for objects that are no longer in use.
1.1.2.2 Java Runtime Environment (JRE):
JRE provides the libraries, Java Virtual Machine, and other components to run Java applications.
It does not contain any development tools like a compiler or debugger; it's mainly for executing
Java applications.
1.1.2.3 Java Development Kit (JDK):
JDK is a superset of JRE, containing everything needed to compile, run, and debug Java
applications.
It includes the JRE along with tools like the Java compiler (`javac`), Java archiver (`jar`), and
others for development.
Components of JDK:
Java Compiler (`javac`): Converts Java source code into bytecode.

Java Launcher (`java`): Launches the Java application by invoking the JVM.
Jar Tool (`jar`): Packs and unpacks archive files.
Debugger (`jdb`): Helps in debugging Java programs.
1.1.3 Setting Up the Environment (Installation of JDK and IDE)
1.1.3.1 Installing the JDK:
1. Download the JDK:

Go to the Oracle JDK download page or the OpenJDK page.
Choose the appropriate version for your operating system.
2. Install the JDK:
Run the installer and follow the on-screen instructions.
During installation, you can set the installation directory (e.g., `C:\Program Files\Java\jdk-
17`).
3. Set Environment Variables:
Add the JDK `bin` directory to your system's `PATH` variable (e.g., `C:\Program
Files\Java\jdk-17\bin`).
On Windows:
1. Right-click `This PC` -> `Properties` -> Àdvanced system settings` -> Ènvironment
Variables`.
2. Under System Variables, find `Path`, click Edit, and add the JDK bin path.
On macOS/Linux, add the following to your `~/.bash_profile` or `~/.bashrc`:
bash
export JAVA_HOME="/Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home"
export PATH="$JAVA_HOME/bin:$PATH"
4. Verify Installation:
Open a terminal or command prompt and type:
bash
java -version
javac -version
You should see the installed version details.
1.1.3.2 Installing an IDE:
1. Choosing an IDE:
Eclipse IDE: Powerful and extensible. Suitable for large projects.
IntelliJ IDEA: Offers smart code completion and a wide range of plugins.
NetBeans: A versatile IDE with excellent support for Java SE, Java EE, and more.
2. Download and Install:
Go to the official website of the chosen IDE and download the installer.
Run the installer and follow the instructions to complete the installation.
3. Setting Up the IDE:
Configure the JDK in the IDE. In most IDEs, this can be done in the settings under "Project
Structure" or "Java SDK."
4. Create a Sample Java Project:
Create a new Java project in your IDE to ensure everything is set up correctly.
Write a simple program like "Hello, World!" to test the setup.
java
public class HelloWorld {

public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Compile and run the program in your IDE to ensure everything is working.
This section should give you a solid foundation for starting with Java. Let me know if you want more
details on any particular subtopic!
1.2. Basic Syntax

Structure of a Java program
Naming conventions
Keywords in Java
Primitive data types (int, char, float, boolean, etc.)
Non-primitive data types (Strings, Arrays, etc.)
Type conversion and casting
Constants and final keyword
1.4. Operators
Arithmetic, Relational, Logical, Bitwise, and Assignment operators
Operator precedence and associativity
Decision-making (if, if-else, switch-case)
Looping statements (for, while, do-while)
Branching statements (break, continue, return)
1.2. Basic Syntax
1.2.1 Structure of a Java Program
A typical Java program consists of a collection of classes and methods. Here is the basic structure of a
Java program:
java
// Package declaration (optional)

package com.example;
// Import statements (optional)

import java.util.Scanner;
// Class declaration
public class Main {
// Main method: Entry point of the program

public static void main(String[] args) {
// Statement: A single instruction to be executed

}
}
Components:
1. Package Declaration: Defines the package to which the class belongs. It's optional but
recommended for better organization.
2. Import Statements: Used to include external classes or entire packages to be used in the
program.
3. Class Declaration: Every Java program must have at least one class. The class name should
match the filename.
4. Main Method: The entry point of a Java application. It must have the signature `public static
void main(String[] args)`.
5. Statements: These are the instructions executed within methods. Each statement ends with a
semicolon (`;`).
1.2.2 Naming Conventions
Class Names: Start with an uppercase letter, and follow camel case. For example, `MyClass`,
`HelloWorld`.
Method Names: Start with a lowercase letter, and follow camel case. For example,
`calculateSum()`, `printMessage()`.
Variable Names: Start with a lowercase letter, and follow camel case. For example, àge`,
èmployeeName`.
Constant Names: Use all uppercase letters with underscores separating words. For example,
`PI`, `MAX_VALUE`.
Package Names: Use all lowercase letters. For example, `com.example`,
òrg.companyname.project`.
1.2.3 Keywords in Java
Java has 52 reserved keywords. These keywords have predefined meanings and cannot be used for
naming variables, methods, or classes. Some examples include:
Data Types: ìnt`, `float`, `char`, `boolean`, `double`, etc.
Control Statements: ìf`, èlse`, `switch`, `case`, `for`, `while`, `do`, `break`, `continue`, etc.
Modifiers: `public`, `private`, `protected`, `static`, `final`, àbstract`, `synchronized`, etc.
Exception Handling: `try`, `catch`, `finally`, `throw`, `throws`.
Class Related: `class`, ìnterface`, èxtends`, ìmplements`, `package`, ìmport`.
Others: `return`, `void`, `this`, `super`, `new`, ìnstanceof`, etc.
1.3.1 Primitive Data Types
Java has 8 primitive data types:
1. byte:
Size: 1 byte (8 bits)
Range: -128 to 127
Example: `byte age = 30;`
2. short:
Size: 2 bytes (16 bits)
Range: -32,768 to 32,767
Example: `short distance = 150;`
3. int:
Range: -2,147,483,648 to 2,147,483,647
Example: ìnt salary = 50000;`
4. long:
Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
Example: `long population = 7800000000L;`
5. float:
Precision: 7 decimal digits
Example: `float temperature = 36.6f;`
6. double:
Precision: 15 decimal digits
Example: `double price = 19.99;`
7. char:
Size: 2 bytes (16 bits, Unicode)
Range: `'\u0000'` (0) to `'\uffff'` (65,535)
Example: `char grade = 'A';`
8. boolean:
Size: 1 bit
Values: `true` or `false`
Example: `boolean isJavaFun = true;`
1.3.2 Non-Primitive Data Types
1. String:
Represents a sequence of characters.
Example: `String name = "John Doe";`
2. Array:
A collection of elements of the same type.
Example: ìnt[] numbers = {1, 2, 3, 4, 5};`
3. Classes, Interfaces, and Enums:
Custom data types defined by the user.
Example: `Person person = new Person();`
1.3.3 Type Conversion and Casting
Implicit Conversion: Automatic conversion by the compiler, e.g., ìnt` to `double`.
java
int x = 10;
double y = x; // Implicit conversion
Explicit Casting: Manual conversion by the programmer, e.g., `double` to ìnt`.
java
double a = 9.8;
int b = (int) a; // Explicit casting
1.3.4 Constants and Final Keyword
Constants: Fixed values that do not change during the execution of a program.
`final` Keyword:
Used to declare constants, prevent method overriding, and inheritance.
Example:
java
final int MAX_HEIGHT = 100;
1.4. Operators
1.4.1 Arithmetic Operators
Used for performing basic arithmetic operations:
Addition (`+`): Adds two values.

Subtraction (`-`): Subtracts one value from another.
Multiplication (`*`): Multiplies two values.
Division (`/`): Divides one value by another.
Modulus (`%`): Returns the remainder of division.
Example:
java
int a = 10, b = 5;
System.out.println("a + b = " + (a + b)); // 15
System.out.println("a - b = " + (a - b)); // 5
System.out.println("a * b = " + (a * b)); // 50
System.out.println("a / b = " + (a / b)); // 2
System.out.println("a % b = " + (a % b)); // 0
1.4.2 Relational Operators
Used to compare two values:
Equal to (`==`)
Not equal to (`!=`)
Greater than (`>`)
Less than (`<`)
Greater than or equal to (`>=`)
Less than or equal to (`<=`)
Example:
java
int x = 10, y = 20;

System.out.println(x > y); // false
System.out.println(x < y); // true
System.out.println(x == y); // false
System.out.println(x != y); // true
1.4.3 Logical Operators
Used for logical operations:
Logical AND (`&&`)

Logical OR (`||`)
Logical NOT (`!`)
Example:
java
boolean a = true, b = false;

System.out.println(a && b); // false
System.out.println(a || b); // true
System.out.println(!a); // false
1.4.4 Bitwise Operators
Operate on binary numbers:
Bitwise AND (`&`)

Bitwise OR (`|`)
Bitwise XOR (`^`)
Bitwise NOT (`~`)
Left Shift (`<<`)
Right Shift (`>>`)
Example:
java
int a = 5, b = 3; // a = 0101, b = 0011 in binary

System.out.println(a & b); // 1 (0001)
System.out.println(a | b); // 7 (0111)
System.out.println(a ^ b); // 6 (0110)
System.out.println(~a); // -6 (Two's complement of 5)
1.4.5 Assignment Operators
Used to assign values to variables:
`=` (Simple assignment)

`+=` (Add and assign)
`-=` (Subtract and assign)
`*=` (Multiply and assign)
`/=` (Divide and assign)
Example:
java
int x = 10;
x += 5; // x = x + 5 = 15
x -= 2; // x = x - 2 = 13
x *= 3; // x = x * 3 = 39
x /= 3; // x = x / 3 = 13
1.4.6 Operator Precedence and Associativity
Precedence: Determines the order in which operators are evaluated.

For example, multiplication (`*`) and division (`/`) have higher precedence than addition
(`+`) and subtraction (`-`).
Associativity: Determines the order in which operators of the same precedence are evaluated.
Most operators have left-to-right associativity.
Example:
java
int result = 2 + 3 * 4; // 14 (3 * 4 is evaluated first)

int result2 = (2 + 3) * 4; // 20 (2 + 3 is evaluated first)
1.5.1 Decision-Making Statements
ìf` Statement:
java
int age = 18;

if (age >= 18) {
System.out.println("You are an adult.");
}
ìf-else` Statement:
java
int marks = 40;

if (marks >= 50) {
System.out.println("Pass");
} else {
System.out.println("Fail");
}
èlse-if` Ladder:
java
int marks = 75;

if (marks >= 90) {
System.out.println("Grade A");
} else if (marks >= 75) {
System.out.println("Grade B");
} else if (marks >= 60) {
System.out.println("Grade C");
} else {
System.out.println("Fail");
}
`switch-case` Statement:
java
int day = 2;
switch (day) {
case 1:
System.out.println("Sunday");
break;
case 2:
System.out.println("Monday");
break;
case 3:
System.out.println("Tuesday");
break;
default:
System.out.println("Invalid day");
}
1.5.2 Looping Statements
`for` Loop:
java
for (int i = 1; i <= 5; i++) {

}
`while` Loop:
java
int i = 1;
while (i <= 5) {
i++;
}
`do-while` Loop:
java
int i = 1;
do {
i++;
} while (i <= 5);
1.5.3 Branching Statements
`break`: Terminates the loop or switch statement.
java
for (int i = 1; i <= 5; i++) {

if (i == 3) {
break; // Exit the loop
}
System.out.println(i);
}
// Output: 1 2
`continue`: Skips the current iteration and continues with the next iteration of the loop.
java
for (int i = 1; i <= 5; i++) {

if (i == 3) {
continue; // Skip this iteration
}
System.out.println(i);
}
// Output: 1 2 4 5
`return`: Exits from the current method and optionally returns a value.
java
public int sum(int a, int b) {

return a + b; // Return the sum
}
This covers the basics of Java syntax, data types, operators, and control statements.
1.6. Arrays
Single-dimensional arrays
Multidimensional arrays
Array manipulation
1.6. Arrays
Arrays in Java are used to store multiple values of the same data type in a single variable. They are
useful when you need to work with a collection of elements, such as numbers, strings, or objects.
Arrays in Java are objects that store elements in contiguous memory locations.
1.6.1 Single-Dimensional Arrays
A single-dimensional array is a list of elements of the same type, accessible using an index.
Declaration, Instantiation, and Initialization
Declaration: `dataType[] arrayName;`

Instantiation: àrrayName = new dataType[size];`
Initialization: àrrayName[index] = value;`
Example:
java
// Declaration and Instantiation

int[] numbers = new int[5];
// Initialization
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
// Alternatively, Declaration, Instantiation, and Initialization in one line

int[] nums = {10, 20, 30, 40, 50};
// Accessing elements
System.out.println(numbers[2]); // Output: 30
Iterating through an Array:
java
// Using a traditional for loop

for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
// Using an enhanced for loop (for-each)

for (int num : numbers) {
System.out.println(num);
}
Common Operations:
Finding the length of an array:
java
int length = numbers.length; // Output: 5
Accessing elements:
java
int firstElement = numbers[0]; // Output: 10
Modifying elements:
java
numbers[1] = 25; // Changes value at index 1 to 25
1.6.2 Multidimensional Arrays

Multidimensional arrays are arrays of arrays. The most commonly used multidimensional arrays are
two-dimensional arrays, which can be thought of as a table with rows and columns.
Declaration, Instantiation, and Initialization
Declaration: `dataType[][] arrayName;`

Instantiation: àrrayName = new dataType[rows][columns];`
Initialization: àrrayName[rowIndex][columnIndex] = value;`
Example (2D Array):
java
// Declaration and Instantiation

int[][] matrix = new int[3][3];
// Initialization
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[1][0] = 4;
matrix[1][1] = 5;
matrix[1][2] = 6;
matrix[2][0] = 7;
matrix[2][1] = 8;
matrix[2][2] = 9;
// Alternatively, Declaration, Instantiation, and Initialization in one line

int[][] grid = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Accessing elements
System.out.println(matrix[1][1]); // Output: 5
Iterating through a 2D Array:
java
// Using a nested for loop

for (int i = 0; i < matrix.length; i++) { // loop through rows
for (int j = 0; j < matrix[i].length; j++) { // loop through columns
System.out.print(matrix[i][j] + " ");
}
System.out.println(); // Move to the next line after each row
}
// Using an enhanced for loop (for-each)

for (int[] row : matrix) {
for (int element : row) {
System.out.print(element + " ");
}
System.out.println();
}
Common Operations:
Finding the number of rows:
java
int rows = matrix.length; // Output: 3
Finding the number of columns in a row:
java
int columns = matrix[0].length; // Output: 3
Accessing elements:
java
int element = matrix[2][1]; // Output: 8
Modifying elements:
java
matrix[0][2] = 100; // Changes value at index (0, 2) to 100
1.6.3 Array Manipulation
Java provides several utility methods in the `java.util.Arrays` class to manipulate arrays efficiently.
Sorting Arrays
You can sort arrays using the Àrrays.sort()` method.
java
int[] numbers = {5, 3, 8, 1, 2};

Arrays.sort(numbers); // Array becomes {1, 2, 3, 5, 8}
// Sorting in descending order using a custom comparator (for reference types)

Integer[] nums = {5, 3, 8, 1, 2};
Arrays.sort(nums, Collections.reverseOrder()); // Array becomes {8, 5, 3, 2, 1}
Searching Arrays
You can search for an element in a sorted array using the Àrrays.binarySearch()` method.
java
int index = Arrays.binarySearch(numbers, 3); // Output: 2 (index of element 3 in sorted

array)
Filling Arrays
You can fill arrays with a specific value using the Àrrays.fill()` method.
java
int[] filledArray = new int[5];

Arrays.fill(filledArray, 9); // Array becomes {9, 9, 9, 9, 9}
Copying Arrays
You can create a copy of an array using the Àrrays.copyOf()` method.
java
int[] copyArray = Arrays.copyOf(numbers, numbers.length); // Copies all elements

int[] partialCopy = Arrays.copyOf(numbers, 3); // Copies first 3 elements
Converting Arrays to Strings
You can convert an array to a string representation using the Àrrays.toString()` method.
java
System.out.println(Arrays.toString(numbers)); // Output: [1, 2, 3, 5, 8]
Comparing Arrays
You can compare two arrays for equality using the Àrrays.equals()` method.
java
int[] array1 = {1, 2, 3};

int[] array2 = {1, 2, 3};
System.out.println(Arrays.equals(array1, array2)); // Output: true
Multi-Dimensional Array Manipulation
For 2D arrays, you can use Àrrays.deepToString()` and Àrrays.deepEquals()` for more complex
structures.
Example:
java
int[][] matrix1 = {{1, 2}, {3, 4}};

int[][] matrix2 = {{1, 2}, {3, 4}};
// Printing a 2D array
System.out.println(Arrays.deepToString(matrix1)); // Output: [[1, 2], [3, 4]]
// Comparing 2D arrays
System.out.println(Arrays.deepEquals(matrix1, matrix2)); // Output: true
This concludes the overview of arrays in Java, covering single-dimensional and multidimensional
arrays, as well as various operations and manipulations you can perform on them.

Defining a class
Creating objects
Constructors (default, parameterized, and copy constructors)
2.2. Encapsulation
Access modifiers (private, public, protected, default)
Getters and setters
Benefits of encapsulation
2.3. Inheritance
Superclass and subclass
Method overriding
super keyword
Types of inheritance (single, multilevel, hierarchical)
2.1.1 Defining a Class
A class in Java is a blueprint for creating objects. It contains fields (variables) and methods to define
the properties and behaviors of an object.
Syntax:
java
class ClassName {
// Fields (Attributes)
int attribute1;
String attribute2;
// Methods (Behaviors)
void method1() {
// Method implementation
}
}
Example:
java
class Car {
// Fields
String color;
String model;
int year;
// Method
void displayInfo() {
System.out.println("Model: " + model);
System.out.println("Color: " + color);
System.out.println("Year: " + year);
}
}
2.1.2 Creating Objects
Objects are instances of a class. An object is created using the `new` keyword, which invokes the class
constructor.
Syntax:
java
ClassName objectName = new ClassName();
Example:
java
Car myCar = new Car(); // Creating an object of the Car class

myCar.model = "Toyota"; // Setting the model attribute
myCar.color = "Red"; // Setting the color attribute
myCar.year = 2021; // Setting the year attribute
myCar.displayInfo(); // Calling the method
2.1.3 Constructors
Constructors are special methods used to initialize objects. They have the same name as the class and
do not have a return type.
Types of Constructors:
1. Default Constructor: A no-argument constructor provided by Java if no other constructor is

defined. Initializes default values.
java
class Car {
// Default constructor
Car() {
System.out.println("Car object created!");
}
}
2. Parameterized Constructor: A constructor that takes arguments to initialize the object with
specific values.
java
class Car {
String model;
String color;
int year;
// Parameterized constructor
Car(String m, String c, int y) {
model = m;
color = c;
year = y;
}
}
Car myCar = new Car("Toyota", "Red", 2021); // Using parameterized constructor
3. Copy Constructor: A constructor that creates an object by copying the fields of another object.
java
class Car {
String model;
String color;
int year;
// Copy constructor
Car(Car c) {
model = c.model;
color = c.color;
year = c.year;
}
}
Car car1 = new Car("Toyota", "Red", 2021);

Car car2 = new Car(car1); // Using copy constructor
2.2. Encapsulation
Encapsulation is the process of wrapping data (fields) and methods into a single unit called a class. It
restricts direct access to certain components and can be used to hide the internal representation of an
object.
2.2.1 Access Modifiers
Access modifiers define the accessibility of classes, methods, and variables.
`private`: Accessible only within the same class.

`default` (no modifier): Accessible within the same package.
`protected`: Accessible within the same package and subclasses.
`public`: Accessible from any class.
Example:
java
class Car {
private String model; // Private variable
private int year;
// Public getter and setter methods

public String getModel() {
return model;
}
public void setModel(String model) {

this.model = model;
}
public int getYear() {

return year;
}
public void setYear(int year) {

this.year = year;
}
}
2.2.2 Getters and Setters
Getters and setters are methods used to access and update the private fields of a class. They provide
controlled access to class properties.
Example:
java
class Car {
private String model;
private int year;
// Getter for model

public String getModel() {
return model;
}
// Setter for model

public void setModel(String model) {
this.model = model;
}
// Getter for year

public int getYear() {
return year;
}
// Setter for year

public void setYear(int year) {
this.year = year;
}
}
Usage:
java
Car myCar = new Car();

myCar.setModel("Toyota");
myCar.setYear(2021);
System.out.println("Model: " + myCar.getModel());
System.out.println("Year: " + myCar.getYear());
2.2.3 Benefits of Encapsulation
Data Hiding: Restricts direct access to fields, protecting the integrity of the data.
Control Over Data: Provides controlled access through getters and setters.
Flexibility and Maintenance: Internal changes to fields do not affect the external code, as long
as the getters and setters remain the same.
2.3. Inheritance
Inheritance allows a class (subclass/child class) to inherit properties and methods from another class
(superclass/parent class). It promotes code reusability and establishes a relationship between classes.
2.3.1 Superclass and Subclass
Superclass (Parent Class): The class whose properties and methods are inherited.
Subclass (Child Class): The class that inherits properties and methods from the superclass.
Syntax:
java
class Superclass {
// Superclass fields and methods
}
class Subclass extends Superclass {

// Subclass fields and methods
}
Example:
java
class Vehicle {
int speed;
void displaySpeed() {
System.out.println("Speed: " + speed);
}
}
class Car extends Vehicle {

int doors;
void displayCarInfo() {
System.out.println("Doors: " + doors);
}
}
Car myCar = new Car();
myCar.speed = 100; // Inherited from Vehicle
myCar.doors = 4; // Specific to Car
myCar.displaySpeed(); // Output: Speed: 100
myCar.displayCarInfo(); // Output: Doors: 4
2.3.2 Method Overriding
Method overriding allows a subclass to provide a specific implementation for a method already
defined in its superclass.
Syntax:
java
@Override
void methodName() {
// New implementation
}
Example:
java
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {

@Override
void sound() {
System.out.println("Dog barks");
}
}
Dog myDog = new Dog();

myDog.sound(); // Output: Dog barks
2.3.3 `super` Keyword
The `super` keyword is used to refer to the superclass's methods or constructor.
Calling Superclass Method:
java
class Animal {
void sound() {
}
}

void sound() {
super.sound(); // Call superclass method
}
}

myDog.sound(); // Output: Animal makes a sound Dog barks
Calling Superclass Constructor:
java
class Animal {
Animal() {
System.out.println("Animal constructor");
}
}

Dog() {
super(); // Call superclass constructor
System.out.println("Dog constructor");
}
}
Dog myDog = new Dog(); // Output: Animal constructor Dog constructor
2.3.4 Types of Inheritance
1. Single Inheritance: A subclass inherits from a single superclass.
java
class A {
// Parent class
}
class B extends A {
// Child class
}
2. Multilevel Inheritance: A subclass inherits from a superclass, and another class inherits from
this subclass.
java
class A {
// Parent class
}
class B extends A {
// Child class
}
class C extends B {
// Grandchild class
}
3. Hierarchical Inheritance: Multiple subclasses inherit from a single superclass.
java
class A {
// Parent class
}
class B extends A {
// Child class 1
}
class C extends A {
// Child class 2
}
Note: Java does not support multiple inheritance (a class cannot inherit from more than one
class) to avoid ambiguity and complexity.
This concludes the overview of classes, objects, encapsulation, and inheritance in Java, including
constructors and the `super` keyword.
2.4. Polymorphism
Compile-time polymorphism (method overloading)
Runtime polymorphism (method overriding)
Type casting with polymorphism
instanceof keyword
2.5. Abstraction
Abstract classes and methods
Interfaces
Difference between abstract class and interface
2.6. Inner Classes
Static inner class
Non-static inner class
Anonymous inner class
Local inner class
2.4. Polymorphism
Polymorphism is the ability of an object to take on multiple forms. It allows one interface to be used
for a general class of actions, making code more flexible and reusable.
2.4.1 Compile-Time Polymorphism (Method Overloading)
Method overloading occurs when multiple methods in the same class have the same name but
different parameters (different type, number, or both). The compiler determines which method to
invoke based on the method signature.
Example:
java
class Calculator {
// Method to add two integers
int add(int a, int b) {
return a + b;
}
// Overloaded method to add three integers

int add(int a, int b, int c) {
return a + b + c;
}
// Overloaded method to add two double values

double add(double a, double b) {
return a + b;
}
}
Calculator calc = new Calculator();

System.out.println(calc.add(10, 20)); // Output: 30
System.out.println(calc.add(10, 20, 30)); // Output: 60
System.out.println(calc.add(10.5, 20.5)); // Output: 31.0
2.4.2 Runtime Polymorphism (Method Overriding)
Method overriding occurs when a subclass provides a specific implementation of a method that is
already defined in its superclass. The method in the subclass must have the same name, return type,
and parameters as the method in the superclass.
Example:
java
class Animal {
void sound() {
}
}

@Override
void sound() {
}
}
Animal myDog = new Dog();

Here, the `sound()` method in the `Dog` class overrides the `sound()` method in the Ànimal` class.
The method call is resolved at runtime based on the object type.
2.4.3 Type Casting with Polymorphism
Type casting is used to change one object reference type to another. It is commonly used in
polymorphism to access subclass methods from a superclass reference.
Upcasting: Converting a subclass reference to a superclass reference.
java
Dog dog = new Dog();

Animal animal = (Animal) dog; // Upcasting
animal.sound(); // Output: Dog barks
Downcasting: Converting a superclass reference back to a subclass reference.
java
Animal animal = new Dog();

Dog dog = (Dog) animal; // Downcasting
dog.sound(); // Output: Dog barks
Note: Downcasting should be done with caution and often requires a type check using the
ìnstanceof` keyword.
2.4.4 ìnstanceof` Keyword
The ìnstanceof` keyword is used to check whether an object is an instance of a specific class or
subclass.
Example:
java
Animal animal = new Dog();
if (animal instanceof Dog) {

Dog dog = (Dog) animal; // Downcasting
System.out.println("The animal is a Dog");
} else {
System.out.println("The animal is not a Dog");
}
Output: `The animal is a Dog`
2.5. Abstraction
Abstraction is the process of hiding the implementation details and showing only the essential
features of an object. It can be achieved using abstract classes and interfaces.
2.5.1 Abstract Classes and Methods
An abstract class is a class that cannot be instantiated. It can have both abstract methods (without
implementation) and concrete methods (with implementation).
Syntax:
java
abstract class Animal {

// Abstract method (no implementation)
abstract void sound();
// Concrete method (with implementation)

void sleep() {
System.out.println("Animal is sleeping");
}
}
A subclass must provide implementations for all abstract methods of the abstract class.
Example:
java

}

@Override
void sound() {
}
}

2.5.2 Interfaces
An interface is a reference type in Java that can contain only constants, method signatures, default
methods, static methods, and nested types. It represents a contract that a class must follow by
implementing all abstract methods.
Syntax:
java
interface Animal {
void sound(); // Abstract method
}
A class can implement multiple interfaces.

Example:
java
interface Animal {
void sound();
}
interface Pet {
void play();
}
class Dog implements Animal, Pet {

@Override
public void sound() {
}
@Override
public void play() {
System.out.println("Dog is playing");
}
}

myDog.play(); // Output: Dog is playing
2.5.3 Difference Between Abstract Class and Interface
Feature Abstract Class Interface

Can have both abstract and Can have only abstract methods (Java 8+ allows
Methods
concrete methods default and static methods)
Variables Can have instance variables Only static and final variables
Constructors Can have constructors Cannot have constructors

A class can extend only one
Inheritance A class can implement multiple interfaces
abstract class
Access
Can have any access modifier All methods are implicitly public and abstract
Modifiers
When you have shared state and
When to Use When you want to define a contract
behavior
2.6. Inner Classes
Inner classes are defined within another class and have access to its outer class members, including
private ones. They are used to logically group classes that will only be used in one place.
2.6.1 Static Inner Class
A static inner class is a nested class that does not have access to instance variables or methods of the
outer class. It can only access static members of the outer class.
Example:
java
class OuterClass {
static int staticVar = 10;
static class StaticInnerClass {

void display() {
System.out.println("Static variable: " + staticVar);
}
}
}
OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();

inner.display(); // Output: Static variable: 10
2.6.2 Non-static Inner Class
A non-static inner class has access to all members (including private) of the outer class. It requires an
instance of the outer class to be created.
Example:
java
class OuterClass {
int outerVar = 10;
class InnerClass {
void display() {
System.out.println("Outer variable: " + outerVar);
}
}
}
OuterClass outer = new OuterClass();

OuterClass.InnerClass inner = outer.new InnerClass();
inner.display(); // Output: Outer variable: 10
2.6.3 Anonymous Inner Class
An anonymous inner class is a class without a name that is used to instantiate an object with certain
"extras," such as overriding methods of a class or interface.
Example:
java

}
Animal myAnimal = new Animal() {

@Override
void sound() {
}
};
myAnimal.sound(); // Output: Animal makes a sound
2.6.4 Local Inner Class
A local inner class is defined inside a method and can only be instantiated within that method. It has
access to final or effectively final variables of the method.
Example:
java
class OuterClass {
void display() {
final int localVar = 10;
class LocalInnerClass {
void displayLocal() {
System.out.println("Local variable: " + localVar);
}
}
LocalInnerClass localInner = new LocalInnerClass();

localInner.displayLocal(); // Output: Local variable: 10
}
}
OuterClass outer = new OuterClass();

outer.display();
This covers the essential concepts of polymorphism, abstraction, and inner classes in Java, providing a
comprehensive understanding of each topic.
Advantages over arrays
Commonly used interfaces (List, Set, Map)
4.2. List Interface
ArrayList, LinkedList, Vector, Stack
Operations (adding, removing, iterating)
4.3. Set Interface
HashSet, LinkedHashSet, TreeSet
Properties and operations
4.4. Map Interface
HashMap, LinkedHashMap, TreeMap, Hashtable
Key-value pairs, entry set
Iterating over a map
PriorityQueue, LinkedList as Queue
Deque interface (ArrayDeque)
Collections class (sorting, searching, etc.)
Arrays class (operations on arrays)
The Java Collections Framework provides a set of classes and interfaces to manage a group of objects
as a single unit. It includes various data structures like lists, sets, maps, and queues.
A unified architecture for representing and manipulating collections of objects.

It includes interfaces and classes for storing, retrieving, and manipulating collections.
Advantages Over Arrays:

Dynamic Size: Collections can grow and shrink dynamically, unlike arrays which have a fixed size.
More Flexibility: Collections can store heterogeneous objects and provide better ways to
manipulate data.
Utility Methods: The framework provides many useful methods for sorting, searching, and
manipulating data.
Commonly Used Interfaces:
1. List: An ordered collection (also known as a sequence). Allows duplicates and provides indexed
access.
2. Set: A collection that does not allow duplicates.
3. Map: A collection of key-value pairs.
4. Queue: A collection designed for holding elements prior to processing.
4.2. List Interface
The `List` interface extends the `Collection` interface and represents an ordered collection.
Implementations:
ArrayList: A resizable array implementation. Allows random access, and it is good for retrieval
but not for insertion/deletion in the middle.
LinkedList: A doubly-linked list implementation. It is better for adding/removing elements in the
middle but slower for random access.
Vector: Synchronized version of ÀrrayList`. It is legacy and not preferred in new applications.
Stack: A subclass of `Vector` that implements a last-in, first-out (LIFO) stack.
Operations:
Adding Elements: àdd(element)`, àdd(index, element)`

Removing Elements: `remove(element)`, `remove(index)`
Iterating: Using Ìterator`, `forEach`, or for-each loop.
Example:
java
List<String> list = new ArrayList<>();

list.add("Apple");
list.add("Banana");
list.add(1, "Orange");
System.out.println(list); // Output: [Apple, Orange, Banana]
list.remove("Orange");
System.out.println(list); // Output: [Apple, Banana]
4.3. Set Interface
The `Set` interface extends the `Collection` interface and represents a collection that does not allow
duplicate elements.
Implementations:
HashSet: Backed by a hash table. It makes no guarantees about the iteration order.
LinkedHashSet: Maintains a linked list of entries, providing predictable iteration order.
TreeSet: Implements a `NavigableSet` backed by a `TreeMap`. It orders elements according to
their natural ordering or by a comparator.
Properties and Operations:
Adding Elements: àdd(element)` - Returns `false` if the element is already present.

Removing Elements: `remove(element)`
Checking Presence: `contains(element)`
Example:
java
Set<String> set = new HashSet<>();

set.add("Apple");
set.add("Banana");
set.add("Apple"); // Duplicate, won't be added
System.out.println(set); // Output: [Apple, Banana]
4.4. Map Interface
The `Map` interface represents a collection of key-value pairs, where each key is mapped to a single
value.
Implementations:
HashMap: A hash table-based implementation. Allows `null` keys and values.

LinkedHashMap: Extends `HashMap` and maintains a doubly-linked list of its entries. Maintains
the insertion order.
TreeMap: A `NavigableMap` implementation. The map is sorted according to the natural ordering
of its keys or by a comparator.
Hashtable: Synchronized version of `HashMap`. It does not allow `null` keys or values.
Key-Value Pairs and Entry Set:
Adding Elements: `put(key, value)`

Removing Elements: `remove(key)`
Accessing Elements: `get(key)`, `keySet()`, `values()`, èntrySet()`
Iterating Over a Map:
Using `forEach` and Èntry` set.
Example:
java
Map<Integer, String> map = new HashMap<>();

map.put(1, "One");
map.put(2, "Two");
map.put(3, "Three");
for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + " = " + entry.getValue());
}
// Output:
// 1 = One
// 2 = Two
// 3 = Three
The `Queue` interface is used for holding elements prior to processing, following the FIFO (first-in-first-
out) principle.
Implementations:
PriorityQueue: An unbounded priority queue based on a priority heap. The elements are
ordered according to their natural ordering or by a comparator.
LinkedList as Queue: Implements both `List` and `Deque` interfaces. Can be used as a queue.
Deque Interface (Double-Ended Queue):
ArrayDeque: A resizable array implementation of the `Deque` interface. It can be used as a
stack or a queue.
Operations:
Adding Elements: òffer(element)`, àdd(element)`

Removing Elements: `poll()`, `remove()`
Peeking Elements: `peek()`, èlement()`
Example:
java
Queue<String> queue = new LinkedList<>();

queue.offer("One");
queue.offer("Two");
queue.offer("Three");
System.out.println(queue.poll()); // Output: One

System.out.println(queue.peek()); // Output: Two
The `java.util.Collections` and `java.util.Arrays` classes provide various utility methods for
operating on collections and arrays.
Collections Class:
Sorting: `Collections.sort(list)` - Sorts the list in natural order.

Searching: `Collections.binarySearch(list, key)` - Searches for the key in the sorted list.
Reverse: `Collections.reverse(list)` - Reverses the order of the elements in the list.
Shuffling: `Collections.shuffle(list)` - Randomly permutes the elements in the list.
Example:
java
List<Integer> numbers = new ArrayList<>(Arrays.asList(4, 2, 5, 1, 3));

Collections.sort(numbers);
System.out.println(numbers); // Output: [1, 2, 3, 4, 5]
Collections.reverse(numbers);
System.out.println(numbers); // Output: [5, 4, 3, 2, 1]
Arrays Class:
Sorting: Àrrays.sort(array)` - Sorts the array in natural order.

Searching: Àrrays.binarySearch(array, key)` - Searches for the key in the sorted array.
Copying: Àrrays.copyOf(array, newLength)` - Copies the array to a new array of the specified
length.
Comparison: Àrrays.equals(array1, array2)` - Compares two arrays.
Example:
java
int[] numbers = {4, 2, 5, 1, 3};

Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // Output: [1, 2, 3, 4, 5]
int index = Arrays.binarySearch(numbers, 3);

System.out.println("Index of 3: " + index); // Output: Index of 3: 2
This covers the core concepts and operations related to the Collections Framework in Java, providing a
comprehensive understanding of each collection type and their respective implementations.

3.1. Packages
Built-in packages (java.lang, java.util, etc.)
User-defined packages
Importing packages
Types of exceptions (checked and unchecked)
try-catch block
finally block
throw and throws keywords
Custom exceptions
3.3. File Handling
File I/O with java.io package
Reading and writing text files
FileReader, FileWriter, BufferedReader, BufferedWriter
Serialization and Deserialization
Creating threads using Thread class and Runnable interface
Thread lifecycle
Synchronization
Inter-thread communication (wait, notify, notifyAll)
Deadlock and how to avoid it
Executor framework
Concurrency utilities (java.util.concurrent package)
This section focuses on advanced object-oriented programming concepts in Java, including packages,
exception handling, file handling, and multithreading.
3.1. Packages
Packages are used in Java to group related classes, interfaces, and sub-packages. They help in
avoiding name conflicts and provide controlled access and organization to code.
Built-in Packages:
1. `java.lang`: Contains fundamental classes like `String`, `Math`, `System`, Òbject`, etc.
2. `java.util`: Contains utility classes like ÀrrayList`, `HashMap`, `Collections`, `Date`, etc.
3. `java.io`: Provides classes for system input and output through data streams, serialization, and
file operations.
4. `java.nio`: Offers the non-blocking I/O facilities.
5. `java.net`: Contains classes for networking operations.
6. `java.sql`: Provides APIs for accessing and processing data stored in a relational database.
User-defined Packages:
User-defined packages can be created to organize your classes into related groups.
Creating a Package:
java
package com.example.myapp; // Package declaration must be the first statement
public class MyClass {

// Class implementation
}
Importing Packages:
Use the ìmport` keyword to access classes from a package.
java
import java.util.ArrayList;
import java.io.File;
Wildcard import to import all classes from a package:
java
import java.util.*;
Java's exception handling mechanism provides a robust way to handle runtime errors, ensuring the
flow of the program is not disrupted.
Types of Exceptions:
1. Checked Exceptions: Exceptions checked at compile-time. Examples: ÌOException`,

`SQLException`.
2. Unchecked Exceptions: Exceptions checked at runtime. Examples: `NullPointerException`,
ÀrithmeticException`.
try-catch Block:
The `try` block contains code that might throw an exception, while the `catch` block handles the
exception.
java
try {
int result = 10 / 0; // This will throw ArithmeticException
} catch (ArithmeticException e) {
System.out.println("Cannot divide by zero.");
}
finally Block:
The `finally` block always executes, regardless of whether an exception was thrown or not.
java
try {
// Code that may throw an exception
} catch (Exception e) {
// Exception handling
} finally {
// Cleanup code, always executed
}
throw and throws Keywords:
`throw`: Used to explicitly throw an exception.
`throws`:Used in the method signature to indicate that this method might throw the listed
exceptions.
java
void checkAge(int age) throws Exception {

if (age < 18) {
throw new Exception("Not eligible to vote");
}
}
Custom Exceptions:
User-defined exceptions can be created by extending the Èxception` class.
java
class InvalidAgeException extends Exception {

public InvalidAgeException(String message) {
super(message);
}
}
3.3. File Handling
File handling in Java allows reading from and writing to files using various classes in the `java.io`
package.
File I/O with `java.io` Package:
`File`:Represents a file or directory path.

`FileReader` & `FileWriter`: Used for reading and writing text files.
`BufferedReader` & `BufferedWriter`: Provide efficient reading and writing capabilities by
buffering characters.
Reading and Writing Text Files:

Reading with `BufferedReader`:
java
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {

String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
Writing with `BufferedWriter`:
java
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {

bw.write("Hello, World!");
bw.newLine(); // Adds a new line
bw.write("This is a test.");
}
Serialization and Deserialization:
Serialization: Process of converting an object into a byte stream for storage or transmission.
Deserialization: Process of converting a byte stream back into an object.
Implementing Serialization:
java
import java.io.Serializable;
class Employee implements Serializable {

private static final long serialVersionUID = 1L;
int id;
String name;
public Employee(int id, String name) {

this.id = id;
this.name = name;
}
}
Serializing an Object:
java
try (ObjectOutputStream oos = new ObjectOutputStream(new

FileOutputStream("employee.ser"))) {
Employee e = new Employee(101, "John Doe");
oos.writeObject(e);
}
Deserializing an Object:
java
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("employee.ser"))) {

Employee e = (Employee) ois.readObject();
System.out.println("Employee ID: " + e.id);
System.out.println("Employee Name: " + e.name);
} catch (IOException | ClassNotFoundException e) {
}
Multithreading in Java allows multiple threads to run concurrently, improving the performance of a
program.
Creating Threads Using `Thread` Class and `Runnable` Interface:
1. Extending the `Thread` Class:
java
class MyThread extends Thread {

public void run() {
System.out.println("Thread is running.");
}
}
MyThread t1 = new MyThread();

t1.start(); // Starts a new thread
2. Implementing the `Runnable` Interface:
java
class MyRunnable implements Runnable {

public void run() {
System.out.println("Thread is running.");
}
}
Thread t2 = new Thread(new MyRunnable());

t2.start(); // Starts a new thread
Thread Lifecycle:
New: The thread instance is created but not started.

Runnable: The thread is ready to run and waiting for the CPU.
Running: The thread is currently executing.
Blocked/Waiting: The thread is blocked or waiting for some resource.
Terminated: The thread has finished its execution.
Synchronization:
Used to control the access of multiple threads to shared resources to prevent data inconsistency.
Synchronized Method:
java
synchronized void sharedMethod() {

// Synchronized code block
}
Inter-thread Communication:
wait(): Causes the current thread to release the lock and wait.
notify(): Wakes up a single thread that is waiting on this object's monitor.
notifyAll(): Wakes up all threads that are waiting on this object's monitor.
Example:
java
synchronized (lockObject) {
lockObject.wait(); // Waits until notify is called
lockObject.notify(); // Wakes up one thread
}
Deadlock and How to Avoid It:
Deadlock: Occurs when two or more threads are blocked forever, waiting for each other.
Avoidance: By ordering locks and avoiding nested locks.
Executor Framework:
A higher-level replacement for managing threads.

Provides various executor services like `ThreadPoolExecutor`, `ScheduledThreadPoolExecutor`, etc.
Creating a Thread Pool:
java
ExecutorService executor = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {

executor.execute(new WorkerThread());
}
executor.shutdown(); // Initiates an orderly shutdown
Concurrency Utilities (`java.util.concurrent` Package):
CountDownLatch: Used to make one or more threads wait until a set of operations being
performed by other threads completes.
CyclicBarrier: A synchronization aid that allows a set of threads to all wait for each other to
reach a common barrier point.
Semaphore: Controls access to a resource with a given number of permits.
Concurrent Collections: Thread-safe variants of collections like `ConcurrentHashMap`,
`CopyOnWriteArrayList`.
This covers the core advanced OOP concepts in Java, including how to handle exceptions, files, and
multithreading efficiently.

Lambda expressions
Functional interfaces (Predicate, Consumer, Supplier, Function)
Method references
Constructor references
5.2. Stream API
Stream creation
Intermediate operations (filter, map, distinct, sorted, etc.)
Terminal operations (forEach, collect, reduce, etc.)
5.3. Optional Class
Handling null values
Creating and using Optional
Methods (isPresent, ifPresent, orElse, orElseGet, orElseThrow)
5.4. Date and Time API
java.time package
LocalDate, LocalTime, LocalDateTime, ZonedDateTime
Formatting and parsing dates
5.5. Default and Static Methods in Interfaces
Usage and purpose
Multiple inheritance problem with default methods
5.6. Nashorn JavaScript Engine
Introduction and use
This section covers the modern features introduced in Java 8 and later, focusing on functional
programming, the Stream API, the Optional class, the Date and Time API, default and static methods
in interfaces, and the Nashorn JavaScript engine.
Java 8 introduced functional programming features, enabling a more concise and readable approach
to coding.
Lambda Expressions:
Lambda expressions are a way to implement functional interfaces (interfaces with a single
abstract method) using a more concise syntax.
Syntax:
java
(parameters) -> expression
Example:
java
List<String> names = Arrays.asList("John", "Jane", "Jack");
names.forEach(name -> System.out.println(name)); // Prints each name
Functional Interfaces:
Interfaces that contain exactly one abstract method are known as functional interfaces. Common
examples include:
`Predicate<T>`: Represents a boolean-valued function of one argument.
`Consumer<T>`: Represents an operation that accepts a single input argument and returns
no result.
`Supplier<T>`: Represents a supplier of results.
`Function<T, R>`: Represents a function that accepts one argument and produces a result.
Example of Functional Interfaces:
java
Predicate<String> isLongerThan5 = s -> s.length() > 5;

Consumer<String> print = s -> System.out.println(s);
Supplier<String> getString = () -> "Hello, World!";
Function<String, Integer> stringLength = s -> s.length();
Method References:
Method references provide a way to refer to methods without invoking them. They can be used
to replace a lambda expression.
Syntax: `ClassName::methodName`
Example:
java

names.forEach(System.out::println); // Method reference to print each name
Constructor References:
Constructor references are similar to method references, but they reference a constructor.
Syntax: `ClassName::new`
Example:
java
Supplier<List<String>> listSupplier = ArrayList::new; // Constructor reference

List<String> list = listSupplier.get(); // Creates a new ArrayList
5.2. Stream API
The Stream API allows for functional-style operations on sequences of elements, making it easier to
process collections of data.
Stream Creation:
Streams can be created from collections, arrays, or I/O channels.

Example from a Collection:
java

Stream<String> stream = names.stream();
Intermediate Operations:
Operations that return a new stream and are lazy (not executed until a terminal operation is
invoked).
Common intermediate operations include:
`filter`: Selects elements based on a condition.
`map`: Transforms each element.
`distinct`: Removes duplicates.
`sorted`: Sorts the stream.
Example of Intermediate Operations:
java
List<String> filteredNames = names.stream()

.filter(name -> name.startsWith("J"))
.map(String::toUpperCase)
.distinct()
.sorted()
.collect(Collectors.toList()); // Collect results into a list
Terminal Operations:
Operations that produce a result or a side-effect and terminate the stream.

Common terminal operations include:
`forEach`: Performs an action for each element.
`collect`: Collects elements into a collection.
`reduce`: Reduces the stream to a single value.
Example of Terminal Operations:
java
names.stream()
.filter(name -> name.startsWith("J"))
.forEach(System.out::println); // Prints names starting with "J"
5.3. Optional Class
The Òptional` class is a container for optional values, designed to avoid `NullPointerException`.
Handling Null Values:
Òptional` can hold either a non-null value or no value at all (null).
Creating and Using Optional:
Creating an Optional:
java
Optional<String> optionalName = Optional.of("John"); // Non-null value

Optional<String> optionalEmpty = Optional.empty(); // No value
Methods:
ìsPresent()`: Returns `true` if a value is present.

ìfPresent(Consumer)`: Executes a block of code if the value is present.
òrElse(T)`: Returns the value if present, otherwise returns the provided value.
òrElseGet(Supplier)`: Returns the value if present, otherwise invokes the supplier to provide a
value.
òrElseThrow(Supplier)`: Returns the value if present, otherwise throws an exception provided by
the supplier.
Example:
java
Optional<String> optionalName = Optional.ofNullable(null);
optional
6. Advanced Topics
Inspecting classes, interfaces, constructors, and methods at runtime
Creating objects and invoking methods dynamically
Built-in annotations (@Override, @Deprecated, @SuppressWarnings)
Custom annotations
Annotations with reflection
6.3. Java Generics
Type parameters in classes, methods, and interfaces
Wildcards and bounds (? extends, ? super)
Generic methods and constructors
Sockets and ServerSockets
URL and HttpURLConnection classes
Datagram and UDP communication
Connecting to a database
Executing SQL queries
ResultSet, Statement, PreparedStatement
Transactions and batch processing
Building GUI applications
Scene graph, Stage, and Scene
Event handling and animations
7. Design Patterns
Singleton
Factory Method
Abstract Factory
Observer
Strategy
Builder
Prototype
Adapter, etc.
8. Testing in Java
JUnit basics
Writing test cases
Mocking with Mockito
Integration testing
9.1. Spring Core
Dependency injection and inversion of control
Bean lifecycle and scopes
9.2. Spring Boot
Building RESTful web services
Spring Data JPA
Spring Security
Microservices with Spring Cloud
9.3. Spring MVC
Building web applications
Controllers, views, and models
Authentication and authorization
OAuth2, JWT
10. Miscellaneous
Memory management and garbage collection
Here's a detailed overview of the advanced topics in Java, covering Reflection API, Annotations,
Generics, Networking, JDBC, JavaFX, Design Patterns, Testing, Microservices with Spring Framework,
and some miscellaneous topics.
6. Advanced Topics
The Reflection API allows Java code to inspect and manipulate classes, methods, and fields at runtime.
Inspecting Classes, Interfaces, Constructors, and Methods:

Use `Class<?>` to obtain class metadata.
Example:
java
Class<?> clazz = Class.forName("java.util.ArrayList");

Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
Creating Objects and Invoking Methods Dynamically:

Use `Constructor` and `Method` classes to create instances and invoke methods.
Example:
java
Constructor<?> constructor = clazz.getConstructor();

Object obj = constructor.newInstance();
Method method = clazz.getMethod("add", Object.class);
method.invoke(obj, "Hello World");
Annotations provide metadata about the code, which can be used by the compiler or at runtime.
Built-in Annotations:
`@Override`: Indicates that a method overrides a method from a superclass.
`@Deprecated`: Marks a method as deprecated and should not be used.
`@SuppressWarnings`: Instructs the compiler to suppress specified warnings.
Custom Annotations:
Define using `@interface`.
Example:
java
@interface MyAnnotation {
String value();
}
Annotations with Reflection:

Retrieve annotations using Reflection.
Example:
java
MyAnnotation annotation = clazz.getAnnotation(MyAnnotation.class);

System.out.println(annotation.value());
6.3. Java Generics
Generics provide a way to specify type parameters in classes, interfaces, and methods.
Type Parameters:
Define generic classes or methods.
Example:
java
public class Box<T> {

private T item;
public void setItem(T item) { this.item = item; }
public T getItem() { return item; }
}
Wildcards and Bounds:

`? extends Type`: Restricts the unknown type to be a subtype of `Type`.
`? super Type`: Restricts the unknown type to be a supertype of `Type`.
Generic Methods and Constructors:
Example of a generic method:
java
public static <T> void printArray(T[] array) {

for (T element : array) {
System.out.println(element);
}
}
Java provides built-in classes for network programming.
Sockets and ServerSockets:

Establish a connection using sockets for client-server communication.
Example:
java
Socket socket = new Socket("localhost", 8080);

ServerSocket serverSocket = new ServerSocket(8080);
URL and HttpURLConnection Classes:
Use for HTTP connections.
Example:
java
URL url = new URL("http://www.example.com");

HttpURLConnection connection = (HttpURLConnection) url.openConnection();
Datagram and UDP Communication:

Use `DatagramSocket` and `DatagramPacket` for UDP.
Example:
java
DatagramSocket socket = new DatagramSocket();

DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
socket.send(packet);
JDBC provides a standard API for connecting and executing queries with databases.
Connecting to a Database:
Load the JDBC driver and establish a connection.
Example:
java
Connection connection =
DriverManager.getConnection("jdbc:mysql://localhost:3306/db_name", "user",
"password");
Executing SQL Queries:

Use `Statement`, `PreparedStatement`, and `ResultSet`.
Example:
java
Statement statement = connection.createStatement();

ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
Transactions and Batch Processing:

Manage transactions using `setAutoCommit(false)` and `commit()`.
Batch processing allows multiple statements to be executed at once.
Example:
java
connection.setAutoCommit(false);
statement.addBatch("INSERT INTO users VALUES (1, 'John')");
statement.addBatch("INSERT INTO users VALUES (2, 'Jane')");
statement.executeBatch();
connection.commit();
JavaFX is used for building rich GUI applications.
Building GUI Applications:

Use Scene, Stage, and GUI components (like buttons, labels).
Example:
java
Stage stage = new Stage();

VBox vbox = new VBox(new Button("Click Me"));
Scene scene = new Scene(vbox, 300, 200);
stage.setScene(scene);
stage.show();
Scene Graph, Stage, and Scene:

The scene graph represents the hierarchical structure of the GUI.
Stage is the top-level container for scenes.
Event Handling and Animations:
Use event handlers to respond to user actions.
Example:
java
button.setOnAction(event -> System.out.println("Button clicked!"));
7. Design Patterns
Design patterns are proven solutions to common software design problems.
Singleton: Ensures a class has only one instance.

Factory Method: Defines an interface for creating an object.
Abstract Factory: Creates families of related objects.
Observer: Defines a dependency between objects so that when one object changes state, all its
dependents are notified.
Strategy: Defines a family of algorithms and makes them interchangeable.
Builder: Separates the construction of a complex object from its representation.
Prototype: Creates new objects by copying an existing object.
Adapter: Allows incompatible interfaces to work together.
8. Testing in Java
Testing ensures code reliability and correctness.
JUnit Basics:
Framework for writing and running tests.
Example of a test case:
java
@Test
public void testAdd() {
assertEquals(5, add(2, 3));
}
Writing Test Cases:

Structure tests with `@Before`, `@After`, `@Test` annotations.
Mocking with Mockito:
Create mock objects for testing interactions.
Example:
java
MyClass myClassMock = mock(MyClass.class);

when(myClassMock.method()).thenReturn("Mocked!");
Integration Testing:
Test components together to ensure they work as expected.
9.1. Spring Core
The core framework provides features like Dependency Injection (DI) and Inversion of Control (IoC).
Dependency Injection and Inversion of Control:

Spring manages object creation and dependencies, reducing tight coupling.
Bean Lifecycle and Scopes:
Understand the lifecycle of a bean and its scope (singleton, prototype, etc.).
9.2. Spring Boot
Spring Boot simplifies the setup and development of Spring applications.
Building RESTful Web Services:

Use Spring MVC for creating REST APIs.
Spring Data JPA:
Simplifies database access and management of JPA entities.
Spring Security:
Provides authentication and authorization features.
Microservices with Spring Cloud:
Use Spring Cloud for building microservices architecture.
9.3. Spring MVC
A framework for building web applications using the Model-View-Controller pattern.
Controllers, Views, and Models:

Define controllers to handle requests, views for presentation, and models for data.
Focuses on securing applications.
Authentication and Authorization:

Manage user login and access control.
OAuth2, JWT:
Implement token-based authentication using OAuth2 and JSON Web Tokens.
10. Miscellaneous
Implement logging to track application behavior and troubleshoot issues.
Memory Management and Garbage Collection
Understand how Java manages memory and the role of the garbage collector in cleaning up
unused objects.
Allows Java code to call or be called by native applications and libraries written in other
languages (like C/C++).
This roadmap provides a structured approach to mastering Java from basic to advanced concepts,
helping you to systematically enhance your knowledge and skills in Java programming. Feel free to
delve into each topic for detailed study and practice!
give 15 to 20 basic commonly asked interview questions on java
Here are 15 to 20 commonly asked interview questions on Java that cover a range of topics, from basic
to intermediate:
Basic Java Interview Questions
1. What is Java?
Explain what Java is, its features, and its platform independence.
2. What are the main features of Java?
Discuss key features such as object-oriented, platform-independent, secure, robust, etc.
3. What is the difference between JDK, JRE, and JVM?
Explain the roles of Java Development Kit, Java Runtime Environment, and Java Virtual
Machine.
4. What is an object in Java?
Describe the concept of an object in object-oriented programming.
5. What is a class in Java?
Explain the definition of a class and its purpose in Java.
6. What are constructors in Java?
Discuss the types of constructors (default, parameterized, and copy constructors).
7. What is method overloading?
Explain how method overloading works in Java and provide an example.
8. What is method overriding?
Discuss the concept of method overriding and how it differs from overloading.
9. What are access modifiers in Java?
Explain the different access modifiers (public, private, protected, and default).
10. What is the difference between `==` and èquals()` in Java?
Discuss how these two operators are used to compare objects.
11. What is an Array in Java?
Explain the definition and types of arrays (single-dimensional and multi-dimensional).
12. What are collections in Java?
Discuss the Java Collections Framework and its main interfaces.
13. What is the difference between ArrayList and LinkedList?
Compare the two data structures in terms of performance and usage.
14. What is the use of the `final` keyword?
Explain how the `final` keyword is used with variables, methods, and classes.
15. What is exception handling in Java?
Describe how exceptions are handled using try-catch blocks.
Intermediate Java Interview Questions
16. What are the different types of exceptions in Java?

Explain checked and unchecked exceptions with examples.
17. What is a Java package?
Discuss the purpose of packages and how to create user-defined packages.
18. What is multithreading in Java?
Explain the concept of threads and how to create them in Java.
19. What are synchronized methods and blocks in Java?
Discuss the importance of synchronization in multithreading.
20. What is the Java Stream API?
Explain what the Stream API is and its advantages in processing collections.
Bonus Questions
21. What are lambda expressions in Java?

Discuss the syntax and use cases of lambda expressions.
22. What is garbage collection in Java?
Explain how Java manages memory and the role of the garbage collector.
These questions should help you prepare for your Java interviews by covering fundamental concepts,
as well as some intermediate topics that may come up in discussions. Good luck!
give 15 to 20 intermediate and advanced commonly asked java questions on interview
Here are 15 to 20 intermediate and advanced Java interview questions that are commonly asked in
interviews:
Intermediate Java Interview Questions
1. What is the difference between an abstract class and an interface in Java?

Discuss the main differences, including usage, method implementations, and inheritance.
2. What are Java annotations, and how do you create a custom annotation?
Explain the purpose of annotations and provide an example of a custom annotation.
3. What is the Java Reflection API?
Describe how reflection works in Java and its common use cases.
4. Explain the concept of generics in Java.
Discuss how generics improve type safety and provide examples of generic classes and
methods.
5. What is the `volatile` keyword in Java?
Explain the purpose of the `volatile` keyword and its effect on multithreading.
6. What are the different ways to create a thread in Java?
Compare the `Thread` class and `Runnable` interface in thread creation.
7. What is the Executor framework?
Explain the Executor framework and its components, such as Èxecutor`, ÈxecutorService`,
and `ThreadPoolExecutor`.
8. What is the significance of the `super` keyword?
Discuss how `super` is used to refer to the superclass's properties and methods.
9. Explain the concept of method references in Java 8.
Describe the syntax and use cases of method references.
10. What is the difference between `HashMap` and `ConcurrentHashMap`?
Compare their implementations and how they handle concurrency.
Advanced Java Interview Questions
11. What is garbage collection, and how does it work in Java?
Discuss different garbage collection algorithms and how the JVM handles memory
management.
12. What are the various types of design patterns, and can you give examples?
Briefly explain design patterns like Singleton, Factory, Observer, etc., and their use cases.
13. How does Java handle memory management?
Explain the memory areas in the JVM (Heap, Stack, Metaspace) and how they are managed.
14. What is the difference between a shallow copy and a deep copy in Java?
Discuss how each type of copy works and when to use them.
15. Explain the significance of the `synchronized` keyword.
Discuss how it is used for thread safety and its impact on performance.
16. What is the Java Stream API, and how is it used?
Explain how streams allow functional-style operations on collections and provide examples.
17. What is a functional interface?
Define functional interfaces and their significance in Java 8 and beyond.
18. Explain the concept of lambda expressions in Java.
Discuss the syntax, benefits, and use cases of lambda expressions.
19. What is the difference between `==` and `.equals()` when comparing objects?
Explain the distinction between reference equality and value equality.
20. What are `CompletableFuture` and its advantages over traditional threading?
Discuss how `CompletableFuture` allows for asynchronous programming and its features.
These questions will help you prepare for interviews by covering various intermediate and advanced
topics in Java, demonstrating your knowledge and understanding of the language. Good luck with
your preparation!
most commonly asked questions and frequently forgettable questions
Here’s a list of commonly asked Java interview questions along with some frequently forgettable
questions that candidates might overlook.
Most Commonly Asked Java Questions
1. What are the main features of Java?

Discuss features like platform independence, object-oriented, robust, secure, etc.
2. What is the difference between JDK, JRE, and JVM?
Explain the roles of Java Development Kit, Java Runtime Environment, and Java Virtual
Machine.
3. What are the types of constructors in Java?
Define default, parameterized, and copy constructors.
4. What is the purpose of the `final` keyword?
Discuss how it is used with variables, methods, and classes.
5. What is method overloading and method overriding?
Explain both concepts and provide examples.
6. What is the difference between `==` and `.equals()`?
Discuss reference vs. value comparison in objects.
7. What are collections in Java?
Describe the Java Collections Framework and its main interfaces (List, Set, Map).
8. What is exception handling in Java?
Explain try-catch blocks, types of exceptions, and the `finally` block.
9. What is multithreading in Java?
Discuss how to create threads using the Thread class and Runnable interface.
10. What is the Java Stream API?
Explain the purpose and functionalities of the Stream API introduced in Java 8.
Frequently Forgettable Java Questions
1. What is a marker interface?

Define a marker interface and provide examples like `Serializable`.
2. What are the different types of inner classes in Java?
Explain static, non-static, local, and anonymous inner classes.
3. What is the difference between a shallow copy and a deep copy?
Discuss the concept of copying objects and their references.
4. What are the advantages of using StringBuilder over String?
Explain mutability and performance considerations.
5. What are Java annotations, and how are they used?
Describe built-in annotations and how to create custom annotations.
6. How do you create a thread-safe singleton in Java?
Discuss different approaches like eager initialization and double-checked locking.
7. What is the `volatile` keyword?
Explain its use in multithreading and memory visibility.
8. What is the significance of the `synchronized` keyword?
Discuss its use for ensuring thread safety and its performance implications.
9. What is the difference between `HashMap` and `Hashtable`?
Discuss synchronization, performance, and null keys/values.
10. What is the purpose of `transient` keyword?
Explain how it affects serialization of fields in a class.
Tips for Retention
Practice Coding: Write small programs to reinforce your understanding of concepts.

Use Flashcards: Create flashcards for frequently forgettable questions to review regularly.
Teach Others: Explaining concepts to peers can help solidify your understanding.
Mock Interviews: Participate in mock interviews to get used to verbalizing your knowledge.
By preparing both the commonly asked questions and the frequently forgettable ones, you’ll be better
equipped for your Java interviews. Good luck!
ChatGPT can make mistakes. Check important info.

Java - Basics To Advanced

Uploaded by

Java - Basics To Advanced

Uploaded by

Java Roadmap Basics to Advanced

History and features of Java

1.2. Basic Syntax

Structure of a Java program

1.3. Data Types and Variables

Primitive data types (int, char, float, boolean, etc.)

Arithmetic, Relational, Logical, Bitwise, and Assignment operators

1.5. Control Statements

Decision-making (if, if-else, switch-case)

Access modifiers (private, public, protected, default)

Superclass and subclass

Compile-time polymorphism (method overloading)

Abstract classes and methods

2.6. Inner Classes

Static inner class

3. Advanced OOP Concepts

Built-in packages (java.lang, java.util, etc.)

3.2. Exception Handling

3.3. File Handling

File I/O with `java.io` package

3.4. Multithreading and Concurrency

Creating threads using `Thread` class and `Runnable` interface

What is the Collections Framework?

4.2. List Interface

ArrayList, LinkedList, Vector, Stack

4.3. Set Interface

HashSet, LinkedHashSet, TreeSet

4.4. Map Interface

HashMap, LinkedHashMap, TreeMap, Hashtable

4.5. Queue Interface

PriorityQueue, LinkedList as Queue

Collections class (sorting, searching, etc.)

5. Java 8 and Beyond (Modern Java Features)

5.2. Stream API

5.3. Optional Class

Handling null values

5.4. Date and Time API

5.5. Default and Static Methods in Interfaces

Usage and purpose

5.6. Nashorn JavaScript Engine

Introduction and use

Inspecting classes, interfaces, constructors, and methods at runtime

6.2. Java Annotations

Built-in annotations (@Override, @Deprecated, @SuppressWarnings)

6.3. Java Generics

Type parameters in classes, methods, and interfaces

6.4. Java Networking

Sockets and ServerSockets

6.5. Java Database Connectivity (JDBC)

6.6. JavaFX (Optional)

Building GUI applications

9. Microservices and Spring Framework (Advanced)

9.2. Spring Boot

Building RESTful web services

9.3. Spring MVC

Building web applications

9.4. Spring Security

Authentication and authorization

1.1. Introduction to Java

1.1. Introduction to Java

1.1.1 History and Features of Java

1.1.1.1 History of Java:

1.1.1.2 Features of Java:

1.1.2.1 Java Virtual Machine (JVM):

Class Loader: Loads class files into memory.

1.1.2.2 Java Runtime Environment (JRE):

1.1.2.3 Java Development Kit (JDK):

Java Compiler (`javac`): Converts Java source code into bytecode.

1.1.3 Setting Up the Environment (Installation of JDK and IDE)

1.1.3.1 Installing the JDK:

1. Download the JDK:

You should see the installed version details.

1.1.3.2 Installing an IDE:

public class HelloWorld {

1.2. Basic Syntax

1.2. Basic Syntax