public class MemoryExample {
    public static void main(String[] args) {
        int primitive = 10; // Stored in stack
        String nonPrimitive = "Java"; // Reference in stack, "Java" object in heap

        Person person = new Person(); // 'person' reference in stack, object in heap
        person.setName("Alice");      // Name field stored in heap
    }
}

class Person {
    private String name; // Non-primitive, stored in heap

    public void setName(String name) {
        this.name = name;
    }
}

public class ImplicitConversion {
    public static void main(String[] args) {
        int intValue = 42;
        long longValue = intValue;  // Implicit conversion from int to long
        double doubleValue = longValue; // Implicit conversion from long to double
        
        System.out.println("Integer value: " + intValue);
        System.out.println("Long value: " + longValue);
        System.out.println("Double value: " + doubleValue);
    }
}

public class ExplicitConversion {
    public static void main(String[] args) {
        double doubleValue = 42.9;
        int intValue = (int) doubleValue;  // Explicit conversion from double to int

        System.out.println("Double value: " + doubleValue);
        System.out.println("Integer value: " + intValue);
    }
}

int a = 10, b = 3;
System.out.println(a + b);  // 13
System.out.println(a - b);  // 7
System.out.println(a * b);  // 30
System.out.println(a / b);  // 3
System.out.println(a % b);  // 1

System.out.println(a > b);   // true
System.out.println(a < b);   // false
System.out.println(a == b);  // false
System.out.println(a != b);  // true

boolean x = true, y = false;
System.out.println(x && y);  // false
System.out.println(x || y);  // true
System.out.println(!x);      // false

System.out.println(5 & 3);  // 1 (AND)
System.out.println(5 | 3);  // 7 (OR)
System.out.println(5 ^ 3);  // 6 (XOR) assume it as subtracting
1101 – 1001 = 0100 (xor)

int c = 5;
c += 3;  // c = c + 3
System.out.println(c);  // 8

int max = (a > b) ? a : b;
System.out.println(max);  // 10

System.out.println(5 << 1);  // 10 (Left Shift)
System.out.println(5 >> 1);  // 2 (Right Shift)

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line); // Print each line of the file
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Input {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // System.in → reads raw bytes.
        // InputStreamReader → converts bytes into characters.
        // BufferedReader → buffers input for efficiency and provides methods like .readLine().

        System.out.println("enter string ");
        String s = br.readLine();
        System.out.println(s);
        int i = Integer.parseInt(br.readLine());
        float f = Float.parseFloat(s);
        double d = Double.parseDouble(s);
        String z = String.valueOf(i);
    }
}

import java.util.Scanner;

public class ScannerExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter your name: ");
        String name = scanner.nextLine();

        System.out.print("Enter your age: ");
        int age = scanner.nextInt();

        System.out.println("Name: " + name);
        System.out.println("Age: " + age);

        scanner.close();
    }
}

if (condition) {
    // Code to execute if condition is true
}

int a = 10;
if (a > 5) {
    System.out.println("a is greater than 5");
}

if (condition) {
    // Code to execute if condition is true
} else {
    // Code to execute if condition is false
}

int a = 10;
if (a < 5) {
    System.out.println("a is less than 5");
} else {
    System.out.println("a is greater than or equal to 5");
}

if (condition1) {
    // Code for condition1
} else if (condition2) {
    // Code for condition2
} else {
    // Code if all conditions are false
}

int a = 10;
if (a < 5) {
    System.out.println("a is less than 5");
} else if (a == 10) {
    System.out.println("a is equal to 10");
} else {
    System.out.println("a is greater than 10");
}

switch (variable) {
    case value1:
        // Code for value1
        break;
    case value2:
        // Code for value2
        break;
    default:
        // Code if no cases match
}

int day = 2;
switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Other Day");
}

for (initialization; condition; update) {
    // Code to repeat
}

for (int i = 1; i <= 5; i++) {
    System.out.println("Count: " + i);
}

while (condition) {
    // Code to repeat
}

int i = 1;
while (i <= 5) {
    System.out.println("Count: " + i);
    i++;
}

do {
    // Code to execute
} while (condition);

int i = 1;
do {
    System.out.println("Count: " + i);
    i++;
} while (i <= 5);

for (type element : collection) {
    // Code to execute
}

int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        break; // Exit loop
    }
    System.out.println("Count: " + i);
}

Count: 1
Count: 2

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue; // Skip iteration
    }
    System.out.println("Count: " + i);
}

Count: 1
Count: 2
Count: 4
Count: 5

public class Encapsulation
{
    private int id;

    public int getId()
    {
        return id;
    }

    public void setId(int id)
    {
        this.id = id;
    }
}
    

package mypackage1;

public class PublicExample {
    public void display() {
        System.out.println("This is a public method.");
    }
}
    

package mypackage2;

import mypackage1.PublicExample; // Importing the class

public class TestPublic {
    public static void main(String[] args) {
        PublicExample obj = new PublicExample();
        obj.display(); // ✅ Accessible
    }
}
    

This is a public method.
    

class PrivateExample {
    private int secretNumber = 42; // Private variable

    private void showSecret() { // Private method
        System.out.println("Secret number is: " + secretNumber);
    }

    public void accessPrivateMethod() { // Public method to access private method
        showSecret();
    }
}

public class TestPrivate {
    public static void main(String[] args) {
        PrivateExample obj = new PrivateExample();

        // System.out.println(obj.secretNumber); // ❌ ERROR: private variable cannot be accessed
        // obj.showSecret(); // ❌ ERROR: private method cannot be accessed

        obj.accessPrivateMethod(); // ✅ Indirect access via public method
    }
}
    

Secret number is: 42
    

package mypackage1;

class DefaultExample {
    void display() { // No access modifier = default
        System.out.println("This is a default method.");
    }
}
    

package mypackage1;

public class TestDefault {
    public static void main(String[] args) {
        DefaultExample obj = new DefaultExample();
        obj.display(); // ✅ Accessible
    }
}
    

package mypackage2;

import mypackage1.DefaultExample; // ❌ ERROR: Class has default access

public class AnotherPackageTest {
    public static void main(String[] args) {
        DefaultExample obj = new DefaultExample(); // ❌ ERROR: Cannot access default class from another package
    }
}
    

This is a default method.
    

DefaultExample is not public in mypackage1; cannot be accessed from outside package
    

package mypackage1;

public class ParentClass {
    protected void showMessage() {
        System.out.println("This is a protected method.");
    }
}
    

package mypackage2;

import mypackage1.ParentClass;

public class ChildClass extends ParentClass { // Inheriting ParentClass
    public static void main(String[] args) {
        ChildClass obj = new ChildClass();
        obj.showMessage(); // ✅ Accessible because of inheritance
    }
}
    

package mypackage2;

import mypackage1.ParentClass;

public class TestProtected {
    public static void main(String[] args) {
        ParentClass obj = new ParentClass();
        // obj.showMessage(); // ❌ ERROR: Cannot access protected method without inheritance
    }
}
    

This is a protected method.
    

showMessage() has protected access in mypackage1.ParentClass
    

class ParentClass {
    // Fields and methods of the parent class
}

class ChildClass extends ParentClass {
    // Fields and methods of the child class
}

// Parent Class
class Animal {
    String name;

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// Child Class
class Dog extends Animal {
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

// Main Class
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat();  // Inherited from Animal class
        dog.bark(); // Defined in Dog class
    }
}

package inheritance;

public class Bike {
    int name;
    int speed;
    
    public Bike(int name, int speed) {
        this.name = name;
        this.speed = speed;
    }
    
    public void addspeed(int speed) {
        this.speed = speed;
    }
}

package inheritance;

public class Motorchildbike extends Bike {
    String eng;
    
    public Motorchildbike(int name, int speed, String engine) {
        super(name, speed); // Calling parent constructor
        eng = engine;
    }
    
    public String toString() {
        return "name: " + name + " speed: " + speed + " engine: " + eng;
    }
}

package inheritance;

public class Main {
    public static void main(String[] args) {
        Motorchildbike mcb = new Motorchildbike(1, 23, "v2");
        System.out.println(mcb.toString());
    }
}

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound(); // Output: Dog barks
    }
}

class Car {
    public Car(String color, int speed) {
        this.color = color;
        this.speed = speed;
    }
}

class Ferrari extends Car {
    int gear;
    public Ferrari(String color, int speed, int gear) {
        super(color, speed); // Calling parent constructor
        this.gear = gear;
    }
}

class Parent {
    String name = "Parent";

    void display() {
        System.out.println("Parent method");
    }
}

class Child extends Parent {
    String name = "Child";

    void display() {
        super.display(); // Calls parent method
        System.out.println("Child method");
    }

    void showName() {
        System.out.println("Name: " + super.name); // Access parent field
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.display();
        child.showName();
    }
}

Parent method
Child method
Name: Parent

class Engine {
    void start() {
        System.out.println("Engine is starting...");
    }

    void stop() {
        System.out.println("Engine is stopping...");
    }
}

class Car {
    private Engine engine; // The car "has-a" engine

    public Car() {
        this.engine = new Engine(); // Create an engine for the car
    }

    void startCar() {
        System.out.println("Car is starting...");
        engine.start(); // Use the engine
    }

    void stopCar() {
        System.out.println("Car is stopping...");
        engine.stop(); // Use the engine
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car(); // Create a car
        car.startCar();      // Start the car
        car.stopCar();       // Stop the car
    }
}

// Part 1: Addition component
class Adder {
    public int add(int a, int b) {
        return a + b;
    }
}

// Part 2: Subtraction component
class Subtractor {
    public int subtract(int a, int b) {
        return a - b;
    }
}

class Calculator {
    // Calculator HAS-A Adder and Subtractor (composition!)
    private Adder adder;
    private Subtractor subtractor;

    // Initialize the parts when Calculator is created
    public Calculator() {
        adder = new Adder();
        subtractor = new Subtractor();
    }

    // Use the Adder component
    public int addNumbers(int x, int y) {
        return adder.add(x, y);
    }

    // Use the Subtractor component
    public int subtractNumbers(int x, int y) {
        return subtractor.subtract(x, y);
    }
}

public class CalculatorDemo {
    public static void main(String[] args) {
        Calculator myCalc = new Calculator();

        int sum = myCalc.addNumbers(10, 5);     // Uses Adder
        int difference = myCalc.subtractNumbers(10, 5); // Uses Subtractor

        System.out.println("Sum: " + sum);          // Output: 15
        System.out.println("Difference: " + difference); // Output: 5
    }
}

Interfaces in Java

An interface is a blueprint for a class. It defines a set of methods that a class must implement, but it does not provide the implementations itself. Implementations are provided by other classes. Interfaces are a core part of Java's approach to abstraction and polymorphism.

Key Characteristics of Interfaces in Java

1. Definition Syntax:

   public interface MyInterface {
       // Constant declaration: these are public, static, and final by default.
   
       // Abstract method
       void myMethod();
   }

2. Abstract Methods:
   • Before Java 8, interfaces could only contain abstract methods (methods without a body).
   • From Java 8 onwards, interfaces can also have:
     • Default methods: Methods with a default implementation.
     • Static methods: Methods that belong to the interface, not an instance of the class. A static method in an interface belongs to the interface itself, not to any implementing class. It cannot be overridden.

     interface MathUtils {
         static int add(int a, int b) {
             return a + b;
         }
     }
     
     public class Main {
         public static void main(String[] args) {
             int result = MathUtils.add(5, 10); // Calling static method
             System.out.println("Sum: " + result);
         }
     }

3. Fields in Interfaces:
   • Fields in an interface are implicitly:
     • public
     • static
     • final
   • Example:

     public interface MyInterface {
         int CONSTANT = 100; // Equivalent to public static final int CONSTANT = 100;
     }

4. Multiple Inheritance:
   • A class can implement multiple interfaces, allowing for multiple inheritance of type.
   • This is Java's way of avoiding the diamond problem that arises with multiple inheritance in classes.
5. Inheritance in Interfaces:
   • An interface can extend another interface.
   • Example:

     public interface A {
         void methodA();
     }
     
     public interface B extends A {
         void methodB();
     }

6. Functional Interfaces:
   • Introduced in Java 8, a functional interface is an interface with exactly one abstract method, but it can have:
     • Default methods
     • Static methods
     • Methods from java.lang.Object (like toString(), equals())
   • If it is a functional interface and we add multiple abstract methods, we get a compilation error.
   • These are used for lambda expressions.
   • Example:

     @FunctionalInterface
     public interface MyFunctionalInterface {
         void execute();
     }

Implementing an Interface

A class that implements an interface must provide implementations for all its abstract methods.

public interface Animal {
    void eat();
    void sleep();
}

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

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping");
    }
}

interface MyInterface {
    void method1();
    void method2();
}

abstract class MyAbstractClass implements MyInterface {
    @Override
    public void method1() {
        System.out.println("Method1 implemented in abstract class");
    }
    // method2 is not implemented, so the class is abstract
}

class ConcreteClass extends MyAbstractClass {
    @Override
    public void method2() {
        System.out.println("Method2 implemented in concrete class");
    }
}

public class Main {
    public static void main(String[] args) {
        ConcreteClass obj = new ConcreteClass();
        obj.method1(); // Output: Method1 implemented in abstract class
        obj.method2(); // Output: Method2 implemented in concrete class
    }
}

class ConcreteClass implements MyInterface {
    @Override
    public void method1() {
        System.out.println("Method1 implemented");
    }

    @Override
    public void method2() {
        System.out.println("Method2 implemented");
    }
}

Key Benefits of Using Interfaces

1. Abstraction: Separates the definition of behaviors from their implementation.
2. Multiple Inheritance: Unlike classes, a class can implement multiple interfaces.
3. Polymorphism: Interfaces allow a class to be treated as a type of the interface, enabling flexible and reusable code.
4. Standardization: Interfaces define a contract, ensuring that different classes provide consistent behavior.

Real-World Example: Java's List Interface

The List interface is a part of the Java Collections Framework. Classes like ArrayList and LinkedList implement this interface.

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

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        System.out.println(names);
    }
}

In this example, List provides the blueprint, while ArrayList provides the implementation.

Differences Between Interfaces and Abstract Classes

Example of Multiple Inheritance Using Interface

package Interface;

public interface A {
    void add(int a, int b);
}

package Interface;

public interface B {
    void substract(int a, int b);
}

package Interface;

public interface All extends A, B {
    void multiply(int a, int b);
}

package Interface;

public class Implementation implements All {

    @Override
    public void add(int a, int b) {
        System.out.println("Addition: " + (a + b));
    }

    @Override
    public void substract(int a, int b) {
        System.out.println("Subtraction: " + (a - b));
    }

    @Override
    public void multiply(int a, int b) {
        System.out.println("Multiplication: " + (a * b));
    }

    public static void main(String[] args) {
        Implementation obj = new Implementation();

        obj.add(10, 5);          // Example usage of add method
        obj.substract(10, 5);    // Example usage of subtract method
        obj.multiply(10, 5);     // Example usage of multiply method
    }
}

Example: Resolving Default Method Conflict in Multiple Interfaces (Java 8+)

interface A {
    default void show() {
        System.out.println("Interface A: show() method");
    }
}

interface B {
    default void show() {
        System.out.println("Interface B: show() method");
    }
}

// Child class implementing both A and B
class Child implements A, B {
    // Must override show() to resolve conflict
    @Override
    public void show() {
        System.out.println("Child class resolving conflict");
        A.super.show(); // Calling A's version
        B.super.show(); // Calling B's version
    }
}

public class Main {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.show();
    }
}

Child class resolving conflict
Interface A: show() method
Interface B: show() method

class Child inherits unrelated defaults for show() from types A and B

Summary

• Java 8+ allows default methods in interfaces.
• If multiple interfaces have the same default method, the child class must override it.
• The child class can route to specific interface versions using InterfaceName.super.method().

Enum in Java?

An enum (short for enumeration) is a special data type that lets you define a set of constant values. These constants are type-safe, meaning only allowed values can be used.

📌 Think of it as a list of fixed options.

🧠 Example (Real-life)

Say you're building a system that deals with Days of the Week:

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

You can then use it in code like:

Day today = Day.MONDAY;

Now, today can only be one of the 7 days. You can’t assign it to something like today = "Holiday" — this prevents errors.

✅ Why use enum?

• Type safety: Only allowed values can be used.
• Code readability: Self-explanatory values like Status.ACTIVE instead of "A".
• Avoids bugs: No accidental typos or invalid values.
• Can contain methods and constructors (advanced use).

🔍 Syntax of enum

enum EnumName {
    CONSTANT1, CONSTANT2, CONSTANT3
}

Example:

enum Color {
    RED, GREEN, BLUE
}

Usage:

Color myColor = Color.GREEN;

🔁 enum in a switch statement

enum Level {
    LOW, MEDIUM, HIGH
}

public class TestEnum {
    public static void main(String[] args) {
        Level level = Level.MEDIUM;

        switch(level) {
            case LOW:
                System.out.println("Low level");
                break;
            case MEDIUM:
                System.out.println("Medium level");
                break;
            case HIGH:
                System.out.println("High level");
                break;
        }
    }
}

⚙️ enum with fields, constructors, and methods

Yes! Enums can have fields, constructors, and methods.

enum Status {
    ACTIVE(1), INACTIVE(0);

    private int code;

    // Constructor
    Status(int code) {
        this.code = code;
    }

    // Method
    public int getCode() {
        return this.code;
    }
}

Usage:

System.out.println(Status.ACTIVE.getCode());  // Output: 1

📚 Key Properties of enum

❌ What Enums Can’t Do

• Cannot extend a class (they already extend Enum).
• Cannot be instantiated using new.
• Cannot inherit another enum.

📦 enum vs class vs interface

🧪 enum with interface

interface Printable {
    void print();
}

enum DocumentType implements Printable {
    PDF, WORD;

    public void print() {
        System.out.println("Printing " + this);
    }
}

✅ Summary

• enum is a type-safe way to define a fixed set of named constants.
• You use it when your variable should only have predefined values.
• It improves code clarity, safety, and maintainability.
• Enums are more powerful than constants — they can have fields, methods, and constructors.

Polymorphism in Java

Polymorphism is one of the core concepts of object-oriented programming (OOP) in Java. The word "polymorphism" is derived from the Greek words "poly" (many) and "morph" (forms), meaning "many forms." In Java, polymorphism allows one interface to be used for a general class of actions, enabling a single function or object to behave differently based on the context.

Types of Polymorphism in Java

Java supports two types of polymorphism:

1. Compile-time Polymorphism (Static Polymorphism):
   • Achieved through method overloading.
   • The method to be called is determined at compile-time based on the method signature (number, type, and order of parameters).
2. Runtime Polymorphism (Dynamic Polymorphism):
   • Achieved through method overriding.
   • The method to be executed is determined at runtime based on the object's type, not the reference type.

1. Compile-Time Polymorphism (Method Overloading)

What is Method Overloading?

Method overloading allows a class to have multiple methods with the same name but different parameter lists (different signatures). (number, type, and order of parameters).

Example:

class Calculator {
    // Method with two parameters
    public int add(int a, int b) {
        return a + b;
    }

    // Overloaded method with three parameters
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // Overloaded method with different parameter types
    public double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("Sum (int, int): " + calc.add(10, 20));
        System.out.println("Sum (int, int, int): " + calc.add(10, 20, 30));
        System.out.println("Sum (double, double): " + calc.add(10.5, 20.5));
    }
}

Output:

Sum (int, int): 30
Sum (int, int, int): 60
Sum (double, double): 31.0

Key Points:

• Overloading is resolved at compile-time.
• It improves code readability and flexibility.

2. Runtime Polymorphism (Method Overriding)

What is Method Overriding?

Method overriding occurs when a subclass provides its own implementation of a method that is already defined in its parent class. The overridden method must have the same name, return type, and parameters.

Example:

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();  // Upcasting
        Animal animal2 = new Cat();

        animal1.sound();  // Calls Dog's sound method
        animal2.sound();  // Calls Cat's sound method
    }
}

Output:

Dog barks
Cat meows

Polymorphism with Interfaces

Polymorphism can also be achieved through interfaces. A single interface can be implemented by multiple classes, each providing its own implementation.

Example:

    interface Shape {
      void draw();
    }
    
    class Circle implements Shape {
      public void draw() {
        System.out.println("Drawing Circle");
      }
    }
    
    class Rectangle implements Shape {
      public void draw() {
        System.out.println("Drawing Rectangle");
      }
    }
    
    public class Main {
      public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        
        shape1.draw(); // Calls Circle's draw method
        shape2.draw(); // Calls Rectangle's draw method
      }
    }
  

Output:

    Drawing Circle
    Drawing Rectangle
  

Why Use Polymorphism?

1. Code Reusability: Write methods or interfaces that work with general types (e.g., Animal, Shape), and let specific types (e.g., Dog, Circle) provide their own behavior.
2. Extensibility: You can add new classes without modifying existing code.
3. Dynamic Behavior: Allows behavior to be determined at runtime, making programs flexible and adaptable.

Key Rules for Polymorphism in Java

1. Method Overloading:
   • Methods must have the same name but different parameter lists.
   • Can occur within the same class.
   • Return type can be the same or different.
2. Method Overriding:
   • Methods must have the same name, parameter list, and return type (or compatible type).
   • Must involve inheritance (parent-child relationship).
   • The overridden method in the subclass cannot have a stricter access modifier than the method in the superclass.
3. Using @Override: It's recommended to use the @Override annotation to avoid mistakes in method signatures.

Abstraction

An abstract class is a class declared with the abstract keyword. It may or may not include abstract methods. An abstract class cannot be instantiated, but another class can make this class its parent class. If a class has an abstract method, then the class should also be declared abstract. If the child class does not provide all the implementations of the parent class's abstract methods, then the child class must also be declared abstract.

Abstract Methods: Methods that are declared without implementation (no {} brackets and should end with a semicolon).

Example:

    abstract void add(int x, int y);
  

Abstract vs Interface

• In an abstract class, we can define non-final and non-static variables and methods can be declared as public, private, or protected.
• In an interface, variables are by default public static final and methods are public by default.
• Classes can extend only one class (either a normal class or an abstract class), whereas we can implement any number of interfaces in a class.

Constructors

Constructors are special functions that are called when an object is created. They:

• Do not have a return type.
• Have the same name as the class name.
• If not explicitly created, the compiler creates a default constructor and assigns default values for primitive types (and null for non-primitive types).

Final Keyword

• Final variables cannot be re-initialized.
• Final methods cannot be overridden.
• Final classes cannot be inherited.
• If a final variable in a class is not initialized, then if we call that variable, we will get a compiler error. We must initialize it either directly, through a constructor, or through an initializer block.
• All final variables are usually named in capital letters.

Static Keyword

Used to share a variable with all the objects throughout the class.

• Static method: They are mainly used to access static variables. Static variables can also be modified by non-static methods, but it is not recommended.
• Static methods are also useful when we don’t want to create an object to access a method. We can directly use ClassName.staticMethodName().
• Static methods cannot access non-static members.
• Static methods cannot use the this reference.

This:

This reference refers to the current object for which the code is being excecuted.
class Point {
int x;
int y;
Point(int x, int y) { // Constructor
this.x = x;
this.y = y;
}
Point setx(int x) { // Fix: Return Point object
this.x = x;
return this; // "this" means return the current object
}
Point sety(int y) { // Fix: Set value and return Point object
this.y = y;
return this;
}
}
class Main {
public static void main(String args[]) {
Point p = new Point(10, 20);
p.setx(2).sety(2); // Now method chaining works!
System.out.println("Updated Point: (" + p.x + ", " + p.y + ")");
}
}

Lambda Expressions

Lambda expressions in Java were introduced in Java 8 to make coding simpler, cleaner, and more readable. They allow you to create short, anonymous functions (functions without a name) that can be used wherever a functional interface is required.

1. What is a Lambda Expression?

A lambda expression is a concise way to define a function in Java without explicitly declaring a method in a class.

✅ Why use Lambda Expressions?

• Reduces boilerplate code (no need for anonymous classes).
• Improves readability and conciseness.
• Enhances functional programming capabilities.
• Simplifies working with collections and streams.

2. Syntax of Lambda Expressions

(parameters) -> { body }

Explanation:

• parameters: Inputs to the function (can be empty, one, or multiple).
• ->: The lambda arrow operator separates parameters from the body.
• { body }: The function body that contains expressions or statements.

3. Example of Lambda Expressions

Example 1: Lambda Expression to Add Two Numbers

    // Functional Interface
    interface Addable {
      int add(int a, int b);
    }
    
    public class LambdaExample {
      public static void main(String[] args) {
        // Using Lambda Expression
        Addable addition = (a, b) -> a + b;
    
        // Calling the function
        System.out.println(addition.add(5, 10)); // Output: 15
      }
    }
  

Explanation:

1. Addable is a functional interface with a method add(int, int).
2. (a, b) -> a + b implements this method without writing a separate class.

4. Different Ways to Use Lambda Expressions

(a) Lambda Expression with a Single Parameter

    // Functional Interface
    interface Greeting {
      void sayHello(String name);
    }

    public class LambdaExample {
      public static void main(String[] args) {
        Greeting greet = name -> System.out.println("Hello, " + name);
        
        greet.sayHello("Alice"); // Output: Hello, Alice
      }
    }
  

✔ Parentheses ( ) are optional if there is only one parameter.
✔ Curly braces {} are not needed for a single statement.

(b) Lambda Expression with No Parameters

    // Functional Interface
    interface Printer {
      void print();
    }

    public class LambdaExample {
      public static void main(String[] args) {
        Printer printer = () -> System.out.println("Printing...");
        printer.print(); // Output: Printing...
      }
    }
  

✔ ( ) is used for empty parameters.
✔ The lambda function directly executes the print statement.

(c) Lambda Expression with Multiple Statements

    interface MathOperation {
      int operate(int a, int b);
    }
    
    public class LambdaMultiLine {
      public static void main(String[] args) {
        MathOperation multiply = (a, b) -> {
          System.out.println("Multiplying " + a + " and " + b);
          return a * b;
        };
        
        System.out.println(multiply.operate(4, 5)); // Output: Multiplying 4 and 5, 20
      }
    }
  

✔ Curly braces {} are required when there are multiple statements.
✔ The return statement is required when the body has multiple lines.

5. Functional Interfaces and Built-in Methods

Lambda expressions are mostly used with functional interfaces. A functional interface is an interface that has only one abstract method. Java provides built-in functional interfaces inside the java.util.function package.

(a) Predicate<T> – Used for Filtering

✔ Returns true or false based on a condition.

    import java.util.function.*;

    public class PredicateExample {
      public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        System.out.println(isEven.test(8)); // Output: true
        System.out.println(isEven.test(7)); // Output: false
      }
    }
  

(b) Consumer<T> – Used for Processing Each Element

✔ Takes an input but does not return anything.

    import java.util.function.*;

    public class ConsumerExample {
      public static void main(String[] args) {
        Consumer<String> printMsg = msg -> System.out.println(msg);
        printMsg.accept("Hello Lambda!"); // Output: Hello Lambda!
      }
    }
  

(c) Function<T, R> – Used for Transforming Data

✔ Takes one value and returns another.

    import java.util.function.*;

    public class FunctionExample {
      public static void main(String[] args) {
        Function<String, Integer> strToInt = str -> Integer.parseInt(str);
        System.out.println(strToInt.apply("123")); // Output: 123
      }
    }
  

(d) Supplier<T> – Used for Generating Values

✔ Takes no input and returns a value.

    import java.util.function.*;

    public class SupplierExample {
      public static void main(String[] args) {
        Supplier<Double> randomNum = () -> Math.random();
        System.out.println(randomNum.get()); // Output: Some random number
      }
    }
  

6. Using Lambda Expressions in Java Collections

Example: Sorting a List Using Lambda

    import java.util.*;

    public class LambdaSorting {
      public static void main(String[] args) {
        List names = Arrays.asList("John", "Emma", "Alice", "Bob");
    
        // Sorting using Lambda Expression
        Collections.sort(names, (a, b) -> a.compareTo(b));
    
        System.out.println(names); // Output: [Alice, Bob, Emma, John]
      }
    }
  

✔ Collections.sort() requires a Comparator, which is provided by the lambda expression.

Example: Filtering a List Using Lambda and Streams

    import java.util.*;

    public class LambdaStreams {
      public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
    
        // Using Stream with Lambda to filter even numbers
        numbers.stream()
               .filter(n -> n % 2 == 0)
               .forEach(n -> System.out.println(n));
    
        // Output: 2 4 6
      }
    }
  

✔ filter(n -> n % 2 == 0): Keeps only even numbers.
✔ forEach(n -> System.out.println(n)): Prints each filtered number.

7. When to Use Lambda Expressions?

✅ Use lambda expressions when:

• You need short, simple functions.
• You want to replace anonymous inner classes.
• You're working with streams, collections, and functional programming.

❌ Avoid lambda expressions when:

• The logic is too complex (better use a regular method).
• You're implementing multiple methods (use a normal class instead).

8. Summary

✔ Lambda Expression Syntax:

(parameters) -> { body }

✔ Common Functional Interfaces:

• Predicate<T> → boolean test(T t) (Filter)
• Consumer<T> → void accept(T t) (Process)
• Function<T, R> → R apply(T t) (Transform)
• Supplier<T> → T get() (Generate)

Stream in Java

A Stream in Java is a sequence of elements that supports sequential and parallel aggregate operations. It was introduced in Java 8 as part of the java.util.stream package.

Key idea: Stream allows you to process collections of objects in a functional style (like map-reduce).

Key Characteristics

1. Not a data structure: Stream does not store data. It operates on a data source (like Collection, Array, I/O channel, etc.).
2. Lazy evaluation: Intermediate operations are lazy — they're not executed until a terminal operation is invoked.
3. Pipelining: You can chain multiple operations together.
4. Internal iteration: The iteration is abstracted and handled by the Stream API (unlike external iteration via loops).

Stream Creation

// From Collection
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

// From Arrays
Stream<Integer> intStream = Arrays.stream(new Integer[]{1, 2, 3});

// Using Stream.of()
Stream<String> streamOf = Stream.of("one", "two", "three");

// Infinite Streams (with limit)
Stream<Double> infinite = Stream.generate(Math::random).limit(10);
Stream<Integer> iterate = Stream.iterate(0, n -> n + 2).limit(5);

Types of Streams

• Stream<T> – For reference types.
• IntStream, LongStream, DoubleStream – For primitive types (specialized).

These primitive streams avoid the cost of boxing/unboxing.

1. Stream<T> – For Reference Types

• This is the most commonly used stream type.
• Works with objects like String, Employee, Person, etc.
• Elements in the stream are references (objects).
• Uses boxing/unboxing if dealing with primitive types (which is less efficient).

✅ Example: Using Stream<T> with reference types

List<String> names = List.of("Alice", "Bob", "Charlie");

names.stream()
    .map(String::toUpperCase)
    .forEach(System.out::println); // Outputs: ALICE, BOB, CHARLIE

Limitations of Stream<T> for primitives:

If you do this:

Stream<Integer> nums = Stream.of(1, 2, 3, 4);

You're using boxed types (Integer), not primitives (int).

This can cause performance overhead due to boxing/unboxing during operations like sum(), max().

Primitive Streams

To avoid boxing overhead, Java provides specialized primitive streams:

These are part of the java.util.stream package and offer additional methods such as:

• sum()
• average()
• min(), max()
• range(), rangeClosed()

2. IntStream

Used for sequences of int values.

✅ Example: Summing integers

int sum = IntStream.of(1, 2, 3, 4, 5).sum(); // 15

✅ Example: Range of integers

IntStream.range(1, 5).forEach(System.out::print);      // 1234
IntStream.rangeClosed(1, 5).forEach(System.out::print); // 12345

✅ Example: Map and filter

int evenSum = IntStream.rangeClosed(1, 10)
    .filter(n -> n % 2 == 0)
    .sum(); // 2+4+6+8+10 = 30

3. LongStream

Used for sequences of long values.

✅ Example: Generate long values

LongStream.of(100L, 200L, 300L)
    .map(n -> n / 100)
    .forEach(System.out::println); // 1, 2, 3

✅ Example: Range with longs

LongStream.rangeClosed(1, 3).forEach(System.out::println); // 1, 2, 3

4. DoubleStream

Used for sequences of double values.

✅ Example: Average of values

OptionalDouble avg = DoubleStream.of(2.5, 3.0, 4.5).average();
avg.ifPresent(System.out::println); // 3.333...

✅ Example: Filtering

DoubleStream.of(1.2, 3.4, 5.6)
    .filter(d -> d > 3)
    .forEach(System.out::println); // 3.4, 5.6

Conversion Between Stream Types

You can convert between Stream<T> and primitive streams using mapping methods:

✅ Example: Stream<String> → IntStream

Stream<String> words = Stream.of("apple", "banana", "carrot");
IntStream lengths = words.mapToInt(String::length);
lengths.forEach(System.out::println); // 5, 6, 6

✅ Example: IntStream → Stream<Integer>

IntStream.range(1, 4).boxed().forEach(System.out::println); // 1, 2, 3

Summary

Stream Type	Use For	Example Method	Benefit
Stream<T>	Objects (String, etc.)	stream()	General use
IntStream	int primitives	IntStream.range()	No boxing, has sum(), average()
LongStream	long primitives	LongStream.of()	Efficient for large numbers
DoubleStream	double primitives	DoubleStream.of()	Useful for calculations

Stream Operations

🔸 1. Intermediate Operations (Lazy)

1. filter(Predicate<T>)

Filters elements based on a condition.

List<String> names = List.of("Alice", "Bob", "Alex");
List<String> filtered = names.stream()
    .filter(name -> name.startsWith("A"))
    .collect(Collectors.toList()); // ["Alice", "Alex"]

2. map(Function<T, R>)

Transforms each element.

List<String> names = List.of("john", "doe");
List<String> upper = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList()); // ["JOHN", "DOE"]

3. flatMap(Function<T, Stream<R>>)

Flattens nested streams (used for List<List<T>>).

List<List<String>> nested = List.of(List.of("a", "b"), List.of("c"));
List<String> flat = nested.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList()); // ["a", "b", "c"]

4. sorted() / sorted(Comparator)

Sorts the stream elements.

List<Integer> numbers = List.of(5, 3, 1, 4);
List<Integer> sorted = numbers.stream()
    .sorted()
    .collect(Collectors.toList()); // [1, 3, 4, 5]

Custom sort:

List<String> names = List.of("Charlie", "Alice", "Bob");
List<String> sorted = names.stream()
    .sorted(Comparator.reverseOrder())
    .collect(Collectors.toList()); // ["Charlie", "Bob", "Alice"]

5. distinct()

Removes duplicates.

List<Integer> nums = List.of(1, 2, 2, 3);
List<Integer> unique = nums.stream()
    .distinct()
    .collect(Collectors.toList()); // [1, 2, 3]

6. limit(n)

Limits the stream to first n elements.

List<Integer> limited = Stream.iterate(1, n -> n + 1)
    .limit(5)
    .collect(Collectors.toList()); // [1, 2, 3, 4, 5]

7. skip(n)

Skips first n elements.

List<Integer> skipped = Stream.of(1, 2, 3, 4, 5)
    .skip(2)
    .collect(Collectors.toList()); // [3, 4, 5]

8. peek(Consumer<T>)

Useful for debugging.

List<String> result = Stream.of("one", "two", "three")
    .peek(s -> System.out.println("Processing: " + s))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

🔸 2. Terminal Operations

1. forEach(Consumer<T>)

Applies action to each element.

Stream.of("a", "b", "c").forEach(System.out::println);

2. collect(Collector)

Collects stream elements into a collection or result.

List<String> result = Stream.of("Java", "Python")
    .collect(Collectors.toList()); // ["Java", "Python"]

3. toArray()

Converts stream to an array.

String[] array = Stream.of("x", "y", "z").toArray(String[]::new);

4. reduce()

Combines elements into one.

int sum = Stream.of(1, 2, 3)
    .reduce(0, Integer::sum); // 6

String combined = Stream.of("a", "b", "c")
    .reduce("", String::concat); // "abc"

5. count()

Counts elements in the stream.

long count = Stream.of(1, 2, 3, 4).count(); // 4

6. anyMatch, allMatch, noneMatch

Predicate-based checks.

boolean anyEven = Stream.of(1, 3, 4).anyMatch(n -> n % 2 == 0); // true
boolean allEven = Stream.of(2, 4, 6).allMatch(n -> n % 2 == 0); // true
boolean noneOdd = Stream.of(2, 4, 6).noneMatch(n -> n % 2 != 0); // true

7. findFirst() / findAny()

Finds first or any element.

Optional<String> first = Stream.of("apple", "banana").findFirst(); // "apple"

8. min() / max()

Finds min or max by comparator.

Optional<Integer> min = Stream.of(3, 1, 2).min(Integer::compareTo); // 1
Optional<Integer> max = Stream.of(3, 1, 2).max(Integer::compareTo); // 3

🔷 Stream Collectors

Collect to List, Set, Map

List<String> list = Stream.of("A", "B").collect(Collectors.toList());

Set<String> set = Stream.of("A", "B").collect(Collectors.toSet());

Map<Integer, String> map = Stream.of("a", "bb", "ccc")
    .collect(Collectors.toMap(String::length, s -> s)); // may need merge logic

joining()

Concatenates strings.

String joined = Stream.of("a", "b", "c")
    .collect(Collectors.joining("-")); // "a-b-c"

groupingBy()

Groups by a classifier.

Map<String, List<String>> grouped = Stream.of("apple", "banana", "apricot")
    .collect(Collectors.groupingBy(s -> s.substring(0, 1))); // {a=[apple, apricot], b=[banana]}

partitioningBy()

Partitions by predicate (true/false).

Map<Boolean, List<Integer>> partitioned = Stream.of(1, 2, 3, 4)
    .collect(Collectors.partitioningBy(n -> n % 2 == 0)); // true: even, false: odd

counting(), summarizingInt()

long count = Stream.of("a", "bb", "ccc")
    .collect(Collectors.counting()); // 3

IntSummaryStatistics stats = Stream.of("a", "bb", "ccc")
    .collect(Collectors.summarizingInt(String::length));

🔷 Stream Reduction

int total = Stream.of(1, 2, 3)
    .reduce(0, (a, b) -> a + b); // 6

With method reference:

int total = Stream.of(1, 2, 3).reduce(0, Integer::sum);

🔷 Parallel Streams

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int total = numbers.parallelStream()
    .map(n -> n * 2)
    .reduce(0, Integer::sum);

Use forEachOrdered() to preserve order:

numbers.parallelStream().forEachOrdered(System.out::println);

🔷 Short-Circuiting Operations

These stop processing early.

Stream.of("a", "b", "c").limit(2).forEach(System.out::println); // a b

boolean found = Stream.of(1, 2, 3, 4).anyMatch(n -> n > 3); // true

🔷 Custom Collector Example

Collector<String, StringBuilder, String> collector = Collector.of(
    StringBuilder::new,
    StringBuilder::append,
    StringBuilder::append,
    StringBuilder::toString
);

String result = Stream.of("Java", "Stream").collect(collector); // "JavaStream"

Gson Tutorial

What is Gson?

Gson is a Java library from Google used for converting Java objects into their JSON representation and vice versa.

✔ Supports:

• Java Object ↔ JSON conversion (Serialization & Deserialization)
• Complex/nested objects
• Collections like List, Map, etc.
• Generics
• Custom type adapters

✅ Maven Dependency

Add this to your pom.xml:

<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.10.1</version>
</dependency>

🔷 1. Gson Class – The Core

The main class used to serialize/deserialize Java objects.

➤ Example: Serialize and Deserialize

import com.google.gson.Gson;

class Person {
    String name;
    int age;
}

public class Main {
    public static void main(String[] args) {
        Gson gson = new Gson();

        // Java object → JSON
        Person person = new Person();
        person.name = "Alice";
        person.age = 25;
        String json = gson.toJson(person);
        System.out.println(json); // {"name":"Alice","age":25}

        // JSON → Java object
        String jsonInput = "{\"name\":\"Bob\",\"age\":30}";
        Person p = gson.fromJson(jsonInput, Person.class);
        System.out.println(p.name); // Bob
        System.out.println(p.age);  // 30
    }
}

✅ Realistic sources of JSON in Java:

From an HTTP response (API call):

HttpURLConnection conn = (HttpURLConnection) new URL("https://api.example.com/person").openConnection();
BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder response = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
    response.append(line);
}
reader.close();
String jsonInput = response.toString();
Person p = gson.fromJson(jsonInput, Person.class);

From a file:

String jsonInput = new String(Files.readAllBytes(Paths.get("person.json")));
Person p = gson.fromJson(jsonInput, Person.class);

From a database (e.g., JSON stored in a text column):

String jsonInput = resultSet.getString("json_column");
Person p = gson.fromJson(jsonInput, Person.class);

From a message queue or WebSocket, etc.

🔷 2. GsonBuilder – For Customization

Use GsonBuilder to configure your Gson instance.

➤ Features:

• Pretty printing
• Serializing nulls
• Custom date format
• Exclusion strategies
• Type adapters

➤ Example:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class Main {
    public static void main(String[] args) {
        Gson gson = new GsonBuilder()
                .setPrettyPrinting()
                .serializeNulls()
                .create();

        System.out.println(gson.toJson(new Person()));
    }
}

🔷 3. JsonObject – JSON Object Representation

A JsonObject is a map-like object used to build or access JSON manually.

➤ Example:

import com.google.gson.JsonObject;

JsonObject obj = new JsonObject();
obj.addProperty("name", "Alice");
obj.addProperty("age", 25);

System.out.println(obj.toString()); // {"name":"Alice","age":25}

String name = obj.get("name").getAsString();  // "Alice"
int age = obj.get("age").getAsInt();          // 25

🔷 4. JsonArray – JSON Array Representation

Holds multiple elements like a list.

➤ Example:

import com.google.gson.JsonArray;
import com.google.gson.JsonPrimitive;

JsonArray array = new JsonArray();
array.add(new JsonPrimitive("apple"));
array.add(new JsonPrimitive("banana"));

System.out.println(array); // ["apple","banana"]

JsonObject fruit = new JsonObject();
fruit.addProperty("name", "mango");
array.add(fruit);
System.out.println(array); // ["apple", "banana", {"name":"mango"}]

🔷 5. JsonElement – Base for All JSON Types

This is the superclass of:

• JsonObject
• JsonArray
• JsonPrimitive
• JsonNull

Useful for parsing unknown or dynamic JSON.

➤ Example:

import com.google.gson.*;

String json = "{\"name\":\"Alice\", \"age\":25}";
JsonElement element = JsonParser.parseString(json);

if (element.isJsonObject()) {
    JsonObject obj = element.getAsJsonObject();
    System.out.println(obj.get("name").getAsString()); // Alice
}

🔷 6. JsonPrimitive – Primitive Value Holder

Wraps single values like:

• String
• Number
• Boolean

➤ Example:

import com.google.gson.JsonPrimitive;

JsonPrimitive name = new JsonPrimitive("Alice");
JsonPrimitive age = new JsonPrimitive(25);
JsonPrimitive isActive = new JsonPrimitive(true);

System.out.println(name.getAsString());  // Alice
System.out.println(age.getAsInt());      // 25
System.out.println(isActive.getAsBoolean()); // true

🔷 7. JsonNull – Represents null

A singleton class (JsonNull.INSTANCE) representing null in JSON.

➤ Example:

import com.google.gson.JsonObject;
import com.google.gson.JsonNull;

JsonObject obj = new JsonObject();
obj.add("nickname", JsonNull.INSTANCE);

System.out.println(obj.toString());  // {"nickname":null}

if (obj.get("nickname").isJsonNull()) {
    System.out.println("Nickname is null");
}

✅ Basic Gson Usage Summary

✔ Serialize Java Object → JSON

Gson gson = new Gson();
String json = gson.toJson(myObject);

✔ Deserialize JSON → Java Object

MyClass obj = gson.fromJson(jsonString, MyClass.class);

✅ 1. How to Exclude Fields in Gson

You might not want to serialize/deserialize all fields (e.g., sensitive info like passwords or internal data). Gson provides multiple ways to exclude fields:

🔹 a. Using transient Keyword (Built-in Java)

Fields marked transient are skipped during serialization and deserialization.

class User {
    String name;
    transient String password;
}

User user = new User();
user.name = "Alice";
user.password = "secret";

String json = new Gson().toJson(user);
System.out.println(json); // {"name":"Alice"} → password is excluded

🔹 b. Using @Expose Annotation

Use @Expose and configure Gson to respect it.

import com.google.gson.annotations.Expose;

class User {
    @Expose
    String name;

    @Expose(serialize = false, deserialize = false)
    String password;
}

Gson gson = new GsonBuilder()
    .excludeFieldsWithoutExposeAnnotation()
    .create();

✅ Only fields with @Expose will be included.

🔹 c. Using a Custom ExclusionStrategy

Full control to exclude based on logic (e.g., field name, type, annotations).

import com.google.gson.*;
import com.google.gson.annotations.SerializedName;
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;

class User {
    String name;
    String password;
}

ExclusionStrategy strategy = new ExclusionStrategy() {
    public boolean shouldSkipField(FieldAttributes f) {
        return f.getName().equals("password");
    }

    public boolean shouldSkipClass(Class clazz) {
        return false;
    }
};

Gson gson = new GsonBuilder()
    .setExclusionStrategies(strategy)
    .create();

✅ 2. Custom Serializer and Deserializer

Sometimes Gson's default behavior isn’t enough (e.g., custom date formats, flattened fields, encrypted data, etc.).

🔹 a. Custom Serializer (JsonSerializer)

import com.google.gson.*;

class Product {
    String name;
    double price;
}

class ProductSerializer implements JsonSerializer {
    public JsonElement serialize(Product p, java.lang.reflect.Type typeOfSrc, JsonSerializationContext context) {
        JsonObject obj = new JsonObject();
        obj.addProperty("product_name", p.name);
        obj.addProperty("formatted_price", "$" + p.price);
        return obj;
    }
}

// Register serializer
Gson gson = new GsonBuilder()
    .registerTypeAdapter(Product.class, new ProductSerializer())
    .create();

🔹 b. Custom Deserializer (JsonDeserializer)

class ProductDeserializer implements JsonDeserializer {
    public Product deserialize(JsonElement json, java.lang.reflect.Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonObject obj = json.getAsJsonObject();
        Product p = new Product();
        p.name = obj.get("product_name").getAsString();
        p.price = Double.parseDouble(obj.get("formatted_price").getAsString().replace("$", ""));
        return p;
    }
}

// Register deserializer
Gson gson = new GsonBuilder()
    .registerTypeAdapter(Product.class, new ProductDeserializer())
    .create();

✅ You can also combine both using TypeAdapter if needed.

✅ 3. Gson vs Jackson – Comparison

🔹 Example: Custom Field Names

Gson:

@SerializedName("first_name")
String firstName;

Jackson:

@JsonProperty("first_name")
String firstName;

🔹 Example: Ignore a field

Gson:

@Expose(serialize = false, deserialize = false)
String internalUseOnly;

Jackson:

@JsonIgnore
String internalUseOnly;

🔹 When to Use Which?

✅ 1. Gson Class Methods

🔹 toJson(Object src)

Converts a Java object to a JSON string.

Person p = new Person("Alice", 25);
String json = new Gson().toJson(p);
// Output: {"name":"Alice","age":25}

🔹 toJson(Object src, Type typeOfSrc)

Used for generic types like List.

List names = Arrays.asList("Alice", "Bob");
Type listType = new TypeToken>() {}.getType();

String json = new Gson().toJson(names, listType);
// Output: ["Alice","Bob"]

🔹 toJson(Object src, Appendable writer)

Writes JSON directly to a Writer or StringBuilder.

StringWriter writer = new StringWriter();
Person p = new Person("Bob", 30);

new Gson().toJson(p, writer);
System.out.println(writer.toString()); // {"name":"Bob","age":30}

🔹 toJsonTree(Object src)

Returns a JsonElement instead of a string (can be a JsonObject, JsonArray, etc.).

JsonElement tree = new Gson().toJsonTree(p);
System.out.println(tree.getAsJsonObject().get("name").getAsString()); // "Bob"

🔹 fromJson(String json, Class classOfT)

Converts a JSON string to a Java object.

String json = "{\"name\":\"Alice\",\"age\":25}";
Person p = new Gson().fromJson(json, Person.class);

🔹 fromJson(Reader json, Class classOfT)

Useful for reading from files or streams.

Reader reader = new FileReader("person.json");
Person p = new Gson().fromJson(reader, Person.class);

🔹 fromJson(String json, Type typeOfT)

Handles deserialization for generic types (e.g., List).

String json = "[{\"name\":\"A\",\"age\":20},{\"name\":\"B\",\"age\":30}]";
Type listType = new TypeToken>() {}.getType();

List people = new Gson().fromJson(json, listType);

🔹 fromJson(JsonElement json, Class classOfT)

Deserialize from a JsonElement (not a string).

JsonObject obj = JsonParser.parseString("{\"name\":\"Alice\",\"age\":25}").getAsJsonObject();
Person p = new Gson().fromJson(obj, Person.class);

✅ 2. GsonBuilder Methods

🔹 create()

Finalizes and builds a configured Gson instance.

Gson gson = new GsonBuilder().create();

🔹 setPrettyPrinting()

Pretty prints the JSON with line breaks and indentation.

Gson gson = new GsonBuilder()
    .setPrettyPrinting()
    .create();

System.out.println(gson.toJson(new Person("Alice", 25)));

🔹 serializeNulls()

Includes null values in output (by default Gson omits them).

class User { String name; String email = null; }

Gson gson = new GsonBuilder().serializeNulls().create();
System.out.println(gson.toJson(new User()));
// {"name":null,"email":null}

🔹 excludeFieldsWithoutExposeAnnotation()

Only includes fields annotated with @Expose.

class User {
    @Expose String name;
    @Expose(serialize = false) String password;
}

Gson gson = new GsonBuilder()
    .excludeFieldsWithoutExposeAnnotation()
    .create();

🔹 registerTypeAdapter(Type, Object)

Registers a custom serializer or deserializer.

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateSerializer())
    .create();

🔹 setDateFormat(String format)

Specify a custom date format.

Gson gson = new GsonBuilder()
    .setDateFormat("yyyy-MM-dd")
    .create();

🔹 setLenient()

Allows malformed JSON (e.g., single quotes, trailing commas).

Gson gson = new GsonBuilder()
    .setLenient()
    .create();

🔹 disableHtmlEscaping()

Avoids escaping of characters like <, >, &.

String unsafe = "&";
String json = new GsonBuilder()
    .disableHtmlEscaping()
    .create()
    .toJson(unsafe);
// Output: "&"

🔹 enableComplexMapKeySerialization()

Allows maps with complex objects as keys.

Map map = new HashMap<>();
map.put(new Person("Alice", 25), "Engineer");

Gson gson = new GsonBuilder()
    .enableComplexMapKeySerialization()
    .create();

🔹 setFieldNamingPolicy(FieldNamingPolicy policy)

Changes how field names are mapped to JSON (e.g., camelCase → lower_case_with_underscores).

Gson gson = new GsonBuilder()
    .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
    .create();

🔹 generateNonExecutableJson()

Adds a security prefix )]}' to the output to prevent XSSI attacks.

Gson gson = new GsonBuilder()
    .generateNonExecutableJson()
    .create();

🔹 setVersion(double version)

Use with @Since and @Until annotations for version-based exclusion.

class Product {
    @Since(1.0) String name;
    @Until(1.5) double price;
}

Gson gson = new GsonBuilder()
    .setVersion(1.0)
    .create();

🔹 disableInnerClassSerialization()

Skips serialization of inner/non-static classes.

Gson gson = new GsonBuilder()
    .disableInnerClassSerialization()
    .create();

🔹 excludeFieldsWithModifiers(...)

Exclude fields with specific Java modifiers (e.g., transient, static, final).

Gson gson = new GsonBuilder()
    .excludeFieldsWithModifiers(Modifier.STATIC, Modifier.TRANSIENT)
    .create(); 

✅ 5. Working with JsonObject, JsonArray, JsonElement

✅ Create manually:

JsonObject obj = new JsonObject();
obj.addProperty("name", "Alice");
obj.addProperty("age", 30);

✅ Parse from string:

JsonElement element = JsonParser.parseString("{\"name\":\"Alice\"}");
JsonObject jsonObject = element.getAsJsonObject();

✅ Reading values:

String name = jsonObject.get("name").getAsString();
int age = jsonObject.get("age").getAsInt();

✅ 6. Working with Generics

Example: Deserialize List of Users

Type userListType = new TypeToken>(){}.getType();
List users = gson.fromJson(jsonString, userListType);

✅ 7. Custom Serializer and Deserializer

class DateSerializer implements JsonSerializer {
    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive(new SimpleDateFormat("yyyy-MM-dd").format(src));
    }
}

class DateDeserializer implements JsonDeserializer {
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        return new SimpleDateFormat("yyyy-MM-dd").parse(json.getAsString());
    }
}

// Register with GsonBuilder
Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateSerializer())
    .registerTypeAdapter(Date.class, new DateDeserializer())
    .create();

✅ 8. Gson Annotations

public class User {
    @SerializedName("user_name")
    private String name;

    @Expose
    private int age;
}

✅ 9. Field Naming Policy

Gson gson = new GsonBuilder()
    .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
    .create();

JDBC Connectivity

JDBC stands for Java Database Connectivity, where we use API to connect and execute the query in the database. JDBC API uses JDBC drivers to connect with the database. There are 4 types of JDBC drivers:

1. JDBC-ODBC bridge driver
2. Native-API driver (partially Java driver)
3. Network Protocol driver (fully Java driver)
4. Thin driver (fully Java driver)

Java API <- Java application -> JDBC driver -> Database

List of JDBC API Interfaces

List of JDBC API Classes

Transaction Isolation

1. Read Uncommitted

What is "Read Uncommitted"? "Read Uncommitted" is the lowest isolation level in databases. It means one transaction can read data that another transaction has modified but not yet committed. This is risky, because the other transaction might roll back, and the first transaction would have read invalid or temporary data. This problem is called a dirty read.

Analogy: Imagine you and your friend are co-authoring a report. Your friend is editing Section A of the report. Before they save their final version, you peek over and copy the changes into your version. But your friend later says, “Oops, my changes were wrong!” and undoes them. Now, you have included incorrect information in your copy because you read it before it was finalized — this is exactly what a dirty read is.

Example in SQL (Real-World): Imagine a bank account with an initial balance of 100.

1. Transaction 1 (T1): BEGIN TRANSACTION; UPDATE accounts SET balance = balance - 100 WHERE id = 1; (hasn't committed yet)
2. Transaction 2 (T2): SELECT balance FROM accounts WHERE id = 1; (Reads the balance as if it has decreased by 100)
3. Transaction 1 (T1) now decides: ROLLBACK; (Undo the update)
4. Result: Transaction 2 has read incorrect data because it read the balance after it was changed but before it was committed. That read is called a dirty read — and it’s only possible in Read Uncommitted isolation level.

Summary of Issues with Read Uncommitted:

Why It's Dangerous: You could read temporary or incorrect data. Useful only for reporting or non-critical queries where performance matters more than accuracy.

2. Read Committed

Read Committed means a transaction can only read data that has been committed by other transactions. This avoids the problem of dirty reads (reading uncommitted, temporary data).

Behavior:

• If Transaction A updates a row but hasn't committed, Transaction B cannot see that update.
• Transaction B will only see the change after Transaction A commits.

Example in SQL: Imagine a bank account with balance = 1000.

1. Transaction 1 (T1): BEGIN TRANSACTION; UPDATE accounts SET balance = balance - 100 WHERE id = 1; (balance is now 900 internally, but not yet committed)
2. Transaction 2 (T2): SELECT balance FROM accounts WHERE id = 1; (It will still see 1000, the last committed value, not 900)
3. Transaction 1 commits: COMMIT; Now, after this, if T2 runs the same SELECT, it will see 900).

Result: No Dirty Reads – T2 cannot read uncommitted changes from T1.

Analogy: Your teammate is editing a Google Doc in "draft mode". You cannot see their unsaved (uncommitted) changes. Once they save (commit), you can see them. This is exactly like Read Committed.

Compared to "Read Uncommitted":

Problem Still Possible in Read Committed: It prevents dirty reads, but not non-repeatable reads.

Example:

1. T1: Reads balance = 1000
2. T2: Updates balance to 900 and commits
3. T1: Reads balance again — now it's 900

The value changed between reads — this is a non-repeatable read, and Read Committed allows it. To fix this, you'd use Repeatable Read isolation level.

Use Cases: Safe for most OLTP systems (e.g., banking, ecommerce). Good balance between performance and consistency. Default in PostgreSQL, Oracle, SQL Server.

JDBC Example: Connection conn = DriverManager.getConnection(...); conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

3. Repeatable Read

What is "Repeatable Read"? Repeatable Read means once a transaction reads a row, no other transaction can change or delete that row until the first transaction finishes. This ensures:

• No Dirty Reads ✅
• No Non-Repeatable Reads ✅
• But allows Phantom Reads ❌ (we’ll explain this too)

Behavior of Repeatable Read:

• If Transaction A reads a row, it will see the exact same data if it reads it again later — even if another transaction commits a change.
• Any UPDATE or DELETE to that row by another transaction is blocked until Transaction A finishes.

Example – Repeatable Read:

Let’s say a table has:

1. Transaction 1 (T1): BEGIN TRANSACTION; SELECT balance FROM accounts WHERE id = 1; (returns 1000)
2. Transaction 2 (T2): BEGIN TRANSACTION; UPDATE accounts SET balance = 2000 WHERE id = 1; (This will BLOCK until T1 commits or rolls back)
3. T1 again: SELECT balance FROM accounts WHERE id = 1; (Still returns 1000. ✅ It is repeatable — value didn’t change.).
4. T1 commits: COMMIT; (Now T2’s update can proceed).

Prevents "Non-Repeatable Read":

What's a Non-Repeatable Read? When you read the same row twice in one transaction, and get different values, because another transaction modified it in between. Repeatable Read prevents this.

❗ Phantom Read Problem (Still Allowed):

What is a Phantom Read? When new rows are added that match your query filter.

Example:

1. T1 runs: SELECT * FROM accounts WHERE balance > 1000; (returns 2 rows)
2. T2 inserts a new row: INSERT INTO accounts (id, name, balance) VALUES (3, 'Bob', 1500); COMMIT;
3. T1 runs the same query again: SELECT * FROM accounts WHERE balance > 1000; (returns 3 rows now)
4. ✅ This is a phantom row, and Repeatable Read does not prevent this.

Summary of Behavior:

Real-Life Analogy: Imagine you’re filling out a tax form based on your bank statement. Repeatable Read ensures your bank balance doesn’t change halfway while filling the form. But someone may open a new account during that time (phantom).

JDBC Example in Java: Connection conn = DriverManager.getConnection(...); conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ); This ensures any SELECT statements are repeatable during the transaction.

When to Use Repeatable Read: You care about consistent reads of the same rows. Example: financial applications, inventory updates. But: Phantom reads are still a problem if you rely on range queries or filters (e.g., WHERE age > 25).

4. Serializable

Serializable ensures full isolation by making concurrent transactions appear as if they were executed one after another, serially, not concurrently. It prevents:

• ✅ Dirty Reads
• ✅ Non-Repeatable Reads
• ✅ Phantom Reads

📌 It's the highest isolation level and guarantees full consistency, but can significantly impact performance due to locking and blocking.

What Serializable Prevents:

How It Works Internally:

Under the hood, the database might:

• Use strict locking (on rows and ranges)
• Or use serialization graphs to detect conflicts
• Ensure that concurrent execution behaves like serial execution

In databases like PostgreSQL and SQL Server, range-locks or predicate locks are used to prevent phantom rows from appearing.

Example: Phantom Reads Blocked

Database: accounts

Transaction 1 (T1)

BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; SELECT COUNT(*) FROM accounts WHERE balance > 1000; (returns 1 Bob)

Transaction 2 (T2)

BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; INSERT INTO accounts (id, name, balance) VALUES (3, 'Carol', 3000); (❌ BLOCKED or may cause serialization failure)

If T1 finishes first, T2 might:

• Be forced to retry (e.g., in PostgreSQL)
• Or get a serialization error

Compared to Repeatable Read:

Summary of Serializable Behavior:

• Ensures complete consistency
• All concurrent transactions appear serialized
• Most safe, least concurrent
• Can lead to:
  • Lock contention
  • Serialization failures (requiring retries)
  • Reduced throughput

Real-World Analogy: Imagine a single-line checkout counter at a store. Each customer is served one at a time. No overlapping activity. Very safe, but slow if there are many customers.

JDBC Example (Java): Connection conn = DriverManager.getConnection(...); conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); conn.setAutoCommit(false); Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery("SELECT * FROM accounts WHERE balance > 1000"); Now you’re operating in a fully isolated serializable mode.

When to Use Serializable:

Use it when:

• Data must be absolutely consistent
• Use cases:
  • Banking
  • Ledger systems
  • Critical audit logs
  • Any system requiring ACID at maximum strength

Avoid it when:

• You need high concurrency
• You can tolerate minor read inconsistencies

🚨 Warning:

• Serializable is expensive
• Use only when needed
• Consider optimistic locking or application-level checks for performance

Summary of Concurrency Issues

JDBC Example Code (Java)

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TransactionIsolationDemo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/your_database"; // Replace with your DB URL
        String user = "your_username";
        String password = "your_password";

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            // Demonstrating transaction isolation levels
            demoReadUncommitted(conn);
            demoReadCommitted(conn);
            demoRepeatableRead(conn);
            demoSerializable(conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private static void demoReadUncommitted(Connection conn) throws SQLException {
        System.out.println("\n--- Read Uncommitted Isolation Level ---");
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

        try {
            conn.setAutoCommit(false);

            // Transaction A: Update without committing
            try (PreparedStatement stmt = conn.prepareStatement("UPDATE accounts SET balance = balance - 100 WHERE id = 1")) {
                stmt.executeUpdate();
                System.out.println("Transaction A: Updated balance, not committed yet.");
            }

            // Transaction B: Read uncommitted data
            try (PreparedStatement stmt = conn.prepareStatement("SELECT balance FROM accounts WHERE id = 1");
                 ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    System.out.println("Transaction B: Read uncommitted balance = " + rs.getInt("balance"));
                }
            }

            conn.rollback(); // Rollback Transaction A
        } finally {
            conn.setAutoCommit(true);
        }
    }

    private static void demoReadCommitted(Connection conn) throws SQLException {
        System.out.println("\n--- Read Committed Isolation Level ---");
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

        try {
            conn.setAutoCommit(false);

            // Transaction A: Update and commit
            try (PreparedStatement stmt = conn.prepareStatement("UPDATE accounts SET balance = balance - 50 WHERE id = 1")) {
                stmt.executeUpdate();
                conn.commit();
                System.out.println("Transaction A: Committed balance update.");
            }

            // Transaction B: Read committed data
            try (PreparedStatement stmt = conn.prepareStatement("SELECT balance FROM accounts WHERE id = 1");
                 ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    System.out.println("Transaction B: Read committed balance = " + rs.getInt("balance"));
                }
            }
        } finally {
            conn.setAutoCommit(true);
        }
    }

    private static void demoRepeatableRead(Connection conn) throws SQLException {
        System.out.println("\n--- Repeatable Read Isolation Level ---");
        conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);

        try {
            conn.setAutoCommit(false);

            // Transaction B: Read initial balance
            try (PreparedStatement stmt = conn.prepareStatement("SELECT balance FROM accounts WHERE id = 1");
                 ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    System.out.println("Transaction B: Initial balance = " + rs.getInt("balance"));
                }
            }

            // Transaction A: Update balance
            try (PreparedStatement stmt = conn.prepareStatement("```html

        

Java JDBC Connection Guide

1. Register the Driver Class

The first step is to load the database driver class into memory.
This tells Java which database driver to use for making the connection.

Code Example:

Explanation:

• Replace "com.mysql.cj.jdbc.Driver" with the driver class name for your database (e.g., "org.postgresql.Driver" for PostgreSQL, "oracle.jdbc.driver.OracleDriver" for Oracle).
• In modern JDBC versions, this step is optional as the driver is often loaded automatically if available on the classpath.

2. Create the Connection Object

Establish a connection to the database using the DriverManager class.

Explanation:

• Replace "jdbc:mysql://localhost:3306/your_database_name" with your database URL.
  • jdbc:mysql:// specifies the protocol.
  • localhost:3306 specifies the host and port of the database.
  • your_database_name is the name of your database.
• Replace "username" and "password" with your database credentials.

Snowflake Connection Example

3. Create the Statement Object

Create a Statement object to send SQL queries to the database.

Code Example:

Explanation:

• The Statement object allows you to execute SQL queries.
• Use PreparedStatement or CallableStatement for dynamic or parameterized queries.

4. Execute the Query

Execute your SQL query using the Statement object and retrieve results if necessary.

Explanation:

• Use executeQuery() for SELECT queries and executeUpdate() for INSERT, UPDATE, DELETE, or DDL statements.
• The ResultSet object holds the results of a query, allowing you to iterate through rows and fetch column values.

5. Close the Connection Object

Release the database resources by closing the connection, statement, and result set objects.

Explanation:

• Always close resources in the reverse order of their creation to avoid memory leaks.

DriverManager Class

The DriverManager class is part of the java.sql package and serves as a key component of the JDBC API. Its primary purpose is to manage a list of database drivers and establish connections to databases using those drivers.

1. getConnection()

• Using Connection URL Only:

  This variant is suitable for URLs containing all required credentials (username and password).

  Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb");

• Using URL and Credentials:

  Explicitly provide the username and password separately.

  Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "username", "password");

• Using URL and Properties:

  Use a Properties object for better configurability, such as adding custom parameters.

  Properties properties = new Properties(); properties.put("user", "username"); properties.put("password", "password"); Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", properties);

2. registerDriver(Driver driver)

This method allows you to register a database driver with the DriverManager.

3. deregisterDriver()

This method removes a registered driver from the DriverManager.

4. getDrivers()

This method retrieves a list of all drivers currently registered with the DriverManager.

5. setLoginTimeout()

This method sets the maximum time (in seconds) that the DriverManager will wait for a database connection.

6. getLoginTimeout()

This method retrieves the currently set login timeout value.

7. setLogWriter()

This method sets a PrintWriter object to log messages from the DriverManager.

8. getLogWriter()

This method retrieves the current PrintWriter used for logging.

Practical Example Combining All Methods

How driver Manger works

When you call driverManager.getConnection(), it scans through the registered driver and finds the best driver with respect to the URL mentioned in the connection.

Complete Code Example

Example connecting to MySQL, PostgreSQL, and Snowflake databases:

1. Prerequisites

Before connecting to any database:

• Install the corresponding database client libraries.
• Ensure you have the database host, port, username, password, and database name (if applicable).
• Verify network access to the database server.

2. Connecting to MySQL

Steps:

1. Install MySQL Client:

   Use mysql CLI tool or libraries such as MySQL Connector for Python, Java, etc.

   For Java (using JDBC):

   <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.33</version> <!-- Use the latest version --> </dependency>

2. Database Configuration:

   • Host: localhost (or your server IP)
   • Port: 3306 (default MySQL port)
   • URL format: jdbc:mysql://<host>:<port>/<database>

3. Connection Code (Java):

   public class MySQLConnection { public static void main(String[] args) { String url = "jdbc:mysql://localhost:3306/mydatabase"; String user = "username"; String password = "password"; try (Connection conn = DriverManager.getConnection(url, user, password)) { System.out.println("Connected to MySQL!"); } catch (SQLException e) { e.printStackTrace(); } } }
4. Test the Connection: Run the above code or use mysql -u username -p from the command line to verify.

3. Connecting to PostgreSQL

Steps:

1. Install PostgreSQL Client:

   • Use psql CLI tool or libraries such as PostgreSQL JDBC Driver for Java.
   • For Java (using JDBC), add the following Maven dependency: <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <version>42.6.0</version> <!-- Use the latest version --> </dependency>

2. Database Configuration:

   • Host: localhost (or your server IP)
   • Port: 5432 (default PostgreSQL port)
   • URL format: jdbc:postgresql://<host>:<port>/<database>

3. Connection Code (Java):

   public class PostgreSQLConnection { public static void main(String[] args) { String url = "jdbc:postgresql://localhost:5432/mydatabase"; String user = "username"; String password = "password"; try (Connection conn = DriverManager.getConnection(url, user, password)) { System.out.println("Connected to PostgreSQL!"); } catch (SQLException e) { e.printStackTrace(); } } }
4. Test the Connection: Use psql -U username -d database_name from the command line or run the code above.

4. Connecting to Snowflake

Steps:

1. Install Snowflake Client:

   • Use Snowflake's JDBC Driver or SnowSQL CLI tool.
   • For Java (using JDBC), add the following Maven dependency: <dependency> <groupId>net.snowflake</groupId> <artifactId>snowflake-jdbc</artifactId> <version>3.13.32</version> <!-- Use the latest version --> </dependency>

2. Database Configuration:

   • Host: <account>.snowflakecomputing.com
   • Port: 443 (default)
   • URL format: jdbc:snowflake://<account>.snowflakecomputing.com/

3. Connection Code (Java):

   public class SnowflakeConnection { public static void main(String[] args) { String url = "jdbc:snowflake://<account>.snowflakecomputing.com/"; String user = "username"; String password = "password"; String schema = "schema_name"; String warehouse = "warehouse_name"; String database = "database_name"; try (Connection conn = DriverManager.getConnection( url, user, password + "?schema=" + schema + "&warehouse=" + warehouse + "&database=" + database)) { System.out.println("Connected to Snowflake!"); } catch (SQLException e) { e.printStackTrace(); } } }
4. Test the Connection: Run the Java code or use SnowSQL CLI (snowsql -a account_name -u username -d database -s schema).

Common Issues & Tips

• Firewall Settings: Ensure your IP is whitelisted in the database server's firewall.
• SSL Certificates: Use SSL for secure connections (e.g., useSSL=true in MySQL).
• Driver Versions: Ensure you use compatible JDBC driver versions for the database.
• Time Zones: Set appropriate time zone settings to avoid discrepancies.
• Pooling: Use connection pooling libraries like HikariCP for better performance in production.

Connection Interface

Connection interface in Java is part of the JDBC API and is provided by the java.sql package. It represents a single connection to a database, enabling Java programs to interact with the database for executing queries, managing transactions, and retrieving metadata.

Methods of Connection Interface

1. createStatement()
   • Creates a statement that allows you to send simple SQL queries to database.
   • Example: Statement stm = con.createStatement();
2. prepareStatement(String sql)
   • A PreparedStatement is a precompiled SQL statement.
   • It allows you to define a SQL query with placeholders (?) and then bind values to those placeholders before executing the query.
   • Creates a prepared statement object for executing precompiled SQL queries.
   • Useful for queries when there are multiple times with different parameters.
   • Example: PreparedStatement ps = con.prepareStatement("insert into employees(name,age) values (?,?)"); ps.setString(1, 'john'); ps.executeUpdate();
   • You can use PreparedStatement for:
     • SELECT String sql = "SELECT * FROM employees WHERE department = ?"; PreparedStatement stmt = conn.prepareStatement(sql); stmt.setString(1, "Engineering"); ResultSet rs = stmt.executeQuery();
     • INSERT String sql = "INSERT INTO employees (id, name, department, salary) VALUES (?, ?, ?, ?)"; PreparedStatement stmt = conn.prepareStatement(sql); stmt.setInt(1, 10); stmt.setString(2, "Alex"); stmt.setString(3, "HR"); stmt.setDouble(4, 70000.00); stmt.executeUpdate();
     • UPDATE String sql = "UPDATE employees SET salary = ? WHERE name = ?"; PreparedStatement stmt = conn.prepareStatement(sql); stmt.setDouble(1, 95000.00); stmt.setString(2, "Alice Johnson"); stmt.executeUpdate();
     • DELETE String sql = "DELETE FROM employees WHERE id = ?"; PreparedStatement stmt = conn.prepareStatement(sql); stmt.setInt(1, 3); stmt.executeUpdate();
     • Note: In PreparedStatement, the position always starts from 1, not 0.
3. prepareCall(String sql)
   • Creates a callable object for executing stored procedures.
   • Example: CallableStatement pc = con.prepareCall("call getDetails(?)");
   • pc.setInt(1);
4. setAutoCommit(Boolean autoCommit)
   • When auto-commit is true, each SQL statement is automatically saved.
   • Example: con.setAutoCommit(true);
5. commit()
   • Manually commits the current transaction.
   • Example: try { Connection con = DriverManager.getConnection(); con.setAutoCommit(false); // database operation con.commit(); }
6. rollback()
   • Rolls back the current transaction, undoing the changes made by the last commit.
   • Savepoint: it's like a bookmark. We can roll back to a savepoint instead of a complete rollback.
   • Example: Connection con = null; Savepoint save = null; try { con = DriverManager.getConnection(""); con.setAutoCommit(false); Statement s = con.createStatement(); s.executeUpdate("insert into students (id,name) values (1,'abc')"); save = con.setSavepoint("savepoint"); con.commit(); } catch (Exception e) { if (con != null) { try { if (save != null) { con.rollback(save); } else { con.rollback(); } } } }
7. close()
   • Closes the connection and frees the resources.
8. setTransactionIsolation(int level)
   • TRANSACTION_READ_UNCOMMITTED
   • TRANSACTION_READ_COMMITTED
   • TRANSACTION_REPEATABLE_READ
   • TRANSACTION_SERIALIZABLE
   • Example: con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
9. getMetaData()
   • Returns metadata about the database, such as version, product name, and other info.
   • Example: DatabaseMetaData md = con.getMetaData(); System.out.println(md.getDatabaseProductName());
10. isClosed()
    • Checks if the connection is closed.
    • Example: if (con.isClosed()) { System.out.println("Connection is closed"); }
11. getAutoCommit()
    • Gets the auto-commit mode.
    • Example: boolean b = con.getAutoCommit(); System.out.println(b);
12. isReadOnly()
    • Checks if the connection is read-only.
13. setReadOnly(boolean readOnly)
    • Sets the connection to read-only.
    • Example: con.setReadOnly(true);
14. nativeSQL(String sql)
    • Converts a standard SQL query to a database-specific SQL query.
    • Example: String nativeSql = con.nativeSQL("select * from student");
15. setCatalog(String catalog)
    • Sets the database for the connection when we don't pass the database in the URL.
    • Example: String url = "jdbc:snowflake://account.region.snowflakecomputing.com/"; Connection conn = DriverManager.getConnection(url, user, password); conn.setCatalog("MY_DATABASE"); // Set database here
    • Example code: import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class SetCatalogExample { public static void main(String[] args) { String url = "jdbc:mysql://localhost:3306/"; // MySQL connection URL String user = "root"; String password = "password"; try (Connection connection = DriverManager.getConnection(url, user, password)) { System.out.println("Connected to the database server."); // Set catalog to 'sales_db' connection.setCatalog("sales_db"); System.out.println("Catalog set to: " + connection.getCatalog()); // Perform operations on 'sales_db' here... // Change catalog to 'hr_db' connection.setCatalog("hr_db"); System.out.println("Catalog set to: " + connection.getCatalog()); // Perform operations on 'hr_db' here... } catch (SQLException e) { e.printStackTrace(); } } }
16. getCatalog()
    • Gets the current catalog.
    • Example: String databaseName = con.getCatalog();
17. setSchema(String schema)
    • Sets the schema.
    • Example: conn.setSchema("PUBLIC");

Statement Interface Methods

The Statement interface uses SQL statements to retrieve data from a database.

1. executeQuery(String sql)

Executes an SQL SELECT query and returns the result as a ResultSet.

Use Case: When you want to retrieve data from the database.

Statement s = con.createStatement();
ResultSet rs = s.executeQuery("SELECT * FROM table");
while (rs.next()) {
    System.out.println("Employee ID: " + rs.getInt("id"));
    System.out.println("Employee Name: " + rs.getString("name"));
}

2. executeUpdate(String sql)

Executes SQL statements like INSERT, DELETE, UPDATE that modify the database. It returns the number of rows affected.

Use Case: When modifying the database.

Statement s = con.createStatement();
int num = s.executeUpdate("UPDATE name SET age='asdas' WHERE id=1");

3. execute(String sql)

Executes any SQL statement. It returns true if the result is a ResultSet (e.g., SELECT), or false if it is an update count (e.g., INSERT, UPDATE, DELETE).

Use Case: When the type of SQL query is not known at compile time.

Statement s = con.createStatement();
boolean isResultSet = s.execute("SELECT * FROM employees");
if (isResultSet) {
    ResultSet rs = s.getResultSet();
    while (rs.next()) {
        System.out.println("ID: " + rs.getInt("id"));
    }
} else {
    int updateCount = s.getUpdateCount();
    System.out.println(updateCount + " row(s) affected.");
}

4. addBatch(String sql)

Adds an SQL command to the current batch of commands. Instead of executing each SQL command individually, the commands are accumulated in a batch and executed together in one go using the executeBatch() method. This approach reduces the overhead of multiple network roundtrips to the database and improves performance, especially for large-scale data manipulation.

Use Case: Used for batch processing.

Statement s = con.createStatement();
s.addBatch("INSERT INTO employees (id, name) VALUES (1, 'John')");
s.addBatch("INSERT INTO employees (id, name) VALUES (2, 'Jane')");
int[] results = s.executeBatch();
System.out.println("Batch execution completed.");
for (int i = 0; i < results.length; i++) {
    System.out.println("Command " + (i + 1) + ": Rows affected = " + results[i]);
}

5. executeBatch()

Executes all SQL commands added to the current batch and returns an array of update counts.

Use Case: Execute multiple SQL commands in a single batch.

int[] results = s.executeBatch();
for (int result : results) {
    System.out.println("Update count: " + result);
}

6. clearBatch()

Clears all SQL commands from the current batch.

Use Case: Reset the batch command list.

s.clearBatch();

7. close()

Closes the Statement object and releases database resources.

Use Case: Clean up after executing statements.

s.close();

8. getResultSet()

Retrieves the current ResultSet object from a Statement. If we don’t directly give like ResultSet rs = s.execute("query"); then we should use getResultSet().

Use Case: Access the result of a previously executed SELECT query.

ResultSet rs = s.getResultSet();

9. getUpdateCount()

Returns the number of rows affected by the last executed SQL command.

Use Case: Retrieve update count after an INSERT, UPDATE, or DELETE statement.

int updateCount = s.getUpdateCount();

10. getMoreResults()

Moves to the next result in a batch of results.

Use Case: Process multiple results from a statement execution.

boolean moreResults = s.getMoreResults();

11. setMaxRows(int max)

Sets the maximum number of rows a ResultSet can contain.

Use Case: Limit query results.

s.setMaxRows(10);

12. getMaxRows()

Retrieves the maximum number of rows for a ResultSet.

Use Case: Check the current row limit.

int maxRows = s.getMaxRows();

13. setQueryTimeout(int seconds)

Sets the time in seconds for a query to execute before timing out.

Use Case: Prevent queries from running indefinitely.

s.setQueryTimeout(30);

14. getQueryTimeout()

Retrieves the current query timeout value.

Use Case: Check the query timeout setting.

int timeout = s.getQueryTimeout();

15. cancel()

Cancels the execution of a running SQL statement.

Use Case: Abort a long-running query.

s.cancel();

16. isClosed()

Checks whether the statement has been closed.

Use Case: Verify the statement's state.

boolean closed = s.isClosed();

17. setFetchSize(int rows)

Gives a hint to the JDBC driver about the number of rows to fetch in each database roundtrip.

Use Case: Optimize performance for large result sets.

s.setFetchSize(50);

18. getFetchSize()

Retrieves the number of rows suggested for each fetch.

Use Case: Monitor fetch size setting.

int fetchSize = s.getFetchSize();

19. getFetchDirection()

Retrieves the current fetch direction for a ResultSet.

Use Case: Determine fetch behavior.

int fetchDirection = s.getFetchDirection();

20. setFetchDirection(int direction)

Sets the fetch direction for rows in a ResultSet (e.g., ResultSet.FETCH_FORWARD).

Use Case: Control traversal direction.

s.setFetchDirection(ResultSet.FETCH_FORWARD);

Scrollable ResultSet – What is it?

A Scrollable ResultSet allows you to move the cursor in multiple directions, not just forward. You can:

• Move forward (next()).
• Move backward (previous()).
• Jump to the first row (first()).
• Jump to the last row (last()).
• Move to a specific row number (absolute(int row)).
• Move relative to the current position (relative(int rows)).

How to Create a Scrollable ResultSet?

When you create a Statement object, you specify two parameters:

1. ResultSet Type – Specifies whether the ResultSet is scrollable and sensitive to database changes.
2. Concurrency Mode – Specifies whether you can update the ResultSet.

Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

Let’s focus on ResultSet Type (scrollability):

ResultSet Types (Scrollability)

1. TYPE_FORWARD_ONLY (Default)

• Moves forward only using next().
• You cannot move backward, or jump to specific rows.
• Most efficient and commonly used.

Statement stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
ResultSet rs = stmt.executeQuery("SELECT * FROM users");
while (rs.next()) {
    System.out.println(rs.getInt("id") + " - " + rs.getString("name"));
}

2. TYPE_SCROLL_INSENSITIVE

• Cursor can move in all directions (forward, backward, jump to a specific row).
• Changes made in the database are NOT visible in the ResultSet while you are working with it.
• Slower than TYPE_FORWARD_ONLY because it creates a temporary snapshot of data.

Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
ResultSet rs = stmt.executeQuery("SELECT * FROM users");

rs.last(); // Move to the last row
System.out.println("Last Row ID: " + rs.getInt("id"));

rs.first(); // Move to the first row
System.out.println("First Row ID: " + rs.getInt("id"));

rs.absolute(2); // Move to the second row
System.out.println("Second Row ID: " + rs.getInt("id"));

rs.previous(); // Move to the previous row (first row)
System.out.println("Back to First Row ID: " + rs.getInt("id"));

Key Point: Even if data changes in the database after you fetch the ResultSet, those changes are NOT reflected.

3. TYPE_SCROLL_SENSITIVE

• Cursor can move in all directions.
• Changes made in the database ARE visible in the ResultSet if the data for the current row is updated.
• Performance is usually slower than TYPE_SCROLL_INSENSITIVE because it keeps track of database changes.

Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
ResultSet rs = stmt.executeQuery("SELECT * FROM users");

rs.absolute(2);
System.out.println("Row 2 Name: " + rs.getString("name"));

// Imagine someone updates this row in the database
// The updated data will be reflected if you access this row again
System.out.println("Row 2 Updated Name: " + rs.getString("name"));

Key Point: If another user or process updates the data in the database, your ResultSet will show the updated values for the current row. Not all drivers support this. It may fall back to TYPE_SCROLL_INSENSITIVE if the driver doesn’t support it.

Concurrency Modes (Optional - Second Parameter)

Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);

Summary: Comparing ResultSet Types

When to Use Which?

Key Points to Remember:

• TYPE_FORWARD_ONLY is the default (most efficient).
• Scrollable ResultSet needs TYPE_SCROLL_INSENSITIVE or TYPE_SCROLL_SENSITIVE.
• Not all JDBC drivers support TYPE_SCROLL_SENSITIVE; it may fall back to TYPE_SCROLL_INSENSITIVE.
• TYPE_SCROLL_INSENSITIVE is the safer choice when you need scrollability.

Practical Example Summary

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root", "password");

// Create Scrollable ResultSet (Insensitive)
Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
ResultSet rs = stmt.executeQuery("SELECT * FROM users");

if (rs.last()) {
    System.out.println("Last Row ID: " + rs.getInt("id"));
}

rs.first();
System.out.println("First Row ID: " + rs.getInt("id"));

rs.absolute(2);
System.out.println("Second Row ID: " + rs.getInt("id"));

rs.previous();
System.out.println("Back to First Row ID: " + rs.getInt("id"));

ResultSet

1. next() Method

• Moves the cursor to the next row.
• Returns: true if there is a valid row, false if no more rows exist.
• Use Case: Used in loops to iterate through all rows in the result set.
• How It Works:
• Initially, the cursor is positioned before the first row.
• First call moves the cursor to the first row.
• Each subsequent call moves the cursor through subsequent rows.
• When no rows are left, it returns false.
• This is how you loop through the ResultSet.
• Example:

while (rs.next()) {
    System.out.println(rs.getInt("id") + " - " + rs.getString("name"));
}

• Here, rs.next() moves the cursor forward for each row until there are no more rows.

2. previous() Method

• Moves the cursor to the previous row.
• Returns: true if there’s a valid row, false if no previous row exists.
• Requires: A scrollable ResultSet (TYPE_SCROLL_INSENSITIVE or TYPE_SCROLL_SENSITIVE).
• How It Works:
• Starts from the current position and moves backwards.
• You can use last() to move to the last row first and then move backward.
• Example:

if (rs.last()) {
    do {
        System.out.println(rs.getInt("id"));
    } while (rs.previous());
}

• rs.last() moves to the last row.
• do-while with previous() moves backward through each row until it reaches before the first row.

3. first() Method

• Moves the cursor to the first row.
• Returns: true if the first row exists, false if the ResultSet is empty.
• How It Works:
• Moves the cursor to the first row regardless of its current position.
• Faster than absolute(1).
• Example:

if (rs.first()) {
    System.out.println(rs.getInt("id"));
}

• rs.first() moves to the first row if it exists and prints the id.

4. last() Method

• Moves the cursor to the last row.
• Returns: true if the last row exists, false if the ResultSet is empty.
• How It Works:
• Moves the cursor to the last row regardless of its current position.
• Faster than some other methods to move directly to the last row.
• Example:

if (rs.last()) {
    System.out.println(rs.getInt("id"));
}

• rs.last() moves to the last row if it exists and prints the id.

5. absolute(int row) Method

• Moves the cursor to the specified row number.
• Positive Number: Moves from the start (e.g., absolute(1) is the first row).
• Negative Number: Moves from the end (e.g., absolute(-1) is the last row).
• Returns: true if the row exists, false otherwise.
• How It Works:
• absolute(1) moves to the first row.
• absolute(3) moves to the third row.
• absolute(-1) moves to the last row.
• absolute(-2) moves to the second last row.
• Example:

if (rs.absolute(2)) { // Move to second row
    System.out.println(rs.getInt("id"));
}
if (rs.absolute(-1)) { // Move to last row
    System.out.println(rs.getInt("id"));
}

• First Call: Moves to the second row and prints the id.
• Second Call: Moves to the last row and prints the id.

6. relative(int rows) Method

• Moves the cursor by the given number of rows from the current position.
• Positive Number: Moves forward (e.g., relative(2) moves forward by 2 rows).
• Negative Number: Moves backward (e.g., relative(-1) moves back by 1 row).
• Returns: true if the new position is valid, false otherwise.
• How It Works:
• Useful to skip rows efficiently or move back based on your requirements.
• Example:

if (rs.first()) {
    rs.relative(2); // Moves from the first row to the third
    System.out.println(rs.getInt("id"));
}

• Here, if the ResultSet starts at the first row, rs.relative(2) moves forward by 2 rows.

7. beforeFirst() Method

• Moves the cursor to a position before the first row.
• Returns: void (no return value).
• Use: Resets the cursor so that you can loop through the rows again.
• Example:

rs.beforeFirst();
while (rs.next()) {
    System.out.println("First row again? No, if the result set is not empty, it loops from the first row.");
}

• This is equivalent to resetting the ResultSet.

8. afterLast() Method

• Moves the cursor to a position after the last row.
• Returns: void (no return value).
• Use: To move the cursor past the last row, so you can process backwards using previous().
• Example:

rs.afterLast();
while (rs.previous()) { // Process rows backwards
    System.out.println(rs.getInt("id"));
}

• This is useful if you need to process rows in reverse order.

Methods to Check Cursor Position (No Movement)

• Methods that check where the cursor is positioned, but do not move it:
• isBeforeFirst()
• isAfterLast()
• isFirst()
• isLast()

9. isBeforeFirst()

• Returns: true if cursor is before the first row.
• Example:

if (rs.isBeforeFirst()) {
    System.out.println("Before first row");
}

• This method is useful to check if you are at the start of the ResultSet.

10. isAfterLast()

• Returns: true if cursor is after the last row.
• Example:

if (rs.isAfterLast()) {
    System.out.println("After last row");
}

• This method is useful to check if you have passed the end of the ResultSet.

11. isFirst()

• Returns: true if cursor is at the first row.
• Example:

if (rs.isFirst()) {
    System.out.println("First row");
}

• Useful to know if you are on the first row for conditional logic.

12. isLast()

• Returns: true if cursor is at the last row.
• Example:

if (rs.isLast()) {
    System.out.println("Last row");
}

• Useful to know if you are on the last row because maybe you can use multiple cursors with break; here.

Data Retrieval Methods

1. getString(int columnIndex) / getString(String columnLabel)

• Returns the column value as a String.
• Use: For text data like VARCHAR (names, descriptions, etc.).
• Examples:
• String name = rs.getString(2); (retrieves second column as String)
• String name = rs.getString("name"); (retrieves column "name")

2. getInt(int columnIndex) / getInt(String columnLabel)

• Returns the column value as an int.
• Use: For INTEGER-like data.
• Examples:
• int id = rs.getInt(1);
• int age = rs.getInt("age");

3. getLong(int columnIndex) / getLong(String columnLabel)

• Returns the column value as a long.
• Use: For BIGINT and other large integers.

4. getDouble(int columnIndex) / getDouble(String columnLabel)

• Returns the column value as a double.
• Use: For DOUBLE or FLOAT values (precision required).

5. getFloat(int columnIndex) / getFloat(String columnLabel)

• Returns the column value as a float.
• Use: For FLOAT values (less precise than double).

6. getBoolean(int columnIndex) / getBoolean(String columnLabel)

• Returns the column value as a boolean.
• Use: For BOOLEAN types (or TINYINT(1) in MySQL).

7. getByte(int columnIndex) / getByte(String columnLabel)

• Returns the column value as a byte.
• Use: For TINYINT or binary data.

8. getShort(int columnIndex) / getShort(String columnLabel)

• Returns the column value as a short.
• Use: For SMALLINT-like data.

9. getDate(int columnIndex) / getDate(String columnLabel)

• Returns the column value as java.sql.Date.
• Use: For DATE values (without time).

10. getTime(int columnIndex) / getTime(String columnLabel)

• Returns the column value as java.sql.Time.
• Use: For TIME values (without date).

11. getTimestamp(int columnIndex) / getTimestamp(String columnLabel)

• Returns the column value as java.sql.Timestamp.
• Use: For DATETIME/TIMESTAMP values.

12. getObject(int columnIndex) / getObject(String columnLabel)

• Returns the column value as a Java Object.
• Use: For dynamic retrieval when you don’t know the type in advance.

13. getBigDecimal(int columnIndex) / getBigDecimal(String columnLabel)

• Returns the column value as BigDecimal.
• Use: For high-precision DECIMAL/NUMERIC values.

14. getBytes(int columnIndex) / getBytes(String columnLabel)

• Returns the column value as a byte[] array.
• Use: For BLOB or binary data.

15. getBlob(int columnIndex) / getBlob(String columnLabel)

• Returns the column value as a Blob object.
• Use: For BLOB (binary large objects).

16. getClob(int columnIndex) / getClob(String columnLabel)

• Returns the column value as a Clob object.
• Use: For CLOB (character large objects).

Update Methods

1. updateString(int columnIndex, String x) / updateString(String columnLabel, String x)

• Updates the specified column (via index or label) with a String value x.
• This is in memory and requires updateRow() to save to the database.

2. updateInt(int columnIndex, int x) / updateInt(String columnLabel, int x)

• Updates the specified column with an int value x.

3. updateDouble(int columnIndex, double x) / updateDouble(String columnLabel, double x)

• Updates the specified column with a double value x.

4. updateObject(int columnIndex, Object x) / updateObject(String columnLabel, Object x)

• Updates the specified column with an Object x. Allows flexibility in updating with any Java object.

5. insertRow()

• Inserts a new row into the database based on current row content (prepared via moveToInsertRow() and updateXxx() calls).
• Steps to use:
1. Move to the "insert row" using moveToInsertRow().
2. Set new column values with updateXxx() methods.
3. Call insertRow() to insert into the database.
4. Use moveToCurrentRow() to return to the original cursor position before moveToInsertRow().
• Example:

rs.moveToInsertRow();
rs.updateString(2, "John Doe");
rs.insertRow();
rs.moveToCurrentRow();

6. updateRow()

• Saves all changes made to the current row in memory to the database.
• Steps to use:
1. Move the cursor to the row you want to update.
2. Use updateXxx() methods to modify columns.
3. Call updateRow() to save changes to the database.
• Example:

rs.next();
rs.updateInt("age", 35); // Modify age column
rs.updateRow(); // Save changes to the database

7. deleteRow()

• Deletes the current row from both the ResultSet and the underlying database.
• Example:

rs.next();
rs.deleteRow(); // Deletes the current row

8. moveToInsertRow()

• Moves the cursor to a special insert row buffer.
• Clear the row buffer and allow setting new values with updateXxx() methods.
• You must call insertRow() to actually insert the row into the database.

9. moveToCurrentRow()

• Moves the cursor back to the row it was on before moveToInsertRow() was called (if applicable).

Complete Example Combining Update Methods

Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery("SELECT id, name, age, salary FROM users");
if (rs.next()) {
    // Update an existing row
    rs.updateString("name", "John Updated");
    rs.updateInt("age", 40);
    rs.updateRow();
}

// Insert a new row
rs.moveToInsertRow();
rs.updateInt("id", 10);
rs.updateString("name", "New User");
rs.updateInt("age", 25);
rs.updateDouble("salary", 65000);
rs.insertRow();
rs.moveToCurrentRow();

// Delete a row
if (rs.absolute(3)) { rs.deleteRow(); } // Deletes the 3rd row

Metadata and State Methods

1. getMetaData()

• Returns general information about the columns (names, types, etc.) in this ResultSet.
• Returns a ResultSetMetaData object.
• Example:

ResultSetMetaData metaData = rs.getMetaData();
int columnCount = metaData.getColumnCount(); // Number of columns

2. getConcurrency()

• Returns the concurrency type of this ResultSet (e.g., CONCUR_READ_ONLY or CONCUR_UPDATABLE).
• Use: Check if ResultSet is updatable.
• Example:

int concurrency = rs.getConcurrency();
if (concurrency == ResultSet.CONCUR_UPDATABLE) {
    System.out.println("Updatable ResultSet");
}

3. getType()

• Returns the type of this ResultSet (e.g., TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, or TYPE_SCROLL_SENSITIVE).
• Example:

int type = rs.getType(); // E.g., ResultSet.TYPE_FORWARD_ONLY

4. getRow()

• Returns the current row number (starting from 1) of this ResultSet.
• Returns 0 if before the first row, after the last row, or if ResultSet is empty.
• Example:

int rowNumber = rs.getRow(); // If on 3rd row, returns 3

Miscellaneous Methods

1. wasNull()

• Used immediately after getXxx() or updateXxx() to check if the retrieved or updated value was SQL NULL.
• Use: Ensures that the value is not null before processing it.
• Example:

int age = rs.getInt("age");
if (rs.wasNull()) {
    System.out.println("Age is NULL");
}

2. close()

• Closes this ResultSet and releases resources.
• Automatically freed when associated Statement is closed or the next result is retrieved.
• Best Practice: Always close the ResultSet explicitly after use.

3. isClosed()

• Checks if this ResultSet is already closed.

4. getCursorName()

• Returns the name of the SQL cursor associated with this ResultSet.
• Rarely used. Most DBMSs will not use named cursors implicitly.

web.xml vs. application.xml vs. server.xml

web.xml (Deployment Descriptor for a Web Application)

• Found inside WEB-INF/ of a web module (WAR file).
• Defines configurations for servlets, filters, listeners, error pages, security constraints, etc.
• It is specific to web applications.

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         version="3.0">
    <servlet>
        <servlet-name>MyServlet</servlet-name>
        <servlet-class>com.example.MyServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>MyServlet</servlet-name>
        <url-pattern>/myServlet</url-pattern>
    </servlet-mapping>
</web-app>
  

application.xml (Deployment Descriptor for an EAR Application)

• Found inside META-INF/ of an Enterprise Application Archive (EAR) file.
• Defines the structure of an Enterprise Application that can contain multiple modules (WARs and EJB JARs).
• Used to declare and assemble web modules (WAR), EJB modules (JAR), and other components.

<application xmlns="http://java.sun.com/xml/ns/javaee"
             version="7">
    <module>
        <web>
            <web-uri>mywebapp.war</web-uri>
            <context-root>/myapp</context-root>
        </web>
    </module>
    <module>
        <ejb>myejb.jar</ejb>
    </module>
</application>
  

Key Differences

server.xml

server.xml is the configuration file for the application server, such as IBM WebSphere, Apache Tomcat, or other servlet containers. It is different from web.xml and application.xml, which are used for application-specific configurations.

✅ Java Code – Connect via JNDI and Query Snowflake

    import javax.naming.InitialContext;
    import javax.naming.Context;
    import javax.sql.DataSource;
    import java.sql.*;
    
    public class SnowflakeJNDIExample {
    
        public static void main(String[] args) {
            Connection conn = null;
    
            try {
                // Step 1: Get the JNDI context
                Context ctx = new InitialContext();
    
                // Step 2: Look up the DataSource
                DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/SnowflakeDS");
    
                // Step 3: Get a connection
                conn = ds.getConnection();
    
                System.out.println("✅ Connected to Snowflake via JNDI!");
    
                // Step 4: Run a test query
                Statement stmt = conn.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT CURRENT_TIMESTAMP");
    
                while (rs.next()) {
                    System.out.println("Current time from Snowflake: " + rs.getString(1));
                }
    
                rs.close();
                stmt.close();
    
            } catch (Exception e) {
                System.err.println("❌ Error connecting to Snowflake: " + e.getMessage());
                e.printStackTrace();
            } finally {
                try {
                    if (conn != null) conn.close();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
    

Defining Snowflake DataSource in server.xml

    <server description="Snowflake JNDI setup">
    
        <!-- Enable required features -->
        <featureManager>
            <feature>jdbc-4.2</feature>
        </featureManager>
    
        <!-- Snowflake JDBC Driver -->
        <library id="SnowflakeLib">
            <fileset dir="${server.config.dir}/lib" includes="snowflake-jdbc-*.jar"/>
        </library>
    
        <!-- DataSource configuration -->
        <dataSource id="SnowflakeDS" jndiName="jdbc/SnowflakeDS">
            <jdbcDriver libraryRef="SnowflakeLib"/>
            <properties>
                <property name="URL" value="jdbc:snowflake://<account>.snowflakecomputing.com/?user=<user>&password=<pwd>&db=<db>&schema=<schema>&warehouse=<wh>"/>
            </properties>
        </dataSource>
    
    </server>
    

Directory Structure with Snowflake JDBC Driver

    MyWebApp/
    ├── WEB-INF/
    │   ├── web.xml
    │   └── lib/
    │       └── snowflake-jdbc-<version>.jar  <-- if not in server lib
    └── SnowflakeJNDIExample.java
    

server.xml in Different Servers

1. WebSphere Application Server (server.xml)

• Located inside profile_root/config/cells/cellName/nodes/nodeName/servers/serverName/server.xml.
• Used to configure the WebSphere application server instance, including ports, data sources, security settings, logging, thread pools, and deployed applications.
• Changes require a server restart in most cases.

Example of server.xml in WebSphere 8.5

<server description="MyServer">
    <featureManager>
        <feature>jsp-2.2</feature>
        <feature>servlet-3.0</feature>
    </featureManager>

    <httpEndpoint id="defaultHttpEndpoint" host="*" httpPort="9080" httpsPort="9443"/>

    <applicationManager autoExpand="true"/>

    <webApplication location="mywebapp.war" contextRoot="/myapp"/>
</server>
  

2. Apache Tomcat (server.xml)

• Found inside $CATALINA_HOME/conf/server.xml.
• Defines the HTTP connector ports, hosts, engine, context settings, and logging.
• Modifications usually require a Tomcat restart.

Example of server.xml in Tomcat

<Server port="8005" shutdown="SHUTDOWN">
    <Service name="Catalina">
        <Connector port="8080" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
        <Engine name="Catalina" defaultHost="localhost">
            <Host name="localhost" appBase="webapps"
                  unpackWARs="true" autoDeploy="true">
                <Context path="/myapp" docBase="mywebapp"/>
            </Host>
        </Engine>
    </Service>
</Server>
  

Key Differences

When Do You Use Each?

• Modify web.xml → If you need to define servlets, filters, or security rules for your web app.
• Modify application.xml → If you’re working with an EAR and need to define multiple modules.
• Modify server.xml → If you need to change WebSphere/Tomcat server settings (ports, SSL, logging, etc.).

Understanding Network Protocol Layers in Simple Terms 🚀

Think of the internet as a postal service delivering messages (data) from one place (computer) to another. This entire system works in layers, each handling a different part of the process.

1️⃣ Link Layer (The Delivery Truck 🚚)

What it does:

• Responsible for physically moving data over a network.
• Uses cables, Wi-Fi, or cellular networks to send bits (1s and 0s).

Examples:

• PPP (Point-to-Point Protocol): Used for dial-up connections.
• Wi-Fi: Wireless communication.
• DSL (Digital Subscriber Line): Used for internet via telephone lines.

Analogy:

The link layer is like a delivery truck that carries letters (data) from one city (computer) to another.

2️⃣ Internet Layer (Finding the Right Address 📍)

What it does:

• Assigns addresses to devices and helps route data between them.
• Uses IP addresses to ensure data reaches the right destination.

Examples:

• IPv4: Uses 32-bit addresses (e.g., 192.168.1.1).
• IPv6: Uses 128-bit addresses (e.g., 2001:0db8:85a3::8a2e:0370:7334) to handle more devices.

Analogy:

The internet layer is like a postal service assigning addresses to every house so letters (data packets) go to the correct place.

3️⃣ Transport Layer (Ensuring Safe & Fast Delivery 📦✈️)

What it does:

• Breaks data into packets and ensures they arrive correctly.
• Manages speed, reliability, and error checking.

Examples:

• TCP (Transmission Control Protocol):
  • Ensures data arrives fully & in order (like sending a fragile package with tracking).
  • Used in websites, emails, file transfers.
• UDP (User Datagram Protocol):
  • Faster but no guarantee of delivery (like sending a postcard).
  • Used in live streaming, gaming, VoIP calls.

Analogy:

TCP is like a courier (FedEx, DHL) that ensures delivery with tracking and confirmation. UDP is like a postcard – sent quickly, but no guarantee it arrives.

4️⃣ Application Layer

Application Layer Explained in Simple Terms 🚀

The Application Layer is the topmost layer of the network model, and it is the one directly used by humans. It defines how applications (like web browsers, email clients, and file transfer programs) interact with the network. Think of it as the user interface of the internet—it ensures that when you visit a website, send an email, or download a file, the data is sent and received in a way your software understands.

🔹 What Does the Application Layer Do?

1. Provides Network Services to Users
   • Applications like Google Chrome, Gmail, and WhatsApp rely on this layer to send and receive data.
2. Formats Data for Communication
   • Converts data into the correct format before sending (e.g., a web page request).
3. Handles Authentication & Encryption
   • Secure connections using SSL/TLS (like HTTPS websites).

🔹 Real-World Examples of the Application Layer Protocols

🔹 Application Layer in Action (Everyday Example)

📌 Scenario: You Visit Google.com
1️⃣ You type www.google.com in your browser.
2️⃣ The browser uses DNS to find Google's IP address.
3️⃣ The browser sends an HTTP request to that IP address.
4️⃣ Google's server sends back the web page using HTTP.
5️⃣ Your browser displays the webpage.
🔹 The Application Layer handles steps 2-5, making sure your request reaches Google and the webpage loads properly.

🔹 Analogy: The Application Layer is Like a Waiter at a Restaurant 🍽️

• You (User) → Place an order (request for a web page).
• Waiter (Application Layer) → Translates your order into the kitchen's language (formats and sends the request).
• Chef (Server) → Cooks your food (processes your request).
• Waiter (Application Layer) → Brings the food to your table (delivers the webpage). Without the Waiter (Application Layer), You Can't Communicate with the Chef (Server)!

🔹 Why is the Application Layer Important?

• ✅ It makes the internet usable for humans.
• ✅ It manages web browsing, emails, file transfers, and more.
• ✅ It secures data transmission using HTTPS & SSL/TLS.

🎯 Final Takeaway

• The Application Layer is the closest to users and enables them to browse websites, send emails, download files, and more.
• It formats data, ensures security, and manages network requests.
• Without it, using the internet as we know it would be impossible!

🔹 Real-Life Analogy: Sending a Letter 📬

Imagine you’re sending a letter to a friend in another city. The process involves several steps, just like data traveling through network layers.

Now let’s see how these layers work together when you visit a website.

🔹 Example: Visiting Google.com

1. Application Layer (What the User Sees)
   • You type www.google.com into a browser.
   • The browser sends an HTTP request to Google’s server.
   • The Application Layer formats the request and sends it to the Transport Layer.
   • Protocols Used: HTTP/HTTPS, FTP, SMTP (emails), DNS
2. Transport Layer (Breaking Data Into Packets)
   • The Transport Layer breaks the HTTP request into smaller pieces called packets.
   • It labels each packet with numbers so they can be reassembled correctly.
   • It chooses whether to use:
     • TCP (for reliable delivery, like web browsing & emails)
     • UDP (for speed, like video calls & online gaming)
   • The packets are then sent to the Internet Layer.
   • Protocols Used: TCP, UDP
3. Internet Layer (Finding the Right Address)
   • The Internet Layer assigns an IP address to the packets.
   • It decides the best route for the data to travel.
   • Each packet is labeled with:
     • Source IP (Your Computer’s Address)
     • Destination IP (Google’s Server Address)
   • The packets are sent to the Link Layer for transmission.
   • Protocols Used: IPv4, IPv6
4. Link Layer (Sending the Data Over the Network)
   • The Link Layer physically sends the packets over Wi-Fi, Ethernet, or fiber cables.
   • It ensures packets reach the next hop (router, switch, etc.) in the journey.
   • If a packet gets lost, it resends it.
   • Finally, the data reaches Google’s server, and the process happens in reverse to send the webpage back to you!
   • Protocols Used: Wi-Fi, Ethernet, PPP

🔹 How the Layers Work Together (Step-by-Step Data Flow)

📌 When You Visit a Website (e.g., Google.com)

🔹 Final Summary

Understanding TCP and IP (TCP/IP Model)

TCP (Transmission Control Protocol) and IP (Internet Protocol) are core components of the TCP/IP model, which is the foundation of internet communication.

TCP and IP work together:

• IP handles addressing and routing of packets across networks.
• TCP ensures reliable, ordered, and error-checked delivery of data.

IP (Internet Protocol)

IP is responsible for addressing and routing packets from source to destination across different networks.

Key Features of IP:

1. Logical Addressing (IP Address)
   • Every device on a network has a unique IP address (e.g., 192.168.1.1 for IPv4, 2001:db8::ff00:42:8329 for IPv6).
2. Packet-Switched Communication
   • Data is broken into packets and sent independently.
3. Connectionless Protocol
   • IP does not establish a connection before sending packets.
4. Best-Effort Delivery
   • No guarantee that packets will arrive in order or at all.

IP Addressing & Routing:

• Every device on a network has an IP address.
• Routers forward packets to their destination based on the IP address.
• Uses subnetting and routing tables for efficient communication.

Example: A device with IP 192.168.1.10 sends a packet to 8.8.8.8 (Google’s DNS). The packet is forwarded by routers to reach the destination.

TCP (Transmission Control Protocol)

TCP ensures reliable, ordered, and error-checked delivery of data between applications.

Key Features of TCP:

1. Connection-Oriented
   • Establishes a connection before data transfer (using a three-way handshake).
2. Reliable Delivery
   • Ensures all packets arrive and are reassembled in the correct order.
3. Error Detection & Correction
   • Uses checksums to detect errors and acknowledgments (ACKs) to confirm receipt.
4. Flow Control & Congestion Control
   • Adjusts transmission speed based on network conditions.

TCP Three-Way Handshake (Connection Establishment):

1. SYN → Client sends a SYN (synchronize) packet to initiate a connection.
2. SYN-ACK → Server responds with SYN-ACK (synchronize acknowledgment).
3. ACK → Client sends an ACK, and the connection is established.

Client ---- SYN ----> Server
Client <-- SYN-ACK -- Server
Client ---- ACK ----> Server  (Connection Established)
    

TCP Communication Example (Sending Data):

1. TCP breaks data into packets.
2. Each packet gets a sequence number.
3. The receiver acknowledges received packets.
4. If a packet is lost, TCP retransmits it.

HTTP (HyperText Transfer Protocol)

HTTP is an application-layer protocol used for communication between web browsers and servers. It is built on TCP/IP.

Key Features of HTTP:

1. Stateless
   • Each request is independent; the server does not remember previous requests.
2. Uses TCP for Reliable Delivery
   • HTTP runs over TCP (typically port 80 for HTTP, 443 for HTTPS).
3. Request-Response Model
   • The client (browser) sends a request, and the server responds.
4. Supports Different Methods (HTTP Verbs)
   • GET, POST, PUT, DELETE, etc.
5. Supports Headers for Metadata
   • Headers contain details like content type, caching, authentication, etc.

HTTP Request-Response Cycle:

1. Client Request:

   GET /index.html HTTP/1.1
   Host: www.example.com
               

2. Server Response:

   HTTP/1.1 200 OK
   Content-Type: text/html
   Content-Length: 1024
   (Followed by the actual webpage content.)
               

Common HTTP Methods:

HTTP vs. HTTPS

• HTTP: Unencrypted communication (port 80).
• HTTPS: Uses SSL/TLS encryption (port 443) for security.

Summary of TCP, IP, and HTTP

Understanding HTTP Request Methods in Detail

1. GET (Retrieve Data)

• Requests data from the server using a URL.
• Does not modify server data.
• No request body; data sent as query parameters.
• Cacheable and idempotent.

GET /products?category=laptops&page=2 HTTP/1.1
Host: example.com

Example Response:

HTTP/1.1 200 OK
Content-Type: application/json

{
  "products": [
    { "id": 101, "name": "Laptop A", "price": 1000 },
    { "id": 102, "name": "Laptop B", "price": 1200 }
  ]
}

Handling Large Data

• Use pagination, compression, or streaming for large responses.

2. POST (Send Data)

• Sends data in the request body to create resources.
• Not idempotent.

POST /users HTTP/1.1
Host: example.com
Content-Type: application/json

{
  "name": "Alice",
  "email": "alice@example.com"
}

3. HEAD (Retrieve Headers Only)

• Similar to GET but does not return the response body.
• Used for checking metadata or existence of a resource.

4. TRACE (Debugging and Testing)

• Returns the received request to the client for debugging.
• Should be disabled in production.

5. PUT (Update or Create Resource)

• Uploads or replaces the entire resource at a given URL.
• Idempotent.

6. DELETE (Remove Resource)

• Deletes the resource at the given URL.
• Idempotent.

7. OPTIONS (Check Allowed Methods)

• Used to determine supported methods on a resource.
• Common in CORS preflight checks.

Comparison of HTTP Methods

Request and Response Format

• Header: Metadata such as content type, length, etc.
• Body: Actual data (only in POST/PUT responses)

GET vs POST

HTTP Status Codes

• 100–199: Informational
• 200–299: Success
• 300–399: Redirection
• 400–499: Client Error
• 500–599: Server Error

Server Overview

A server is a hardware machine running server software, accepting requests, processing them, and sending responses.

• Web Server: Handles static content and JSP/Servlets.
• Application Server: Adds support for EJB, JNDI, JMS, JTA, etc. (e.g., GlassFish, WebSphere).

Server vs Container

• Server interacts with the client; container interacts with the server.
• Static content: handled by server; dynamic content: handled by container.
• Types of containers: Web container (servlets/JSP), EJB container.

Tomcat Server Configuration

• Download the ZIP version, not the installer.
• While configuring, select only till the server folder (not /bin).
• Select web.xml when creating a dynamic web project.

Servlet Interface Hierarchy

• Servlet (interface) → GenericServlet → HttpServlet
• GenericServlet: protocol-independent
• HttpServlet: used for HTTP-specific requests (GET, POST, etc.)

Servlet Life cycle:

1. Servlet class is loaded:
   When a client requests for web application, the web container first looks for the servlet class. And if the request is for the first time, the servlet class is loaded into the memory. This loading happens only once per servlet class.
2. Servlet instance is created:
   After the servlet class is loaded, its instances are created to handle the servlet request. This also happens only once per servlet life cycle.
3. INIT() method is invoked:
   Once the init method is called (this method is invoked only once to initialize the servlet), inside the method the servlet can perform initialization tasks like (database connection, configuration).
4. Request Handling – service():
   This is used for handling the request. In this phase, service method is invoked.
5. destroy():
   Once the server is turned off, all the servlet and associated resources are removed.

Web.xml (deployment descriptor)

Where should the web.xml be created: It should be created in WEBAPP → (HTML, CSS), WEB-INF → web.xml

The web.xml syntax:

<webapp>
    <servlet>
        <servlet-name>any name as per our wish</servlet-name>
        <servlet-class>the class in which servlet logic is written</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>any name as per our wish but should be same as above</servlet-name>
        <url-pattern>the url from which we will get the call for servlet class</url-pattern>
    </servlet-mapping>
</webapp>
    

Note: In latest versions it's not mandatory to create a web.xml, we use annotations instead.

Servlet Annotation:

@WebServlet: This annotation is used where we don’t want to create a URL mapping using web.xml

Servlet Interface:

HttpServletRequest

✅ 1. Request Info

✅ 2. Request Parameters

✅ 3. Headers and Cookies

✅ 4. Session and Attributes

HttpServletResponse

✅ 1. Status & Headers

✅ 2. Content Settings

✅ 3. Output Streams

✅ 4. Cookies

Simple program 

Servlert class
package servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Addservlet extends HttpServlet{

public void service(HttpServletRequest req , HttpServletResponse res) throws IOException
{
    int num1= Integer.parseInt(req.getParameter("num1"));
    int num2= Integer.parseInt(req.getParameter("num2"));
    int result=num1+num2;

    PrintWriter pw=res.getWriter();
    pw.print(result);
}

}

Index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<form  action="add">

 Enter num1:<input type='text' name='num1'> 
 Enter num2:<input type='text' name='num2'> 
 <input type="submit">
</form>
</body>
</html>

Web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
  <display-name>servlet</display-name>
  
  <servlet>
  <servlet-name>add</servlet-name>
  <servlet-class>servlet.Addservlet</servlet-class>
  </servlet>
  <servlet-mapping>
  <servlet-name>add</servlet-name>
  <url-pattern>/add</url-pattern>
  </servlet-mapping>
  
</web-app>

Request Dispatcher
Calling one servlet from another servlet this can be done using request dispatcher.
Index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="add">
enter num1:<input type="text" name="num1" >
enter num2:<input type="text" name="num2" >
<input type="submit"'>
</form>
</body>
</html>

Add servlet
package servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Addservlet extends HttpServlet {

    public void service(HttpServletRequest req,HttpServletResponse res) throws IOException, ServletException
    {
        int num1=Integer.parseInt(req.getParameter("num1"));
        int num2=Integer.parseInt(req.getParameter("num2"));
        int result=num1+num2;
        //PrintWriter pw=res.getWriter();
        //pw.print(result);
        req.setAttribute("num1", num1);
        req.setAttribute("num2", num2);
        RequestDispatcher rd= req.getRequestDispatcher("sq");
        rd.forward(req, res);
    }
}

Sqservlet 
package servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Sq extends HttpServlet {

    public void service(HttpServletRequest req,HttpServletResponse res) throws IOException
    {
        int num1= (int) req.getAttribute("num1");
        int num2=(int) req.getAttribute("num2");
        int result= num1*num2;
        PrintWriter pw=res.getWriter();
        pw.print(result);
    //    RequestDispatcher rd= req.getRequestDispatcher("sq");
    }
}

Web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
  <display-name>Add</display-name>
  <servlet>
  <servlet-name>add</servlet-name>
  <servlet-class>servlet.Addservlet</servlet-class>
  </servlet>
  <servlet-mapping>
   <servlet-name>add</servlet-name>
   <url-pattern>/add</url-pattern>
 </servlet-mapping>
   <servlet>
  <servlet-name>square</servlet-name>
  <servlet-class>servlet.Sq</servlet-class>
  </servlet>
  <servlet-mapping>
   <servlet-name>square</servlet-name>
   <url-pattern>/sq</url-pattern>
 </servlet-mapping>

</web-app>

Calling one servlet using another servlet using reponse.sendRedirect("servet")
package servlet;

import java.io.IOException;
import java.net.http.HttpRequest;

import javax.servlet.http.*;
import javax.servlet.http.HttpServletResponse;

public class AddServlet extends HttpServlet {

    public void service(HttpServletRequest req,HttpServletResponse res) throws IOException
    {
        int num1=Integer.parseInt(req.getParameter("num1"));
        int num2=Integer.parseInt(req.getParameter("num2"));
        int result= num1+num2;
        res.sendRedirect("sq");
        // or passing results in the url along with redirecting
        res.sendRedirect("sq?="+result);
    }
}

Sqservlet  :
package servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Sqservlet  extends HttpServlet{
    public void service(HttpServletRequest req,HttpServletResponse res) throws IOException
    {
        int result= Integer.parseInt(req.getParameter("result"));
        PrintWriter pw=res.getWriter();
        pw.print(result);
    }
}

Http Session:
package servlet;

import java.io.IOException;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class Addservlet extends HttpServlet{

public void service(HttpServletRequest req, HttpServletResponse res) throws IOException
{
    int num1=Integer.parseInt(req.getParameter("num1"));
    int num2=Integer.parseInt(req.getParameter("num2"));
    int result=num1+num2;
    
    HttpSession s=req.getSession();
    s.setAttribute("result", result );
    res.sendRedirect("sq");
            
}
}

package servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class Sqservlet extends HttpServlet{

public void service(HttpServletRequest req, HttpServletResponse res) throws IOException
{
    HttpSession s=req.getSession();
    int result=(int) s.getAttribute("result");
    PrintWriter pw=res.getWriter();
    pw.print(result);
}
}

Cookie:

Cookie c=new Cookie(name, value) note:value should be cookie
Response.addCookie(c);
Example:
Int res=10;
Cookie c=new Cookie("res",k+"");   we are converting int k to string k to pass in cookie

To fetch all the cokies sent
Int result;
Cookie c[]=req.getCookies():
For(Cookie ck: c)
{
    If((ck.getName()).equals("result"))
    {
        Result=ck.getValuse()
    }
}

Example 
addservlet
package servlet;

import java.io.IOException;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Addservlet extends HttpServlet {

    public void service(HttpServletRequest req,HttpServletResponse res ) throws IOException
    {
        int num1= Integer.parseInt(req.getParameter("num1"));
        int num2= Integer.parseInt(req.getParameter("num2"));
    
        Cookie c=new Cookie("num1",num1+"");
        Cookie c1=new Cookie("num2",num2+"");
        res.addCookie(c);
        res.addCookie(c1);
        res.sendRedirect("sq");
        
    }
    
}

sqservlet
package servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Sqservlet  extends HttpServlet {

    int num1=0;
    int num2=0;
    public void service(HttpServletRequest req,HttpServletResponse res ) throws IOException
    {
        Cookie c1[]=req.getCookies();
        
        for (Cookie c:c1 )
        {
            if((c.getName()).equals("num1"))
            {
                num1=Integer.parseInt(c.getValue());
            }
        
            else if((c.getName()).equals("num2"))
            {
                num2=Integer.parseInt(c.getValue());
            }
        }
            
    int result =num1+num2;
    System.out.println(result);
    PrintWriter pw=res.getWriter();
    pw.print(result);
        
    }
}

JSP

There are three types of tags in JSP

1. Scriptlet
   • <% %> Scriptlet tag
   • <%! %> Declaration tag
   • <%= %> Expression tag
2. Directive Tags - <%@ %>
   • Page directive: <%@ page attribute="value" %> (refer next page)
   • Include directive
   • Taglib directive
3. Action Tags

Scriptlet Details

1. <% %> - Anything written here is like writing inside void service(HttpServletRequest, HttpServletResponse)
2. <%! %> - Anything written here is like writing outside the service method. You can create variables or other methods.
3. <%@ page import=”java.*”, “java.util.*” %> - Directive tags send instructions to the JSP container.
4. <%= k %> - Equivalent to out.print(k)
5. <jsp:... /> - Action tag

@page Directive in JSP

The @page directive in JSP is used to define global settings for a JSP page, such as its scripting language, buffer size, content type, error handling, and more. It provides instructions to the JSP container on how to process the page.

<%@ page attribute="value" %>

🔥 Attributes of @page Directive

Examples for Each Attribute

1️⃣ Set Content Type (HTML with UTF-8)

<%@ page contentType="text/html; charset=UTF-8" %>

✔ Ensures the page is displayed correctly in different languages.

2️⃣ Import Java Classes

<%@ page import="java.util.Date, java.util.List" %>

✔ Lets you use Date and List in your JSP page without writing full package names.

3️⃣ Enable/Disable Session

<%@ page session="false" %>

✔ If your page does not need session tracking (for better performance), set it to "false".

4️⃣ Error Handling (Redirect to Error Page)

<%@ page errorPage="error.jsp" %>

✔ If an error occurs, the user is sent to error.jsp.

✅ Inside error.jsp, add this:

<%@ page isErrorPage="true" %>

✔ Now, error.jsp can access exception objects like:

<%= exception.getMessage() %>

Understanding <%@ include file="..." %> (Static Include)

Imagine you’re writing an essay for school. Your teacher gave you a header that every student must use. Instead of writing it again, you just copy-paste it at the top of your document.

Now, in JSP Terms

<%@ include file="header.jsp" %>

• The content of header.jsp is copied into the main JSP page before the page runs.
• It happens only once, when the page is first loaded.

Example

📌 header.jsp

<h1>Welcome to My Website</h1>
<hr>

📌 index.jsp

<%@ include file="header.jsp" %>
<p>This is the homepage.</p>

🔹 Final Output

<h1>Welcome to My Website</h1>
<hr>
<p>This is the homepage.</p>

⚠ What’s the Catch?

If header.jsp is changed later, index.jsp won’t update automatically!

Real-World Analogy 🏠

Static Include = Copy-Pasting

When to Use <%@ include %>?

• ✅ When the included file doesn’t change often (e.g., static headers, footers).
• ✅ When you want better performance (since it's compiled once).
• ❌ Don’t use it if the included file changes frequently! Use <jsp:include> instead.

Quick Comparison

<%@ taglib %>

Imagine This:

You're running a café ☕, and every time a customer comes in, you have to greet them manually:
👉 “Hello, [Customer’s Name]! Welcome to our café!”

JSP tag libraries (<%@ taglib %>) work the same way!

📌 Without <%@ taglib %> (Manual Way)

<%
    String name = request.getParameter("name");
    if (name != null) {
        out.println("<h1>Hello, " + name + "!</h1>");
    } else {
        out.println("<h1>Hello, Guest!</h1>");
    }
%>

📌 With <%@ taglib %> (Smart Way)

Step 1: Define Tag Library (mytags.tld)

<taglib xmlns="http://java.sun.com/xml/ns/j2ee" version="1.2">
    <tlib-version>1.0</tlib-version>
    <short-name>MyTags</short-name>
    
    <tag>
        <name>greetUser</name>
        <tag-class>com.example.GreetUserTag</tag-class>
        <body-content>empty</body-content>
    </tag>
</taglib>

Step 2: Java Class (GreetUserTag.java)

package com.example;

import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class GreetUserTag extends SimpleTagSupport {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public void doTag() throws JspException, IOException {
        String message = (name != null) ? "Hello, " + name + "!" : "Hello, Guest!";
        getJspContext().getOut().print("<h1>" + message + "</h1>");
    }
}

Step 3: Use in JSP (index.jsp)

<%@ taglib uri="/WEB-INF/tlds/mytags.tld" prefix="mytag" %>
<mytag:greetUser name="John" />

✔ This prints:

<h1>Hello, John!</h1>

Final Comparison

🔹 Final Takeaway

• 💡 <%@ taglib %> lets you create custom JSP tags that replace repetitive Java code.
• 💡 It makes JSP pages cleaner, easier to read, and reusable—just like using a shortcut or mod in a video game!

JSP Action Tags Explained Simply
JSP action tags are special tags that let you control the behavior of your JSP page dynamically. They help include files, forward requests, work with JavaBeans, and more. Let’s go through all the important action tags one by one.
________________________________________
1. <jsp:include> – Include Another File
📌 What it does?
It adds the content of another file (like a JSP or HTML file) into the current page at runtime.
📌 Example:
If you have a header file (header.jsp), you can include it like this:
<jsp:include page="header.jsp" />
📌 Why use it?
If header.jsp changes, all pages using it will automatically get the updated content.
________________________________________
2. <jsp:forward> – Redirect to Another Page
📌 What it does?
It forwards the request to another page. The user never sees the original page.
📌 Example:
If a user is not logged in, redirect them to a login page:
<jsp:forward page="login.jsp" />
📌 Why use it?
To move users to another page based on conditions.
________________________________________
3. <jsp:param> – Pass Extra Data
📌 What it does?
It sends extra information when including or forwarding pages.
📌 Example (Passing a username to another JSP file):
<jsp:include page="welcome.jsp">
    <jsp:param name="username" value="JohnDoe" />
</jsp:include>
📌 Why use it?
To send small pieces of information like user details.
________________________________________
4. <jsp:useBean> – Create/Access JavaBean
📌 What it does?
It creates or fetches an existing JavaBean (a simple Java object used in JSP).
📌 Example (Creating a Bean for a User Object):
<jsp:useBean id="user" class="com.example.User" scope="session" />
📌 Why use it?
To store user details, settings, or any reusable data.
________________________________________
5. <jsp:setProperty> – Set a Bean Property
📌 What it does?
It updates the values of a JavaBean’s variables.
📌 Example (Setting a user’s name in a bean):
<jsp:setProperty name="user" property="name" value="John Doe" />
📌 Why use it?
To easily update values without writing Java code.
________________________________________
6. <jsp:getProperty> – Get a Bean Property
📌 What it does?
It retrieves a JavaBean’s variable value and displays it.
📌 Example (Getting the name of a user from a bean):
<jsp:getProperty name="user" property="name" />
📌 Why use it?
To display stored data like user names, emails, etc.
________________________________________
7. <jsp:plugin> – Embed Applets (Rarely Used)
📌 What it does?
It inserts a Java applet (a small Java program that runs in a browser). This is rarely used today.
📌 Example:
<jsp:plugin type="applet" code="MyApplet.class" width="300" height="300">
    <jsp:param name="bgcolor" value="blue" />
</jsp:plugin>
📌 Why use it?
You probably don’t need this, as Java applets are outdated.
________________________________________
8. <jsp:fallback> – Provide Backup for <jsp:plugin>
📌 What it does?
If a browser does not support Java applets, this tag shows alternative content.
📌 Example:
<jsp:plugin type="applet" code="MyApplet.class" width="300" height="300">
    <jsp:fallback>
        Sorry, your browser does not support Java applets.
    </jsp:fallback>
</jsp:plugin>
📌 Why use it?
Again, this is rarely used today.
________________________________________
Final Summary of JSP Action Tags
Tag	Purpose
<jsp:include>	Adds another file dynamically.
<jsp:forward>	Redirects to another page.
<jsp:param>	Passes additional data.
<jsp:useBean>	Creates or fetches a JavaBean.
<jsp:setProperty>	Updates a JavaBean's variable.
<jsp:getProperty>	Displays a JavaBean's variable.
<jsp:plugin>	Embeds a Java applet (outdated).
<jsp:fallback>	Shows alternate content for plugins.
What is Expression Language (EL)?
Imagine you’re using a vending machine 🥤. Instead of opening the machine and manually pulling out a drink, you just press a button (e.g., "Coca-Cola") and it magically appears!
Expression Language (EL) is like that button—it helps you get data easily from Java objects without writing complex Java code inside JSP pages.
________________________________________
🔹 Why Use Expression Language (EL)?
❌ Without EL (Old Java Way – Too Much Code 😩)
If we want to print a username stored in a request attribute, we write this:
<%
    String user = (String) request.getAttribute("username");
    out.println("Welcome, " + user);
%>
😡 Too much Java code inside JSP! Messy and hard to read!
✅ With EL (Simple and Clean 😃)
<p>Welcome, ${username}</p>
🎉 Much easier! No need for Java code!
________________________________________
🔹 EL Syntax (How It Works)
Expression Language (EL) always starts with ${} and can access:
•	Request Attributes → ${requestScope.name}
•	Session Attributes → ${sessionScope.user}
•	Application Attributes → ${applicationScope.data}
•	Parameters (Form Inputs, URLs) → ${param.email}
•	Cookies → ${cookie.userName.value}
•	Headers → ${header["User-Agent"]}
•	Functions (String, Math, Boolean) → ${10 + 20}, ${"hello".toUpperCase()}
________________________________________
🔹 EL Examples with Real Code
1️⃣ Accessing Request Attributes (Getting values stored in request scope)
📌 Java Code (Servlet that sets data)
request.setAttribute("username", "John123");
📌 JSP Code (Get Data Using EL)
<p>Welcome, ${username}!</p>
✔ Output:
Welcome, John123!
________________________________________
2️⃣ Accessing Session Attributes (Getting values stored in session scope)
📌 Java Code (Setting Data in Session)
session.setAttribute("user", "Alice");
📌 JSP Code (Get Data from Session)
<p>Hello, ${sessionScope.user}!</p>
✔ Output:
Hello, Alice!
________________________________________
3️⃣ Getting Form Data (Parameters from URL or Form)
📌 URL: http://example.com/page.jsp?email=john@example.com
📌 JSP Code (Access Query Parameter)
<p>Your email: ${param.email}</p>
✔ Output:
Your email: john@example.com
________________________________________
4️⃣ Accessing Cookies 🍪
📌 Java Code (Setting a Cookie)
Cookie cookie = new Cookie("userName", "Mike");
response.addCookie(cookie);
📌 JSP Code (Get Cookie Value Using EL)
<p>Welcome back, ${cookie.userName.value}!</p>
✔ Output:
Welcome back, Mike!
________________________________________
5️⃣ Using EL for Math Calculations
<p>Sum: ${10 + 5}</p>
<p>Multiplication: ${4 * 3}</p>
<p>Division: ${20 / 4}</p>
✔ Output:
Sum: 15
Multiplication: 12
Division: 5
________________________________________
6️⃣ Using EL Functions (String and Math)
✔ Convert to Uppercase:
<p>${"hello".toUpperCase()}</p>
✔ Length of a String:
<p>Length: ${fn:length("Hello World")}</p>
✔ Math Functions:
<p>Random Number: ${Math.random() * 100}</p>

2️⃣ Ternary Operator (? :) – If-Else in EL

Syntax:

${condition ? value_if_true : value_if_false}

Example: Checking User Role

<p>${userRole == "admin" ? "You have admin access" : "You are a regular user"}</p>

✔ If userRole == "admin", it prints:
You have admin access

✔ Otherwise, it prints:
You are a regular user

3️⃣ Logical Operators (&&, ||, !)

Syntax:

• && → AND
• || → OR
• ! → NOT

Example: Checking if user is an admin & logged in

<c:if test="${userRole == 'admin' && not empty username}">
    <p>Welcome, Admin ${username}!</p>
</c:if>

✔ If userRole is "admin" AND username exists, it prints:
Welcome, Admin John!

4️⃣ Checking If a Value is Empty

<p>${empty username ? "Guest" : "Welcome, " + username}</p>

✔ If username is empty, it prints:
Guest

✔ Otherwise, it prints:
Welcome, John!

🔹 Why Use Expression Language?

• ✅ Cleaner JSP Code – No Java code inside JSP!
• ✅ Short and Simple – ${name} is easier than writing <% %> blocks.
• ✅ Faster Development – No need to cast objects manually.

🔹 Final Takeaway 🎯

• 🔥 Expression Language (${}) makes JSP pages simpler and easier to read.
• 🔥 It replaces messy Java code with short expressions.
• 🔥 Great for accessing form data, cookies, sessions, and more!