Complete Java Course

Java Syntax and JVM Architecture

Java is a high-level, class-based, object-oriented programming language. This lesson covers the fundamental syntax and the core of the Java platform: the Java Virtual Machine (JVM). The JVM is an abstract machine that provides a runtime environment in which Java bytecode can be executed.

Hello, World!

The classic "Hello, World!" program demonstrates the basic structure of a Java application. It must be inside a class, and the execution begins in the main method.

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

JVM Architecture Overview

The JVM is the heart of the "write once, run anywhere" philosophy. It consists of three main components: the ClassLoader Subsystem, the Runtime Data Areas (like the Heap and Stack), and the Execution Engine.

• ClassLoader: Loads the class files from the file system, network, or other sources.
• Runtime Data Areas: Where the program's data is stored. The **Heap** is for objects, and the **Stack** is for method calls and local variables.
• Execution Engine: Executes the bytecode. It contains an **Interpreter**, a **JIT (Just-In-Time) Compiler**, and a **Garbage Collector**.

Variables, Data Types, and Operators

In this lesson, we'll cover how to declare and use variables, the different data types available in Java, and the various operators you can use to manipulate data.

Variables and Data Types

Java is a strongly-typed language, which means every variable must be declared with a specific data type. Data types can be primitive (e.g., int, double, boolean) or non-primitive (e.g., String, arrays).

// Primitive Data Types
int myAge = 30;
double pi = 3.14159;
boolean isLearning = true;
char firstInitial = 'J';

// Non-Primitive Data Types
String myName = "John Doe";

Operators

Operators are special symbols used to perform operations on variables and values. We'll explore arithmetic, assignment, comparison, logical, and bitwise operators.

• Arithmetic: +, -, *, /, % (modulus)
• Assignment: =, +=, -=, *=
• Comparison: ==, !=, >, <, >=, <=
• Logical: && (AND), || (OR), ! (NOT)

Control Flow and Exception Handling

This lesson teaches you how to control the flow of your program's execution using conditional statements and loops, and how to handle unexpected errors with exception handling.

Control Flow

Conditional statements (if, else if, else, switch) allow you to execute code based on certain conditions. Loops (for, while, do-while) allow you to repeat a block of code multiple times.

// A simple for loop
for (int i = 0; i < 5; i++) {
    System.out.println("Loop: " + i);
}

// An if-else statement
int score = 85;
if (score > 90) {
    System.out.println("Grade A");
} else {
    System.out.println("Grade B or lower");
}

Exception Handling

Exceptions are errors that occur during the execution of a program. Java provides a robust mechanism to handle them using try, catch, and finally blocks.

try {
    int[] numbers = {1, 2, 3};
    System.out.println(numbers[10]); // This will throw an ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Error: " + e.getMessage());
} finally {
    System.out.println("This always runs.");
}

Arrays and Collections Framework

Arrays are fixed-size data structures for storing multiple values of the same type. The Java Collections Framework provides a more flexible and powerful set of data structures like Lists, Sets, and Maps.

Arrays

An array is an object that holds a fixed number of values of a single type. Array elements are accessed by an index, which starts from 0.

int[] scores = new int[3]; // Declares an array of size 3
scores[0] = 95;
scores[1] = 88;
scores[2] = 76;

String[] names = {"Alice", "Bob", "Charlie"};

Collections Framework

The Collections Framework offers dynamic data structures. The most common ones are:

• List: An ordered collection that can contain duplicate elements (e.g., ArrayList).
• Set: A collection that cannot contain duplicate elements (e.g., HashSet).
• Map: A collection that stores key-value pairs, where keys are unique (e.g., HashMap).

import java.util.ArrayList;
import java.util.List;

List fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Apple"); // Duplicates are allowed
System.out.println(fruits); // [Apple, Banana, Apple]

String Manipulation and I/O

This lesson covers how to work with String objects and how to perform basic input and output operations in Java, which are essential for any application.

String Manipulation

The String class is fundamental in Java. It provides numerous methods for manipulating text, such as concatenation, splitting, searching, and formatting.

String greeting = "Hello";
String name = "World";
String message = greeting.concat(", ").concat(name); // "Hello, World"

System.out.println(message.length()); // 12
System.out.println(message.replace("World", "Java")); // "Hello, Java"

Input and Output (I/O)

You can read input from the console using the Scanner class and write output using System.out.println(). For file I/O, you would typically use classes from the java.io package.

import java.util.Scanner;

public class UserInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter your name: ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
        scanner.close();
    }
}

Classes, Objects, and Methods

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code. This lesson introduces the core building blocks of OOP: **classes**, **objects**, and **methods**.

Classes and Objects

A **class** is a blueprint or template for creating objects. An **object** is an instance of a class. It has state (data) and behavior (methods).

// Class definition
public class Car {
    // Attributes (data)
    String color;
    String model;

    // Method (behavior)
    public void startEngine() {
        System.out.println(model + " engine started.");
    }
}

// Creating an object
Car myCar = new Car();
myCar.color = "Red";
myCar.model = "Tesla";
myCar.startEngine(); // Output: Tesla engine started.

Inheritance and Polymorphism

Inheritance and polymorphism are two of the four pillars of OOP. **Inheritance** allows a class to inherit properties and methods from another class. **Polymorphism** allows objects of different classes to be treated as objects of a common superclass.

Inheritance

We use the extends keyword to create a subclass. The subclass inherits all public and protected members of the superclass. This promotes code reuse.

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking.");
    }
}

// In main method:
Dog myDog = new Dog();
myDog.eat(); // Inherited method
myDog.bark(); // Dog-specific method

Polymorphism

Polymorphism means "many forms." It is often demonstrated through method overriding. A subclass can provide its own specific implementation of a method that is already provided by its superclass.

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating fish.");
    }
}

// In main method:
Animal myAnimal = new Cat();
myAnimal.eat(); // Output: Cat is eating fish.

Interfaces and Abstract Classes

Interfaces and abstract classes are used to achieve abstraction in Java. They define a contract that subclasses must follow. Understanding when to use which is a key part of good design.

Abstract Classes

An **abstract class** is a class that is declared with the abstract keyword. It cannot be instantiated and may contain abstract methods (methods without a body) as well as concrete methods.

abstract class Vehicle {
    public abstract void drive(); // Abstract method
    
    public void turnOnLights() { // Concrete method
        System.out.println("Lights are on.");
    }
}

class Car extends Vehicle {
    @Override
    public void drive() {
        System.out.println("Driving a car.");
    }
}

Interfaces

An **interface** is a blueprint of a class. It can contain method signatures, default methods, static methods, and constants. A class can implement multiple interfaces using the implements keyword.

interface Drivable {
    void drive();
}

class Truck implements Drivable {
    @Override
    public void drive() {
        System.out.println("Driving a truck.");
    }
}

Encapsulation and Access Modifiers

Encapsulation is another core concept of OOP. It's the process of bundling data (fields) and the methods that operate on that data into a single unit, a class. **Access modifiers** are keywords used to set the accessibility of classes, methods, and other members.

Encapsulation

The main idea of encapsulation is to hide the internal state of an object from the outside world and only expose a public interface for interacting with it. This is typically achieved by making fields private and providing public "getter" and "setter" methods.

public class BankAccount {
    private double balance; // Encapsulated field

    public double getBalance() { // Getter method
        return balance;
    }

    public void deposit(double amount) { // Setter-like method
        if (amount > 0) {
            balance += amount;
        }
    }
}

Access Modifiers

Java has four access modifiers:

• public: Accessible from anywhere.
• protected: Accessible within the same package and by subclasses.
• default (no keyword): Accessible only within the same package.
• private: Accessible only within the class itself.

Design Patterns and SOLID Principles

This lesson introduces you to common software design patterns and the **SOLID** principles of object-oriented design. These are crucial for writing clean, maintainable, and scalable code.

SOLID Principles

SOLID is an acronym for five design principles intended to make software designs more understandable, flexible, and maintainable.

• S - Single Responsibility Principle: A class should have only one reason to change.
• O - Open/Closed Principle: Software entities should be open for extension, but closed for modification.
• L - Liskov Substitution Principle: Subtypes must be substitutable for their base types.
• I - Interface Segregation Principle: Clients should not be forced to depend on interfaces they do not use.
• D - Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions.

Common Design Patterns

A design pattern is a general, reusable solution to a commonly occurring problem in software design. We'll briefly look at a few, like the **Singleton** pattern for ensuring a class has only one instance, and the **Factory** pattern for creating objects without specifying the exact class.

Generics and Type Safety

Generics enable you to write a single class, interface, or method that can operate on different types of objects, while ensuring type safety at compile time. This prevents runtime errors and makes your code more robust.

Using Generics

The most common use of generics is with the Collections Framework. Instead of storing raw Object types, you can specify the exact type of elements a collection will hold, like List.

import java.util.ArrayList;
import java.util.List;

// Before Generics (unsafe)
List list = new ArrayList();
list.add("Hello");
list.add(123); // No compile-time error, but will fail at runtime
String s1 = (String) list.get(0);

// With Generics (safe)
List stringList = new ArrayList<>();
stringList.add("Hello");
// stringList.add(123); // Compile-time error!
String s2 = stringList.get(0); // No cast needed

Lambda Expressions and Stream API

Introduced in Java 8, lambda expressions and the Stream API provide a powerful way to write more concise and functional-style code, especially for processing collections of data.

Lambda Expressions

A lambda expression provides a clear and concise way to represent an anonymous function. It's often used with functional interfaces (interfaces with a single abstract method).

// Old way: anonymous inner class
Runnable oldWay = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running old way.");
    }
};

// New way: Lambda expression
Runnable newWay = () -> System.out.println("Running new way.");

Stream API

The Stream API allows you to process collections of objects in a functional manner. It provides a chain of operations like filter, map, and reduce to perform complex data transformations easily.

import java.util.Arrays;
import java.util.List;

List names = Arrays.asList("John", "Jane", "Alice", "Bob");

names.stream()
    .filter(name -> name.startsWith("J"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);
// Output:
// JANE
// JOHN

Multithreading and Concurrency

Java was designed with concurrency in mind. This lesson explores how to write multi-threaded applications to perform tasks in parallel, improving application performance and responsiveness.

Creating Threads

There are two primary ways to create a thread in Java: extending the Thread class or implementing the Runnable interface. The Runnable interface is generally preferred as it allows your class to extend another class if needed.

// Implementing the Runnable interface
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running.");
    }
}

// In main method:
Thread t = new Thread(new MyRunnable());
t.start(); // Starts the thread

Concurrency Issues and Solutions

Working with multiple threads can lead to issues like race conditions. Java provides synchronization mechanisms like the synchronized keyword and the java.util.concurrent package to manage these issues and ensure data integrity.

Annotations and Reflection

Annotations are a form of metadata that can be added to Java source code. **Reflection** is the process of a program being able to examine or modify its own structure at runtime. Both are powerful features used extensively in modern frameworks.

Annotations

Annotations provide information to the compiler or the JVM. They are often used for configuration, like the @Override annotation, which tells the compiler that you intend to override a superclass method.

// Standard annotation
@Override
public String toString() {
    return "My Object";
}

// Custom annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

Reflection

Reflection allows you to inspect classes, interfaces, fields, and methods at runtime without knowing their names at compile time. This is how frameworks like Spring can dynamically create and manage objects.

Class myClass = MyClass.class;
Method[] methods = myClass.getDeclaredMethods();
for (Method method : methods) {
    System.out.println(method.getName());
}

Memory Management and Garbage Collection

Java handles memory management automatically, freeing developers from manual memory allocation and deallocation. This is done by the **Garbage Collector (GC)**, which reclaims memory from objects that are no longer in use.

JVM Memory Areas

The JVM divides memory into several areas. The most important for developers are:

• Heap: Where all class instances and arrays are stored. This is the area managed by the Garbage Collector.
• Stack: Stores local variables and partial results, and plays a part in method invocation and return.
• Method Area: Stores class structures, method data, and other metadata.

Garbage Collection

The GC's job is to identify and remove objects that are no longer reachable by the program. It's an automatic process, but you can hint to the JVM to run it using System.gc(), though there's no guarantee it will run immediately.

public class GcExample {
    @Override
    public void finalize() {
        System.out.println("Object is being garbage collected.");
    }
    
    public static void main(String[] args) {
        GcExample obj = new GcExample();
        obj = null; // Object is now eligible for GC
        System.gc(); // Hint to the JVM to run the GC
    }
}

Spring Framework and Spring Boot

The **Spring Framework** is a powerful and popular framework for building enterprise-level applications in Java. **Spring Boot** makes it easier to create stand-alone, production-grade Spring-based applications that you can just "run."

Why Spring?

Spring provides a comprehensive infrastructure support for developing Java applications. Its core concepts include:

• Dependency Injection (DI): A design pattern where an object receives other objects that it depends on.
• Inversion of Control (IoC): The framework handles the creation and management of objects, freeing you from manually creating them.

Spring Boot

Spring Boot simplifies the Spring setup by providing convention-over-configuration. It's famous for its "autowiring" and embedded servers (like Tomcat), which allow you to create a runnable JAR file with minimal configuration.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class HelloApplication {

    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class, args);
    }

    @GetMapping("/")
    public String hello() {
        return "Hello from Spring Boot!";
    }
}

Hibernate and JPA

When building enterprise applications, you need to interact with a database. **JPA (Java Persistence API)** is a specification for object-relational mapping (ORM) in Java. **Hibernate** is the most popular implementation of JPA.

Object-Relational Mapping (ORM)

An ORM tool maps Java objects to database tables, allowing you to interact with your database using Java objects instead of writing raw SQL queries. This makes your code more object-oriented and less coupled to the database.

JPA and Hibernate

JPA provides a standard way to define your entities and their relationships. Hibernate, as the implementation, does the heavy lifting of translating your Java objects into SQL statements. We use annotations like @Entity, @Id, and @Table to configure this mapping.

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    // Getters and Setters
}

RESTful Web Services

REST (Representational State Transfer) is an architectural style for designing networked applications. A **RESTful Web Service** is a service that follows this style. This lesson teaches you how to design and build REST APIs in Java, typically using a framework like Spring Boot.

Key Principles of REST

• Stateless: The server does not store any client context between requests.
• Client-Server: Clear separation between the client and the server.
• Uniform Interface: Use standard HTTP methods (GET, POST, PUT, DELETE) and a consistent URL structure.
• Resource-Based: The API is designed around resources (e.g., /users, /products) that can be manipulated.

Building a REST API with Spring Boot

Spring Boot makes it very easy to create RESTful services using annotations like @RestController and @RequestMapping.

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @GetMapping
    public List getAllProducts() {
        // Return a list of products
        return products;
    }

    @PostMapping
    public Product createProduct(@RequestBody Product newProduct) {
        // Save the new product
        return newProduct;
    }
}

Maven and Gradle Build Tools

As applications grow, managing dependencies and the build lifecycle becomes complex. **Maven** and **Gradle** are powerful build automation tools that simplify this process. They are essential for any professional Java project.

Maven

Maven is a declarative build tool that uses an XML file, pom.xml, to manage the project's build, dependencies, and documentation. It follows a concept of a "project object model" (POM).

<!-- A simple Maven dependency definition in pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Gradle

Gradle is a more modern build tool that uses a Groovy or Kotlin-based DSL (Domain Specific Language) for its build scripts (build.gradle). It is often considered more flexible and faster than Maven.

// A simple Gradle dependency definition in build.gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

Testing with JUnit and Mockito

Writing automated tests is a critical practice for building reliable software. **JUnit** is the most popular testing framework for Java, and **Mockito** is a powerful mocking library used to create mock objects for testing.

JUnit

JUnit provides annotations like @Test to mark methods as test methods. Assertions (e.g., assertEquals) are used to verify that the code behaves as expected.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MyServiceTest {

    @Test
    void testAdd() {
        int result = MyService.add(2, 3);
        assertEquals(5, result, "2 + 3 should be 5");
    }
}

Mockito

Mockito is used for creating mock objects in tests. Mocks are simulated objects that mimic the behavior of real objects, allowing you to test a class in isolation without relying on its real dependencies.

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.mockito.Mockito.when;

// A simple example of mocking a dependency
@Test
void testGetUserName() {
    UserService userService = Mockito.mock(UserService.class);
    when(userService.getById(1)).thenReturn("Alice");

    // Test a class that depends on UserService
    assertEquals("Alice", userService.getById(1));
}

Database Connectivity (JDBC)

**JDBC (Java Database Connectivity)** is the standard Java API for connecting to and interacting with databases. It provides a common set of classes and interfaces to execute SQL statements and retrieve results, regardless of the specific database vendor.

How JDBC Works

To use JDBC, you need to follow a series of steps:

1. Load the database driver.
2. Establish a connection to the database.
3. Create a Statement or PreparedStatement object.
4. Execute the SQL query.
5. Process the ResultSet (if it's a query).
6. Close the connection and all resources.

import java.sql.*;

public class JdbcExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        try (Connection conn = DriverManager.getConnection(url, "user", "password");
             Statement stmt = conn.createStatement()) {

            String sql = "SELECT id, name FROM users";
            ResultSet rs = stmt.executeQuery(sql);

            while (rs.next()) {
                System.out.println("ID: " + rs.getInt("id") + ", Name: " + rs.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Microservices Architecture

**Microservices** is an architectural style that structures an application as a collection of small, loosely coupled, and independently deployable services. This is in contrast to the traditional monolithic architecture.

Monolith vs. Microservices

In a monolithic architecture, the entire application is built as a single unit. In a microservices architecture, the application is broken down into smaller, self-contained services that communicate with each other, often via REST APIs.

Benefits of Microservices:

• Scalability: You can scale individual services based on demand.
• Resilience: A failure in one service doesn't necessarily bring down the entire application.
• Technology Diversity: Different services can be written in different languages or use different technologies.
• Independent Deployment: Services can be deployed independently, leading to faster release cycles.

Docker and Containerization

**Docker** is a platform that uses **containerization** to package an application and its dependencies into a single, isolated unit called a **container**. This ensures that the application runs consistently across different environments.

Why Use Docker?

Developers often face the problem of "it works on my machine." Containers solve this by packaging the application with everything it needs to run, including libraries, dependencies, and the operating system's environment. This guarantees consistency from development to production.

# A simple Dockerfile for a Java application
FROM openjdk:17-jdk-slim
WORKDIR /app
COPY target/my-app.jar /app/my-app.jar
EXPOSE 8080
CMD ["java", "-jar", "my-app.jar"]

Key Docker Commands

• docker build -t my-app .: Builds a Docker image from a Dockerfile.
• docker run -p 8080:8080 my-app: Runs a container from the image.
• docker-compose up: Used for managing multi-container applications.

Security and Authentication

Security is paramount in any enterprise application. This lesson covers fundamental concepts of application security, focusing on **authentication** (verifying a user's identity) and **authorization** (determining what a user is allowed to do).

Authentication Methods

There are many ways to authenticate users. Common methods include:

• Username/Password: The most common method, often combined with a hashing algorithm to store passwords securely.
• OAuth 2.0 / OpenID Connect: Industry standards for authentication and authorization, used for "Sign in with Google/Facebook."
• JWT (JSON Web Tokens): A standard for securely transmitting information between parties as a JSON object.

Spring Security

For Java applications, **Spring Security** is the de-facto standard for handling security concerns. It provides comprehensive and flexible security solutions for both web and enterprise applications.

import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(requests -> requests
                .requestMatchers("/", "/public/**").permitAll()
                .anyRequest().authenticated()
            );
        return http.build();
    }
}

Performance Optimization

Performance is a key factor in the success of any application. This lesson covers strategies and techniques to identify and resolve performance bottlenecks in Java applications, ensuring they run efficiently and scale effectively.

Common Performance Issues

Common issues that can degrade performance include:

• Inefficient Algorithms: Using an algorithm with a high time complexity.
• Excessive Object Creation: Leads to more frequent and longer garbage collection pauses.
• Database Bottlenecks: Slow or unoptimized SQL queries, lack of proper indexing.
• Synchronization Overhead: Too much use of synchronized blocks, leading to thread contention.

Tools and Techniques

You can use various tools and techniques to optimize performance:

• Profiling: Use profilers (e.g., VisualVM, JProfiler) to analyze CPU and memory usage.
• Benchmarking: Write micro-benchmarks to test the performance of specific code sections.
• Caching: Store frequently accessed data in memory to reduce I/O operations.
• Asynchronous Processing: Use non-blocking I/O and reactive programming to handle a large number of requests efficiently.