Tag:

Java

Tutorial: Setting Up Java Hibernate Environment

written by 75ypsaw71

Hibernate is an Object-Relational Mapping (ORM) framework for Java that simplifies database interaction by mapping Java objects to database tables.

This tutorial explains how to set up and configure a Hibernate environment, including examples to demonstrate its usage.

1. What is Hibernate?

Hibernate simplifies database interaction by allowing you to work with Java objects instead of writing SQL queries. It abstracts database interactions and provides capabilities like lazy loading, caching, and automatic schema generation.

2. Prerequisites

Java Development Kit (JDK): Ensure JDK 8 or above is installed.
Database: Install and configure a database like MySQL, PostgreSQL, or H2.
IDE: Use an IDE like IntelliJ IDEA, Eclipse, or any editor of your choice.
Maven: Used for dependency management (can be replaced with Gradle).

3. Hibernate Core Components

Key Hibernate Components:

SessionFactory: Provides sessions for database operations.
Session: Manages the connection with the database.
Transaction: Handles database transactions.
Query: Executes HQL (Hibernate Query Language) or SQL queries.
Configuration: Configures Hibernate settings.

4. Setting Up Hibernate Environment

Step 4.1: Adding Hibernate Dependencies

Using Maven

Add the following dependencies to your pom.xml file:

<dependencies>
    <!-- Hibernate Core -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.6.15.Final</version>
    </dependency>
    
    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>

    <!-- H2 Database (Optional for Testing) -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <version>2.1.214</version>
    </dependency>
</dependencies>

Using Gradle

Add the dependencies to your build.gradle:

dependencies {
    implementation 'org.hibernate:hibernate-core:5.6.15.Final'
    implementation 'mysql:mysql-connector-java:8.0.33'
    implementation 'com.h2database:h2:2.1.214'
}

Step 4.2: Configuring Hibernate

Create a hibernate.cfg.xml Configuration File

The hibernate.cfg.xml file contains database connection properties and Hibernate settings. Place this file in the src/main/resources directory.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC 
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN" 
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- JDBC Database Connection Settings -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_demo</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>

        <!-- Hibernate Dialect -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Hibernate Properties -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>
</hibernate-configuration>

Step 4.3: Creating the Entity Class

Create a Java class that represents a database table. Annotate the class with Hibernate annotations to define the mapping.

import javax.persistence.*;

@Entity
@Table(name = "employees")
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "email")
    private String email;

    // Constructors
    public Employee() {}

    public Employee(String firstName, String lastName, String email) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }

    // Getters and Setters
    public int getId() {
        return id;
    }

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

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", email=" + email + "]";
    }
}

Step 4.4: Creating Hibernate Utility Class

This class simplifies the creation of the SessionFactory.

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static SessionFactory sessionFactory;

    static {
        try {
            sessionFactory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Employee.class).buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

5. Basic Hibernate Example

Save an Employee to the Database

import org.hibernate.Session;
import org.hibernate.Transaction;

public class HibernateExample {
    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;

        try {
            transaction = session.beginTransaction();

            // Create a new Employee
            Employee employee = new Employee("John", "Doe", "john.doe@example.com");

            // Save the Employee to the database
            session.save(employee);

            transaction.commit();
            System.out.println("Employee saved successfully!");
        } catch (Exception e) {
            if (transaction != null) transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}

6. Testing the Hibernate Setup

Run the Application: Run the HibernateExample class.
Verify the Database: Check the employees table in the database to ensure the data was inserted correctly.
Observe the Logs: Hibernate will print SQL queries to the console if hibernate.show_sql is enabled.

Conclusion

Setting up the Hibernate environment involves configuring dependencies, creating a configuration file, and defining your entity classes. This tutorial provides a step-by-step guide to help you get started with Hibernate.

With this setup in place, you can now explore advanced Hibernate features like criteria queries, HQL, and caching.

For more details, refer to the official Hibernate documentation.

January 13, 2025 0 comment

Advanced

Java Lambda Expressions

written by 75ypsaw71

Java Lambda Expressions, introduced in Java 8, provide a clear and concise way to represent one method interface using an expression.

They are particularly useful for functional interfaces, which are interfaces with a single abstract method.

Lambda expressions help simplify code by eliminating the need for anonymous classes, making code more readable and easier to maintain.

Syntax of Lambda Expressions

The syntax of a lambda expression is:

(parameters) -> expression
(parameters) -> { statements; }

(parameters): The input parameters for the method.
->: The arrow token separates parameters from the expression or block of code.
expression or { statements; }: The body of the lambda expression, which can either be a single expression or a block of statements.

Key Points about Lambda Expressions

Functional Interface Requirement: Lambda expressions can only be used with functional interfaces.
Type Inference: The types of parameters can be inferred by the compiler.
Conciseness: Lambdas simplify code by reducing boilerplate syntax.

Example 1: Basic Lambda Expression with Runnable

The Runnable interface is a functional interface with a single run() method, which is ideal for a lambda expression.

Example

public class LambdaRunnableExample {
    public static void main(String[] args) {
        // Using lambda expression for Runnable
        Runnable task = () -> System.out.println("Task is running");
        
        // Start a thread with the lambda expression
        Thread thread = new Thread(task);
        thread.start();
    }
}

Explanation

We create a Runnable using a lambda expression instead of an anonymous inner class.
Runnable task = () -> System.out.println(“Task is running”); represents the run() method of Runnable.

Output

Task is running

Example 2: Lambda Expression with Parameters

This example uses a lambda expression with parameters in the Comparator interface to compare two strings by their lengths.

Example

import java.util.Arrays;
import java.util.Comparator;

public class LambdaComparatorExample {
    public static void main(String[] args) {
        String[] names = { "John", "Alice", "Bob", "Charlie" };
        
        // Using lambda expression to sort by string length
        Arrays.sort(names, (s1, s2) -> Integer.compare(s1.length(), s2.length()));
        
        // Display sorted array
        System.out.println(Arrays.toString(names));
    }
}

Explanation

(s1, s2) -> Integer.compare(s1.length(), s2.length()) is a lambda expression that implements the compare method of Comparator<String>.
This lambda expression sorts strings by their lengths.

Output

[Bob, John, Alice, Charlie]

Example 3: Using Lambda with Custom Functional Interface

You can define your own functional interface to use with lambda expressions.

Example

@FunctionalInterface
interface Greeting {
    void sayHello(String name);
}

public class LambdaCustomInterfaceExample {
    public static void main(String[] args) {
        // Lambda expression for Greeting interface
        Greeting greeting = name -> System.out.println("Hello, " + name + "!");
        
        // Use the lambda expression
        greeting.sayHello("Alice");
        greeting.sayHello("Bob");
    }
}

Explanation

Greeting is a custom functional interface with a single method sayHello.
name -> System.out.println(“Hello, ” + name + “!”) is a lambda that implements sayHello to greet a user by name.

Output

Hello, Alice!
Hello, Bob!

Example 4: Lambda Expression with Block of Statements

If the lambda body has multiple statements, enclose them in curly braces { }.

Example

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

public class LambdaBlockExample {
    public static void main(String[] args) {
        // Lambda expression with multiple statements in the body
        MathOperation addition = (a, b) -> {
            System.out.println("Adding " + a + " and " + b);
            return a + b;
        };
        
        int result = addition.operate(5, 3);
        System.out.println("Result: " + result);
    }
}

Explanation

(a, b) -> { System.out.println(“Adding ” + a + ” and ” + b); return a + b; } has a block of statements within the lambda.
The lambda prints each operand before performing the addition.

Output

Adding 5 and 3
Result: 8

Example 5: Lambda Expressions with Predicate Functional Interface

The Predicate<T> interface is a generic functional interface that accepts a single argument and returns a boolean result. It’s commonly used in filter operations.

Example

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class LambdaPredicateExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // Predicate to check if a string starts with "A"
        Predicate<String> startsWithA = s -> s.startsWith("A");

        // Filter and print names starting with "A"
        names.stream()
             .filter(startsWithA)
             .forEach(System.out::println);
    }
}

Explanation

Predicate<String> startsWithA = s -> s.startsWith(“A”) checks if a string starts with “A”.
filter(startsWithA) filters the stream to include only names that start with “A”.

Output

Alice

Example 6: Using Lambda with Function Interface

The Function<T, R> interface is a functional interface that accepts one argument of type T and returns a result of type R.

Example

import java.util.function.Function;

public class LambdaFunctionExample {
    public static void main(String[] args) {
        // Function to calculate the square of an integer
        Function<Integer, Integer> square = x -> x * x;

        // Use the function
        System.out.println("Square of 5: " + square.apply(5));
        System.out.println("Square of 10: " + square.apply(10));
    }
}

Explanation

Function<Integer, Integer> square = x -> x * x; is a lambda that calculates the square of a number.
apply is called with the argument to calculate and print the square.

Output

Square of 5: 25
Square of 10: 100

Example 7: Method References with Lambda Expressions

Java provides method references as a shorthand notation for lambdas that call a single method. They are often used to refer to existing methods or constructors.

Example

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

public class LambdaMethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // Method reference instead of lambda expression
        names.forEach(System.out::println);
    }
}

Explanation

System.out::println is a method reference that refers to System.out.println(String).
This replaces a lambda that would have called println on each name in the list.

Output

Alice
Bob
Charlie

Example 8: Lambda Expression with BiFunction

The BiFunction<T, U, R> functional interface takes two arguments of types T and U, and returns a result of type R.

Example

import java.util.function.BiFunction;

public class LambdaBiFunctionExample {
    public static void main(String[] args) {
        // BiFunction to concatenate two strings with a space
        BiFunction<String, String, String> concatenate = (s1, s2) -> s1 + " " + s2;

        // Use the BiFunction
        String result = concatenate.apply("Hello", "World");
        System.out.println("Concatenated String: " + result);
    }
}

Explanation

(s1, s2) -> s1 + ” ” + s2 is a lambda that concatenates two strings with a space in between.
The apply method is called to concatenate “Hello” and “World”.

Output

Concatenated String: Hello World

Summary

Java lambda expressions simplify working with functional interfaces, making code more concise and readable.

Key points include:

Syntax: (parameters) -> expression or (parameters) -> { statements }.
Functional Interfaces: Lambdas work with interfaces that have a single abstract method.
Common Functional Interfaces:
- Runnable, Comparator, Predicate, Function, BiFunction, etc.
Method References: Provide a shorthand for lambdas that only call one method.

Lambda expressions are a core feature for functional programming in Java, making it easier to work with collections, streams, and functional interfaces.

November 4, 2024 0 comment

OOP

Java Hidden Classes

written by 75ypsaw71

In Java, Hidden Classes are a feature introduced in Java 15 as part of the JEP 371 proposal.

They are not meant for direct use by typical application developers but are more relevant to frameworks, libraries, and advanced use cases such as dynamic proxies and runtime code generation.

Hidden classes are non-discoverable, meaning they do not appear in the system dictionary, making them ideal for temporary, dynamically generated classes that should not be accessible through the usual reflection mechanisms.

Key Characteristics of Hidden Classes

Non-discoverable: Hidden classes are not visible in the usual class namespaces, so they cannot be accessed by name after creation.
Dynamic Generation: They are typically generated at runtime, not defined in source code.
Temporary Usage: They are often used in frameworks and libraries where a temporary, disposable class is needed.
Enhanced Security: Since hidden classes are isolated, they improve security and encapsulation by hiding implementation details from the global scope.

Creating Hidden Classes

To create a hidden class, we use the java.lang.invoke API, specifically MethodHandles and Lookup. We use Lookup.defineHiddenClass to define a hidden class at runtime.

Example Scenarios

Let’s look at some practical scenarios where hidden classes can be beneficial, along with examples.

Example 1: Creating a Simple Hidden Class

In this example, we’ll dynamically define a hidden class and invoke a method from it.

Code Example

import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.MethodHandle;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;

public class HiddenClassExample {
    public static void main(String[] args) throws Throwable {
        // Load bytecode for the hidden class (assuming it's pre-compiled)
        byte[] bytecode = Files.readAllBytes(Paths.get("MyHiddenClass.class"));

        // Use a Lookup to define a hidden class
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        Class<?> hiddenClass = lookup.defineHiddenClass(bytecode, true, MethodHandles.Lookup.ClassOption.NESTMATE).lookupClass();

        // Create a MethodHandle for the method we want to invoke
        MethodHandle hiddenMethod = lookup.findStatic(hiddenClass, "hiddenMethod", MethodType.methodType(void.class));

        // Invoke the hidden method
        hiddenMethod.invoke();
    }
}

// Hidden Class (pre-compiled and loaded as bytecode)
public class MyHiddenClass {
    public static void hiddenMethod() {
        System.out.println("Hello from the hidden class!");
    }
}

Explanation

Load Bytecode: We load the bytecode of the hidden class (e.g., MyHiddenClass.class) using Files.readAllBytes.
Define Hidden Class: We define the class as hidden using lookup.defineHiddenClass. The ClassOption.NESTMATE option makes it a nestmate of the current class, allowing access to its private members if needed.
Invoke Method: We create a MethodHandle to the hiddenMethod and then invoke it.

Note: Hidden classes are defined using bytecode rather than source code, so MyHiddenClass.class needs to be compiled separately.

Example 2: Using Hidden Classes in a Proxy Pattern

Hidden classes are commonly used in frameworks for creating dynamic proxies, where runtime-generated classes can implement or extend interfaces without being part of the main application’s codebase.

Code Example

import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodType;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;

interface Service {
    void execute();
}

public class HiddenProxyExample {
    public static void main(String[] args) throws Throwable {
        byte[] bytecode = Files.readAllBytes(Paths.get("ServiceProxy.class"));

        MethodHandles.Lookup lookup = MethodHandles.lookup();
        Class<?> proxyClass = lookup.defineHiddenClass(bytecode, true, MethodHandles.Lookup.ClassOption.NESTMATE).lookupClass();

        MethodHandle constructor = lookup.findConstructor(proxyClass, MethodType.methodType(void.class));
        Service proxyInstance = (Service) constructor.invoke();

        proxyInstance.execute();
    }
}

// Proxy implementation (compiled separately)
public class ServiceProxy implements Service {
    @Override
    public void execute() {
        System.out.println("Executing service via proxy.");
    }
}

Explanation

Define the Interface: We define a Service interface with an execute() method.
Hidden Proxy Class: The ServiceProxy class implements the Service interface and provides the execute method’s implementation.
Dynamic Proxy Creation: Using MethodHandles.Lookup, we load and create an instance of the hidden ServiceProxy class at runtime.
Invoke Method: Finally, we call the execute method through the Service interface, executing it dynamically.

Note: As in the previous example, ServiceProxy.class should be compiled in advance and provided as bytecode.

Example 3: Using Hidden Classes with Method Handles for Advanced Reflection

Hidden classes can work with MethodHandles to execute code that should be encapsulated and invisible to the outer application. Here, we’ll demonstrate creating a hidden class to encapsulate sensitive computations.

Code Example

import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodType;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;

public class HiddenComputeExample {
    public static void main(String[] args) throws Throwable {
        byte[] bytecode = Files.readAllBytes(Paths.get("ComputeClass.class"));

        MethodHandles.Lookup lookup = MethodHandles.lookup();
        Class<?> computeClass = lookup.defineHiddenClass(bytecode, true, MethodHandles.Lookup.ClassOption.NESTMATE).lookupClass();

        MethodHandle computeMethod = lookup.findStatic(computeClass, "compute", MethodType.methodType(int.class, int.class, int.class));
        int result = (int) computeMethod.invoke(10, 20);

        System.out.println("Computation result: " + result);
    }
}

// ComputeClass.java (compiled separately)
public class ComputeClass {
    public static int compute(int a, int b) {
        return a + b;
    }
}

Explanation

Hidden Compute Class: We create a ComputeClass that provides a compute method to add two numbers.
Defining Hidden Class: The MethodHandles.Lookup is used to define the ComputeClass as hidden.
Method Invocation: We retrieve a MethodHandle for the compute method and invoke it with the specified arguments, obtaining the computed result.

This example demonstrates how hidden classes can securely encapsulate computations or sensitive logic, shielding them from access via regular reflection.

Example 4: Conditional Access to Hidden Classes

Hidden classes can restrict their access within certain conditions, providing conditional behavior based on runtime data.

Code Example

import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodType;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;

public class ConditionalAccessExample {
    public static void main(String[] args) throws Throwable {
        if (System.getenv("ALLOW_ACCESS") != null) {
            byte[] bytecode = Files.readAllBytes(Paths.get("ConditionClass.class"));

            MethodHandles.Lookup lookup = MethodHandles.lookup();
            Class<?> conditionClass = lookup.defineHiddenClass(bytecode, true, MethodHandles.Lookup.ClassOption.NESTMATE).lookupClass();

            MethodHandle conditionMethod = lookup.findStatic(conditionClass, "conditionalAccess", MethodType.methodType(void.class));
            conditionMethod.invoke();
        } else {
            System.out.println("Access not allowed.");
        }
    }
}

// ConditionClass.java (compiled separately)
public class ConditionClass {
    public static void conditionalAccess() {
        System.out.println("Conditional access granted.");
    }
}

Explanation

Environment-based Access Control: Before loading the hidden class, the program checks if an environment variable ALLOW_ACCESS is set.
Defining Hidden Class Conditionally: If the condition is met, ConditionClass is defined and the method conditionalAccess is invoked.
Encapsulation: This approach shows how to restrict access to hidden class functionality based on runtime conditions.

Key Points to Remember about Hidden Classes

Usage: Hidden classes are designed primarily for frameworks and libraries rather than application code.
Method Handles: Hidden classes work closely with MethodHandles and Lookup to define classes and invoke their methods dynamically.
Isolation: Since hidden classes are non-discoverable, they help keep sensitive or temporary classes encapsulated.
No Direct Reference: Hidden classes cannot be referenced directly by name after their creation, enhancing security and encapsulation.

Summary

Java’s hidden classes provide a way to define classes dynamically at runtime, without polluting the global namespace.

They are useful for cases where a class is needed temporarily and should not be accessible outside its immediate context.

Hidden classes are particularly beneficial for frameworks and libraries that need to generate classes on the fly, allowing for encapsulation, security, and advanced reflective operations through MethodHandles.

November 4, 2024 0 comment

OOP

Java sealed classes

written by 75ypsaw71

Java sealed classes, introduced in Java 15 as a preview feature and finalized in Java 17, allow developers to define which classes or interfaces can extend or implement a given class or interface.

This provides more control over class hierarchies and helps achieve more predictable and maintainable code.

Key Features of Sealed Classes

Explicit Control: Sealed classes explicitly control which classes are allowed to extend them.
Enhanced Security and Maintainability: By restricting subclasses, you can ensure a limited set of extensions, making the code easier to reason about.
Compile-Time Safety: The compiler can check that only the specified subclasses extend or implement the sealed class or interface.

Syntax Overview

A sealed class is defined using the sealed keyword, followed by a permits clause that lists the classes allowed to extend it. Any class that extends a sealed class must use one of the following modifiers:

final: Indicates that this subclass cannot be extended further.
sealed: Indicates that the subclass itself is also sealed, continuing the restriction to further subclasses.
non-sealed: Removes the sealing constraint for this subclass, allowing it to be extended freely.

public sealed class Parent permits Child1, Child2 {
    // Class contents
}

public final class Child1 extends Parent {
    // Class contents
}

public sealed class Child2 extends Parent permits GrandChild {
    // Class contents
}

public non-sealed class GrandChild extends Child2 {
    // Class contents
}

Example 1: Basic Sealed Class

In this example, we define a sealed class Shape that has three permitted subclasses: Circle, Rectangle, and Square.

public sealed class Shape permits Circle, Rectangle, Square {
    public abstract double area();
}

public final class Circle extends Shape {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public final class Rectangle extends Shape {
    private final double width;
    private final double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }
}

public final class Square extends Shape {
    private final double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double area() {
        return side * side;
    }
}

Explanation

Shape is a sealed class that permits only Circle, Rectangle, and Square as subclasses.
Each subclass overrides the area method to calculate the area of the respective shape.
Each subclass is marked as final, meaning no further subclassing is allowed.

Example 2: Sealed Class with non-sealed Subclass

In this example, we modify the hierarchy by allowing the Rectangle class to be further extended.

public sealed class Shape permits Circle, Rectangle, Square {
    public abstract double area();
}

public final class Circle extends Shape {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public non-sealed class Rectangle extends Shape {
    private final double width;
    private final double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }
}

public final class Square extends Shape {
    private final double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double area() {
        return side * side;
    }
}

// A class extending Rectangle since it is non-sealed
public class ColoredRectangle extends Rectangle {
    private String color;

    public ColoredRectangle(double width, double height, String color) {
        super(width, height);
        this.color = color;
    }

    public String getColor() {
        return color;
    }
}

Explanation

Rectangle is marked as non-sealed, allowing it to be further extended.
ColoredRectangle extends Rectangle and adds a new property color.
Shape is still restricted to three subclasses, but Rectangle can have further subclasses due to the non-sealed modifier.

Example 3: Sealed Interface

Sealed classes are not limited to classes; they can also be applied to interfaces. Here’s an example with a sealed interface Vehicle.

public sealed interface Vehicle permits Car, Bike, Truck {
    void drive();
}

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

public final class Bike implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Riding a bike.");
    }
}

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

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

Explanation

Vehicle is a sealed interface, permitting only Car, Bike, and Truck.
Car and Bike are final classes, while Truck is non-sealed, allowing it to be further extended by other classes, such as PickupTruck.

Example 4: Sealed Class with Nested Classes

Using sealed classes with nested classes can help in encapsulating logic within a single outer class.

public class Company {

    public sealed class Employee permits Developer, Manager, Tester {
        public String name;

        public Employee(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    public final class Developer extends Employee {
        public Developer(String name) {
            super(name);
        }

        public void develop() {
            System.out.println(name + " is developing code.");
        }
    }

    public final class Manager extends Employee {
        public Manager(String name) {
            super(name);
        }

        public void manage() {
            System.out.println(name + " is managing the team.");
        }
    }

    public final class Tester extends Employee {
        public Tester(String name) {
            super(name);
        }

        public void test() {
            System.out.println(name + " is testing the code.");
        }
    }
}

Explanation

Employee is a sealed nested class within Company, permitting only Developer, Manager, and Tester as subclasses.
This allows the Company class to maintain strict control over the types of Employee objects that can exist within it.
Each subclass (e.g., Developer, Manager, and Tester) is marked as final.

Example 5: Using Sealed Classes in Pattern Matching (Java 17+)

With sealed classes, pattern matching in switch statements becomes more robust since the compiler knows all possible subclasses. This is especially useful when working with sealed hierarchies in switch expressions.

public sealed class Shape permits Circle, Rectangle, Square {
    public abstract double area();
}

public final class Circle extends Shape {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public final class Rectangle extends Shape {
    private final double width;
    private final double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }
}

public final class Square extends Shape {
    private final double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double area() {
        return side * side;
    }
}

// Pattern matching with a sealed class
public class TestPatternMatching {
    public static void printShapeDetails(Shape shape) {
        switch (shape) {
            case Circle c -> System.out.println("Circle with area: " + c.area());
            case Rectangle r -> System.out.println("Rectangle with area: " + r.area());
            case Square s -> System.out.println("Square with area: " + s.area());
        }
    }

    public static void main(String[] args) {
        Shape shape = new Circle(5.0);
        printShapeDetails(shape);

        shape = new Rectangle(4.0, 6.0);
        printShapeDetails(shape);
    }
}

Explanation

The Shape class hierarchy allows using pattern matching with switch.
The switch statement in printShapeDetails uses shape to match against Circle, Rectangle, and Square.
This pattern matching is exhaustive, meaning all cases are covered. If new subclasses are added to Shape, the compiler will enforce covering them in the switch, ensuring compile-time safety.

Summary

Java sealed classes provide a powerful way to control inheritance hierarchies, making it easier to enforce restricted extensions and ensuring safer, more maintainable code. Key points include:

Sealed classes restrict which classes can extend or implement them using the permits clause.
Modifiers for subclasses:
- final to prevent further subclassing.
- sealed to continue the hierarchy restrictions.
- non-sealed to remove the restriction, allowing further subclassing.
Pattern Matching Support in Java 17 and later, allowing exhaustive case matching.

Sealed classes are helpful in domain-driven design, data modeling, and any situation where a limited and predictable set of types is beneficial.

November 4, 2024 0 comment

Error Handling

Java throw keyword

written by 75ypsaw71

In Java, the throw keyword is used to explicitly throw an exception.

It’s a powerful feature for handling error cases in your programs. You can throw either checked or unchecked exceptions, depending on your needs.

Syntax

The syntax for throw is as follows:

throw new ExceptionType("Error message");

When throw is used, it immediately terminates the execution of the method and passes control to the nearest enclosing try-catch block or, if not caught, propagates the exception up the call stack.

1. Throwing an Unchecked Exception (RuntimeException)

An unchecked exception, or runtime exception, doesn’t need to be declared in the throws clause of the method. These exceptions are subclasses of RuntimeException.

Example: Throwing IllegalArgumentException

This example throws an IllegalArgumentException if the provided age is negative.

public class ThrowUncheckedExceptionExample {
    public static void checkAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        } else {
            System.out.println("Age is valid: " + age);
        }
    }

    public static void main(String[] args) {
        checkAge(25); // Valid case
        checkAge(-5); // Invalid case, throws exception
    }
}

Explanation

checkAge throws IllegalArgumentException if the age parameter is negative.
Since IllegalArgumentException is an unchecked exception, we don’t need to handle it or declare it in the method signature.
When checkAge(-5) is called, it throws the exception, stopping the method’s execution.

2. Throwing a Checked Exception (Exception)

Checked exceptions must either be caught or declared in the method signature using throws.

Common checked exceptions include IOException, SQLException, and Exception.

Example: Throwing IOException

This example demonstrates throwing an IOException when a file is not found.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class ThrowCheckedExceptionExample {
    public static void readFile(String filename) throws IOException {
        File file = new File(filename);
        if (!file.exists()) {
            throw new IOException("File not found: " + filename);
        }
        // Simulate reading the file
        System.out.println("Reading file: " + filename);
    }

    public static void main(String[] args) {
        try {
            readFile("test.txt"); // Throws exception if file doesn't exist
        } catch (IOException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }
}

Explanation

readFile throws an IOException if the specified file does not exist.
IOException is a checked exception, so readFile must declare it in its throws clause.
The main method catches and handles the exception, printing a message to the console.

3. Throwing a Custom Exception

You can create custom exceptions by extending the Exception or RuntimeException classes.

Custom exceptions are helpful when you want to handle application-specific errors.

Example: Creating and Throwing a Custom Exception

This example defines a custom exception InvalidScoreException and throws it if a score is out of a valid range.

class InvalidScoreException extends Exception {
    public InvalidScoreException(String message) {
        super(message);
    }
}

public class ThrowCustomExceptionExample {
    public static void validateScore(int score) throws InvalidScoreException {
        if (score < 0 || score > 100) {
            throw new InvalidScoreException("Score must be between 0 and 100.");
        } else {
            System.out.println("Score is valid: " + score);
        }
    }

    public static void main(String[] args) {
        try {
            validateScore(85);  // Valid score
            validateScore(110); // Invalid score, throws exception
        } catch (InvalidScoreException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }
}

Explanation

InvalidScoreException extends Exception, making it a checked exception.
validateScore throws an InvalidScoreException if the score is not between 0 and 100.
In main, validateScore(110) throws an exception, which is caught and handled.

4. Throwing Exceptions in a Method and Propagating to the Caller

Exceptions can be thrown in one method and then propagated up the call stack to the calling method if not handled.

This approach allows centralized exception handling in the calling method.

Example: Propagating an Exception

In this example, an exception thrown in processFile propagates to main.

import java.io.IOException;

public class ExceptionPropagationExample {
    public static void processFile(String filename) throws IOException {
        if (filename == null) {
            throw new IOException("Filename cannot be null");
        }
        System.out.println("Processing file: " + filename);
    }

    public static void processRequest(String filename) throws IOException {
        processFile(filename);
    }

    public static void main(String[] args) {
        try {
            processRequest(null);
        } catch (IOException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }
}

Explanation

processFile throws an IOException if the filename is null.
processRequest calls processFile and doesn’t handle the exception, so it propagates to main.
main catches the exception and handles it, centralizing error handling.

5. Using throw with try-catch-finally

The finally block is executed even if an exception is thrown.

This example demonstrates how to clean up resources after an exception is thrown.

public class ThrowWithFinallyExample {
    public static void divide(int numerator, int denominator) {
        try {
            if (denominator == 0) {
                throw new ArithmeticException("Cannot divide by zero");
            }
            System.out.println("Result: " + (numerator / denominator));
        } catch (ArithmeticException e) {
            System.out.println("Caught exception: " + e.getMessage());
        } finally {
            System.out.println("Cleaning up resources.");
        }
    }

    public static void main(String[] args) {
        divide(10, 2);  // Valid division
        divide(10, 0);  // Throws exception
    }
}

Explanation

If denominator is 0, ArithmeticException is thrown, and it’s caught in the catch block.
The finally block executes whether an exception is thrown or not, ensuring cleanup.

6. Throwing Exceptions in Constructors

You can use throw in constructors to validate parameters when creating an object.

This is useful to prevent invalid object creation.

Example: Throwing an Exception in a Constructor

In this example, a constructor throws an exception if an invalid parameter is passed.

class Employee {
    private String name;

    public Employee(String name) {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Name cannot be null or empty");
        }
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class ConstructorExceptionExample {
    public static void main(String[] args) {
        try {
            Employee emp = new Employee(""); // Throws exception
        } catch (IllegalArgumentException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }

        Employee emp2 = new Employee("Alice");
        System.out.println("Employee name: " + emp2.getName());
    }
}

Explanation

Employee constructor throws IllegalArgumentException if name is null or empty.
This ensures that an invalid Employee object can’t be created.
main catches and handles the exception.

7. Using throw with Multiple Exception Types

In Java, you can throw multiple types of exceptions based on different conditions within a single method.

Example: Throwing Multiple Exception Types

public class MultipleExceptionExample {
    public static void checkValue(int value) throws IllegalArgumentException, ArithmeticException {
        if (value < 0) {
            throw new IllegalArgumentException("Value cannot be negative");
        } else if (value == 0) {
            throw new ArithmeticException("Value cannot be zero");
        } else {
            System.out.println("Valid value: " + value);
        }
    }

    public static void main(String[] args) {
        try {
            checkValue(-1);
        } catch (IllegalArgumentException | ArithmeticException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }
}

Explanation

checkValue can throw either IllegalArgumentException if value is negative or ArithmeticException if value is zero.
In main, both exceptions are caught using a multi-catch block (catch (IllegalArgumentException | ArithmeticException e)).

Summary

The throw keyword in Java is used to create custom error-handling logic by explicitly throwing exceptions.

Key points include:

Unchecked Exceptions: Do not require throws in method signature and are often used for programmer errors (e.g., IllegalArgumentException).
Checked Exceptions: Must be declared in the method’s throws clause and are often used for recoverable errors (e.g

., IOException).

Custom Exceptions: Useful for application-specific error handling.
throw with try-catch-finally: Ensures resource cleanup.
Constructors and Methods: Constructors can throw exceptions to prevent invalid objects from being created.

Using throw effectively improves code robustness and provides clear error messaging.

November 4, 2024 0 comment

Error Handling

Java finally block

written by 75ypsaw71

In Java, the finally block is used in exception handling to ensure that a section of code is always executed, regardless of whether an exception is thrown or not.

The finally block is typically used to perform cleanup operations, like closing files, releasing resources, or closing database connections.

Syntax

The syntax for a try-catch-finally block is:

try {
    // Code that may throw an exception
} catch (ExceptionType e) {
    // Code to handle the exception
} finally {
    // Code that will always execute, regardless of an exception
}

The finally block is optional and can be used in any try-catch statement.

Even if an exception occurs and is handled (or not), the finally block will execute after the try and catch blocks.

1. Basic Example of the finally Block

In this example, we’ll see how a finally block is executed after a try block, even if no exception occurs.

public class FinallyExample {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block.");
        } catch (Exception e) {
            System.out.println("Inside catch block.");
        } finally {
            System.out.println("Inside finally block.");
        }
    }
}

Output

Inside try block.
Inside finally block.

Explanation

Since no exception is thrown in the try block, the catch block is skipped.
The finally block is executed immediately after the try block, displaying “Inside finally block”.

2. finally Block with an Exception Thrown

Here’s an example where an exception is thrown, but the finally block still executes after handling the exception.

public class FinallyWithException {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block.");
            int result = 10 / 0; // This will throw ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Exception caught: " + e);
        } finally {
            System.out.println("Inside finally block.");
        }
    }
}

Output

Inside try block.
Exception caught: java.lang.ArithmeticException: / by zero
Inside finally block.

Explanation

The try block throws an ArithmeticException due to division by zero.
The catch block catches the exception and prints a message.
The finally block is executed after the catch block, ensuring cleanup actions are always performed.

3. finally Block with System Exit

If you call System.exit() in a try or catch block, the finally block will not execute, as System.exit() terminates the program immediately.

public class FinallyWithExit {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block.");
            System.exit(0); // Exit the program
        } catch (Exception e) {
            System.out.println("Inside catch block.");
        } finally {
            System.out.println("Inside finally block."); // This will NOT execute
        }
    }
}

Output

Inside try block.

Explanation

System.exit(0); is called within the try block, causing the program to terminate immediately.
The finally block does not execute because the program has already exited.

4. Using finally for Resource Cleanup

The finally block is commonly used for closing resources like files, network connections, or database connections. This example shows how to use the finally block to ensure a file is closed after reading.

import java.io.*;

public class FinallyResourceCleanup {
    public static void main(String[] args) {
        BufferedReader reader = null;
        
        try {
            reader = new BufferedReader(new FileReader("example.txt"));
            String line = reader.readLine();
            System.out.println("First line of the file: " + line);
        } catch (IOException e) {
            System.out.println("An I/O error occurred: " + e.getMessage());
        } finally {
            try {
                if (reader != null) {
                    reader.close(); // Ensure the file is closed
                    System.out.println("File closed successfully.");
                }
            } catch (IOException e) {
                System.out.println("Failed to close the file.");
            }
        }
    }
}

Explanation

BufferedReader is used to read from a file named “example.txt”.
In the finally block, reader.close() is called to ensure the file is closed even if an exception occurs.
The finally block ensures that the resource (file) is always cleaned up.

5. Nested try-catch-finally Blocks

In Java, you can nest try-catch-finally blocks. In this example, an inner try-catch-finally block is placed inside an outer try-catch-finally.

public class NestedFinallyExample {
    public static void main(String[] args) {
        try {
            System.out.println("Outer try block.");
            try {
                System.out.println("Inner try block.");
                int result = 10 / 0; // This will throw ArithmeticException
            } catch (ArithmeticException e) {
                System.out.println("Inner catch block: " + e);
            } finally {
                System.out.println("Inner finally block.");
            }
        } catch (Exception e) {
            System.out.println("Outer catch block.");
        } finally {
            System.out.println("Outer finally block.");
        }
    }
}

Output

Outer try block.
Inner try block.
Inner catch block: java.lang.ArithmeticException: / by zero
Inner finally block.
Outer finally block.

Explanation

Both finally blocks are executed, ensuring cleanup for both inner and outer blocks.
The ArithmeticException in the inner try block is caught by the inner catch block.
Both the inner and outer finally blocks execute, demonstrating that each block maintains its own finally section.

6. finally Block with Multiple Exceptions

This example demonstrates how finally behaves with multiple exceptions.

public class FinallyWithMultipleExceptions {
    public static void main(String[] args) {
        try {
            int[] arr = new int[2];
            System.out.println("First element: " + arr[0]);
            System.out.println("Accessing out-of-bounds element: " + arr[3]); // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index out of bounds: " + e);
        } catch (Exception e) {
            System.out.println("General exception: " + e);
        } finally {
            System.out.println("Inside finally block.");
        }
    }
}

Output

First element: 0
Array index out of bounds: java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 2
Inside finally block.

Explanation

The try block throws an ArrayIndexOutOfBoundsException.
The catch block for ArrayIndexOutOfBoundsException handles this specific exception.
The finally block executes afterward, regardless of whether the exception is handled.

7. finally Block in a Method with a Return Statement

Even if a try or catch block has a return statement, the finally block will still execute before returning the value.

public class FinallyWithReturn {
    public static int testMethod() {
        try {
            System.out.println("Inside try block.");
            return 1;
        } catch (Exception e) {
            System.out.println("Inside catch block.");
            return 2;
        } finally {
            System.out.println("Inside finally block.");
        }
    }

    public static void main(String[] args) {
        int result = testMethod();
        System.out.println("Returned value: " + result);
    }
}

Output

Inside try block.
Inside finally block.
Returned value: 1

Explanation

testMethod() has a return statement in the try block.
Even though return 1 is executed, the finally block still executes before the method returns the value.
This behavior ensures that cleanup operations in finally are always performed.

Summary

The finally block is an essential feature in Java for resource management and cleanup.

It ensures that a specific block of code executes after try and catch blocks, regardless of exceptions.

Use Cases:

Closing files or database connections.
Releasing resources.
Ensuring important actions occur even if an exception is thrown.

Key Points:

The finally block always executes after try and catch blocks.
System.exit() will prevent the finally block from executing.
finally is still executed even if there’s a return in try or catch

November 4, 2024 0 comment

OOP

Java Static Classes

written by 75ypsaw71

In Java, the concept of a “static class” typically refers to static nested classes.

Java does not support creating a completely standalone static class, but a class defined within another class can be marked as static.

Static nested classes do not need an instance of the outer class to be created, making them useful when you want a nested class that is logically related to the outer class but doesn’t require an outer class instance to function.

Key Points About Static Nested Classes

A static nested class can be accessed directly using the outer class’s name.
Static nested classes can only access static members (variables and methods) of the outer class.
They are often used when a nested class should be associated with the outer class but not depend on an instance of it.

Example 1: Basic Static Nested Class

A simple example where a static nested class is used to print a message. The outer class has a static variable, which the static nested class can access directly.

class OuterClass {
    static String outerMessage = "Hello from the Outer Class";

    // Static nested class
    static class StaticNestedClass {
        public void printMessage() {
            System.out.println(outerMessage);
        }
    }
}

public class TestStaticNestedClass {
    public static void main(String[] args) {
        // Create an instance of the static nested class without an instance of the outer class
        OuterClass.StaticNestedClass nestedInstance = new OuterClass.StaticNestedClass();
        nestedInstance.printMessage();
    }
}

Explanation

StaticNestedClass is declared as static, so it can be created without an instance of OuterClass.
StaticNestedClass accesses the outerMessage variable directly, since it’s a static member of OuterClass.
In main, we create StaticNestedClass with OuterClass.StaticNestedClass, showing that we don’t need an instance of OuterClass.

Example 2: Utility Static Nested Class

Static nested classes are often used for utility methods that are closely related to the outer class. Here, a static nested class performs operations on the outer class’s data.

class MathOperations {
    private static int multiplier = 5;

    // Static nested class for utility methods
    static class Multiplier {
        public static int multiply(int x) {
            return x * multiplier;
        }

        public static int square(int x) {
            return x * x;
        }
    }
}

public class TestStaticUtilityClass {
    public static void main(String[] args) {
        int number = 4;
        
        // Accessing static methods of the nested class
        System.out.println("Multiply by 5: " + MathOperations.Multiplier.multiply(number));
        System.out.println("Square of 4: " + MathOperations.Multiplier.square(number));
    }
}

Explanation

MathOperations contains a static nested class called Multiplier, which includes methods for multiplying and squaring numbers.
Multiplier methods are static, making them easy to access with MathOperations.Multiplier.
This example demonstrates how to create a utility class within a class for related methods without requiring instances.

Example 3: Static Nested Class for Data Grouping

Static nested classes can be used to group related data or constants. In this example, we use a static nested class to group constants related to database configuration.

class DatabaseConfig {
    // Static nested class to hold constants
    static class DBConstants {
        public static final String DB_URL = "jdbc:mysql://localhost:3306/mydatabase";
        public static final String USER = "root";
        public static final String PASSWORD = "password";
    }
}

public class TestDatabaseConfig {
    public static void main(String[] args) {
        // Access constants via the static nested class
        System.out.println("Database URL: " + DatabaseConfig.DBConstants.DB_URL);
        System.out.println("User: " + DatabaseConfig.DBConstants.USER);
        System.out.println("Password: " + DatabaseConfig.DBConstants.PASSWORD);
    }
}

Explanation

DBConstants is a static nested class inside DatabaseConfig that groups constants related to database configuration.
Constants such as DB_URL, USER, and PASSWORD are accessed directly through the DBConstants class without creating instances.
This approach helps keep related constants organized within the outer class, keeping the code structured.

Example 4: Encapsulating Data with Static Nested Classes

Static nested classes are useful when you want to encapsulate data or behavior within an outer class. In this example, a static nested class models a coordinate in a Cartesian plane.

class Graph {
    // Static nested class representing a coordinate point
    static class Point {
        private int x, y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public void displayPoint() {
            System.out.println("Point (" + x + ", " + y + ")");
        }
    }
}

public class TestGraph {
    public static void main(String[] args) {
        // Create instances of the nested class
        Graph.Point point1 = new Graph.Point(5, 10);
        Graph.Point point2 = new Graph.Point(2, 3);

        // Display points
        point1.displayPoint();
        point2.displayPoint();
    }
}

Explanation

Point is a static nested class inside the Graph class, representing a point with x and y coordinates.
We create instances of Point without needing an instance of Graph.
This approach allows logically grouping Point with Graph while keeping them independent.

Example 5: Static Nested Class with Multiple Instances

Sometimes, a static nested class can act as a blueprint to create multiple related objects within an outer class, as shown below:

class Building {
    private static int buildingNumber = 101;

    // Static nested class representing a room
    static class Room {
        private int roomNumber;

        public Room(int roomNumber) {
            this.roomNumber = roomNumber;
        }

        public void showRoomDetails() {
            System.out.println("Building: " + buildingNumber + ", Room: " + roomNumber);
        }
    }
}

public class TestBuilding {
    public static void main(String[] args) {
        // Create multiple instances of the static nested class
        Building.Room room1 = new Building.Room(1);
        Building.Room room2 = new Building.Room(2);

        // Display room details
        room1.showRoomDetails();
        room2.showRoomDetails();
    }
}

Explanation

Room is a static nested class inside the Building class, representing rooms within a building.
buildingNumber is a static member of Building accessible within Room, meaning all rooms belong to the same building.
This example demonstrates using a static nested class to create multiple instances associated with the outer class’s static data.

Summary of Static Nested Classes

When to Use: Static nested classes are useful when you need a class related to an outer class but do not need access to its instance members.
Characteristics:
- Only has access to static members of the outer class.
- Does not require an instance of the outer class to be created.
Use Cases:
- Utility methods related to the outer class.
- Grouping constants.
- Encapsulating helper classes for complex outer class logic.
- Creating classes that are logically grouped with an outer class but independent of its instances.

Static nested classes provide a way to encapsulate helper classes or utility methods, making your code more modular and organized.

November 4, 2024 0 comment

OOP

Java inner classes

written by 75ypsaw71

Java inner classes are classes that are defined within another class.

They provide a way to logically group classes that are only used in one place and help encapsulate the outer class functionality by hiding the inner class.

In Java, there are several types of inner classes:

Let’s go through each type with examples.

1. Non-static Inner Class (Member Inner Class)

A non-static inner class, also known as a member inner class, is a class defined inside another class without the static keyword. This type of inner class has access to the outer class’s instance variables and methods.

Example of a Non-static Inner Class

class OuterClass {
    private String message = "Hello from OuterClass";

    // Inner class
    class InnerClass {
        public void displayMessage() {
            System.out.println("Message from OuterClass: " + message);
        }
    }

    public void createInner() {
        InnerClass inner = new InnerClass();
        inner.displayMessage();
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.createInner();

        // Alternatively, we can create an inner class instance directly
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.displayMessage();
    }
}

Explanation

The InnerClass is a non-static inner class, so it can access message, a private field in OuterClass.
We can create an instance of InnerClass using the outer class instance (outer.new InnerClass()).

2. Static Nested Class

A static nested class is a static class inside an outer class. Since it’s static, it doesn’t have access to instance variables or methods of the outer class, but it can access static members.

Example of a Static Nested Class

class OuterClass {
    private static String staticMessage = "Hello from OuterClass";

    // Static nested class
    static class StaticNestedClass {
        public void displayMessage() {
            System.out.println("Message from OuterClass: " + staticMessage);
        }
    }
}

public class TestStaticNestedClass {
    public static void main(String[] args) {
        // We can create an instance of the static nested class without an instance of the outer class
        OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
        nested.displayMessage();
    }
}

Explanation

StaticNestedClass is a static nested class. It doesn’t require an instance of OuterClass to be instantiated.
StaticNestedClass can access staticMessage, a static field of OuterClass, but not instance fields.

3. Local Inner Class (Defined within a Method)

A local inner class is defined within a method of an outer class. It can only be accessed within that method and has access to the method’s final or effectively final variables.

Example of a Local Inner Class

class OuterClass {
    public void display(final String name) {
        // Local inner class
        class LocalInnerClass {
            public void printName() {
                System.out.println("Name: " + name);
            }
        }

        // Create an instance of the local inner class and call its method
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.printName();
    }
}

public class TestLocalInnerClass {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display("Alice");
    }
}

Explanation

LocalInnerClass is defined inside the display method.
It can access name, a parameter of display. In Java, the local variables must be effectively final to be accessed by a local inner class.

4. Anonymous Inner Class

An anonymous inner class is a class without a name that is defined and instantiated all in one place. It’s commonly used to provide implementations for interfaces or abstract classes on the fly.

Example of an Anonymous Inner Class Implementing an Interface

interface Greeting {
    void sayHello();
}

public class TestAnonymousInnerClass {
    public static void main(String[] args) {
        // Create an anonymous inner class that implements Greeting
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello from an anonymous inner class!");
            }
        };

        greeting.sayHello();
    }
}

Explanation

The anonymous inner class implements the Greeting interface without creating a separate class.
The sayHello method is implemented on the spot, and we can call it directly.

Example of an Anonymous Inner Class Extending a Class

abstract class Animal {
    abstract void sound();
}

public class TestAnonymousInnerClass {
    public static void main(String[] args) {
        // Create an anonymous inner class that extends Animal
        Animal dog = new Animal() {
            @Override
            public void sound() {
                System.out.println("Woof Woof");
            }
        };

        dog.sound();
    }
}

Explanation

The anonymous inner class extends the Animal class and provides an implementation for the sound method directly where it is defined.

Summary

Non-static Inner Class: A regular inner class with access to the outer class’s instance variables. Requires an outer class instance to instantiate.
Static Nested Class: A static class inside another class. Doesn’t require an outer class instance and can only access static members.
Local Inner Class: Defined inside a method and can access method variables that are final or effectively final.
Anonymous Inner Class: A class with no name, defined and instantiated in one place, used mainly to provide implementations for interfaces or abstract classes.

Inner classes are useful for organizing code and implementing event listeners, callbacks, and other encapsulated logic specific to the outer class.

November 4, 2024 0 comment

Error Handling

Java Nested try Blocks tutorial with code examples

written by 75ypsaw71

Nested try blocks in Java are a way to handle complex error scenarios by allowing try blocks within other try or catch blocks.

This is especially useful when you need to perform multiple operations that might each throw different exceptions, or if one exception may lead to another operation that could also fail.

Here’s a step-by-step tutorial with code examples to illustrate how nested try blocks work in Java.

1. Basic Syntax of Nested try Blocks

In a nested try structure, you place one try block inside another. Here's the basic syntax:

try {
    // Outer try block
    try {
        // Inner try block
    } catch (ExceptionType e) {
        // Handle exception from the inner try block
    }
} catch (ExceptionType e) {
    // Handle exception from the outer try block
}

In this structure, the outer try block catches any exceptions not caught by the inner try block.

2. Example 1: Handling Two Different Exceptions in Nested try Blocks

Suppose you have a situation where you are performing both array access and division.

Both operations can throw different exceptions (ArrayIndexOutOfBoundsException and ArithmeticException).

Here’s an example:

public class NestedTryExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 0};
        
        try {
            System.out.println("Outer try block");
            int result = 0;
            
            // Nested try block for array access
            try {
                System.out.println("Inner try block for array");
                result = numbers[3]; // May throw ArrayIndexOutOfBoundsException
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("Caught ArrayIndexOutOfBoundsException: " + e.getMessage());
            }
            
            // Nested try block for division
            try {
                System.out.println("Inner try block for division");
                result = numbers[1] / numbers[2]; // May throw ArithmeticException
            } catch (ArithmeticException e) {
                System.out.println("Caught ArithmeticException: " + e.getMessage());
            }
            
            System.out.println("Result: " + result);
            
        } catch (Exception e) {
            System.out.println("Caught Exception in outer try block: " + e.getMessage());
        }
        
        System.out.println("End of program");
    }
}

Output Explanation:

The first try block attempts to access an out-of-bounds index in numbers.
If ArrayIndexOutOfBoundsException occurs, it is caught by the inner catch.
The second try block tries to perform a division by zero.
If ArithmeticException occurs, it is caught by its respective inner catch.

3. Example 2: Propagating Exceptions to Outer catch

In some cases, you may want to handle exceptions in the outer catch block only if they are not handled in the inner block.

public class NestedTryExample2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};

        try {
            System.out.println("Outer try block");

            // Inner try block for array access
            try {
                System.out.println("Inner try block for array");
                int result = arr[5]; // Causes ArrayIndexOutOfBoundsException
                System.out.println("Result: " + result);
            } catch (ArithmeticException e) {
                System.out.println("This will not catch ArrayIndexOutOfBoundsException.");
            }

            System.out.println("This line in the outer try will not be executed.");

        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Caught ArrayIndexOutOfBoundsException in the outer catch: " + e.getMessage());
        }

        System.out.println("End of program");
    }
}

In this example:

The ArrayIndexOutOfBoundsException in the inner block is not caught by the inner catch because it is set to handle only ArithmeticException.
Instead, it propagates to the outer catch, which handles ArrayIndexOutOfBoundsException.

4. Example 3: Using Multiple Inner try Blocks

Sometimes, you may need more than one nested try block. Here’s an example where we try multiple operations, each in its own inner try block.

public class NestedTryExample3 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 0};
        
        try {
            System.out.println("Outer try block");

            // First inner try block
            try {
                System.out.println("First inner try block");
                int result = arr[3]; // May throw ArrayIndexOutOfBoundsException
                System.out.println("Result from first inner try: " + result);
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("Caught ArrayIndexOutOfBoundsException: " + e.getMessage());
            }

            // Second inner try block
            try {
                System.out.println("Second inner try block");
                int result = arr[1] / arr[2]; // May throw ArithmeticException
                System.out.println("Result from second inner try: " + result);
            } catch (ArithmeticException e) {
                System.out.println("Caught ArithmeticException: " + e.getMessage());
            }

        } catch (Exception e) {
            System.out.println("Caught exception in outer try block: " + e.getMessage());
        }

        System.out.println("End of program");
    }
}

In this example:

The outer try contains two separate inner try blocks for different operations.
Each inner block has its own catch block for specific exceptions.
Any uncaught exceptions would propagate to the outer catch block.

5. Tips for Using Nested try Blocks

Avoid Overusing: Nested try blocks can become difficult to read. Only use them when truly necessary.
Handle Specific Exceptions Closest to the Source: Try to handle exceptions in the innermost catch blocks to avoid unnecessarily propagating them up.
Use Nested Blocks for Related Operations: If several operations are related and each might fail independently, nested try blocks help isolate errors.

Conclusion

Nested try blocks in Java offer a way to manage complex error scenarios, especially when dealing with multiple independent operations that may throw different exceptions.

October 25, 2024 0 comment

Advanced

Java Regular Expressions tutorial with Examples

written by 75ypsaw71

Regular Expressions (Regex) in Java provide a powerful way to search, match, and manipulate strings.

They are part of the java.util.regex package and allow you to use patterns to locate, extract, and replace specific text patterns within strings.

In this tutorial, we will cover:

Basic Usage of Regular Expressions in Java
Common Regex Patterns and Examples
Using Pattern and Matcher Classes for Matching
Search and Replace with Regex
Splitting Strings Using Regex

Let's explore each section with examples.

1. Basic Usage of Regular Expressions in Java

Java provides the Pattern and Matcher classes for handling regex operations.

The Pattern class compiles a regex pattern, while the Matcher class applies the pattern to a target string.

Example 1: Basic Matching

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class BasicRegexExample {
    public static void main(String[] args) {
        String text = "Java is a powerful programming language.";
        String pattern = "powerful";

        // Compile the pattern
        Pattern compiledPattern = Pattern.compile(pattern);
        
        // Create a matcher to search for the pattern
        Matcher matcher = compiledPattern.matcher(text);
        
        if (matcher.find()) {
            System.out.println("Match found!");
        } else {
            System.out.println("No match found.");
        }
    }
}

Explanation: This example checks if the word “powerful” exists in the text string. matcher.find() returns true if a match is found.

2. Common Regex Patterns and Examples

Java regular expressions follow the same basic syntax as other languages.

Here are some common patterns:

Pattern	Description	Example
.	Any character	a.c matches “abc”, “adc”
\d	Any digit (0-9)	\d matches “3” in “123abc”
\D	Any non-digit	\D matches “a” in “123abc”
\w	Any word character (a-z, A-Z, 0-9, _)	\w+ matches “abc123”
\s	Any whitespace character	\s matches space in “a b”
[abc]	Any character in set	[aeiou] matches “a” in “cat”
[^abc]	Any character not in set	[^aeiou] matches “c” in “cat”
`a	b`	Either a or b
*, +, ?	Zero or more, one or more, zero or one	a*, a+, a?
{n,m}	Between n and m repetitions	a{2,4} matches “aa”, “aaa”

Example 2: Using Common Patterns to Match Strings

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class PatternExample {
    public static void main(String[] args) {
        String text = "Contact us at info@example.com or visit www.example.com";
        String emailPattern = "\\w+@\\w+\\.\\w+";  // Email pattern
        String urlPattern = "www\\.\\w+\\.\\w+";   // URL pattern

        // Match email
        Matcher emailMatcher = Pattern.compile(emailPattern).matcher(text);
        if (emailMatcher.find()) {
            System.out.println("Email found: " + emailMatcher.group());
        }

        // Match URL
        Matcher urlMatcher = Pattern.compile(urlPattern).matcher(text);
        if (urlMatcher.find()) {
            System.out.println("URL found: " + urlMatcher.group());
        }
    }
}

Output:

Email found: info@example.com
URL found: www.example.com

Explanation: The email pattern \\w+@\\w+\\.\\w+ matches a basic email format, and the URL pattern www\\.\\w+\\.\\w+ matches web addresses starting with www.

3. Using Pattern and Matcher Classes for Matching

The Pattern and Matcher classes provide methods like matches(), find(), and group() for working with regular expressions.

Example 3: Extracting Groups with Pattern and Matcher

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class GroupExample {
    public static void main(String[] args) {
        String text = "User: JohnDoe, Email: john.doe@example.com";
        String pattern = "(\\w+): (\\w+), Email: (\\w+\\.\\w+@\\w+\\.\\w+)";

        Matcher matcher = Pattern.compile(pattern).matcher(text);

        if (matcher.find()) {
            System.out.println("Username: " + matcher.group(2));
            System.out.println("Email: " + matcher.group(3));
        }
    }
}

Output:

Username: JohnDoe
Email: john.doe@example.com

Explanation: Using parentheses in the pattern (…) creates capturing groups. matcher.group(2) extracts the username, and matcher.group(3) extracts the email.

4. Search and Replace with Regex

The replaceAll() method allows you to replace matched patterns with a specific string.

Example 4: Replacing Words in a String

public class ReplaceExample {
    public static void main(String[] args) {
        String text = "Java is great. Java is powerful.";
        String updatedText = text.replaceAll("Java", "Python");

        System.out.println("Updated text: " + updatedText);
    }
}

Output:

Updated text: Python is great. Python is powerful.

Explanation: This example replaces all occurrences of “Java” with “Python” using replaceAll().

Example 5: Using Regex in Replace to Format a String

public class FormatExample {
    public static void main(String[] args) {
        String text = "UserID123";
        String formattedText = text.replaceAll("(UserID)(\\d+)", "$1-#$2");

        System.out.println("Formatted text: " + formattedText);
    }
}

Output:

Formatted text: UserID-#123

Explanation: Using replaceAll() with () captures groups in the pattern and replaces them in the output. $1 and $2 reference the groups.

5. Splitting Strings Using Regex

You can split a string into parts based on a regex pattern with split().

Example 6: Splitting a String by Multiple Delimiters

import java.util.Arrays;

public class SplitExample {
    public static void main(String[] args) {
        String text = "apple,orange;banana|grape";
        String[] fruits = text.split("[,;|]");

        System.out.println("Fruits: " + Arrays.toString(fruits));
    }
}

Output:

Fruits: [apple, orange, banana, grape]

Explanation: The pattern [ ,;|] matches commas, semicolons, or vertical bars, and split() divides the string based on any of these delimiters.

Example 7: Splitting a String by Whitespace and Trimming Extra Spaces

public class SplitTrimExample {
    public static void main(String[] args) {
        String text = " Java    is  powerful ";
        String[] words = text.trim().split("\\s+");

        for (String word : words) {
            System.out.println(word);
        }
    }
}

Output:

Java
is
powerful

Explanation: The split(“\\s+”) pattern splits by one or more whitespace characters, and trim() removes leading and trailing spaces.

Summary of Regular Expressions in Java

Regex Function	Description
Pattern.compile()	Compiles a regex pattern.
matcher()	Creates a Matcher instance for applying the pattern.
find()	Searches for the next match of the pattern in the text.
matches()	Checks if the entire text matches the regex pattern.
group()	Returns matched groups from the pattern using capturing groups.
replaceAll()	Replaces all matches in the text with a specified replacement.
split()	Splits text into an array based on the regex pattern.

Conclusion

In this tutorial, we explored various ways to use regular expressions in Java, including:

Basic pattern matching with Pattern and Matcher.
Common regex patterns for matching strings.
Extracting groups from matches.
Using regex to search and replace text.
Splitting text based on complex patterns.

October 25, 2024 0 comment

Newer Posts

Older Posts

Java

Table of Contents

1. What is Hibernate?

2. Prerequisites

3. Hibernate Core Components

Key Hibernate Components:

4. Setting Up Hibernate Environment

Step 4.1: Adding Hibernate Dependencies

Using Maven

Using Gradle

Step 4.2: Configuring Hibernate

Create a hibernate.cfg.xml Configuration File

Step 4.3: Creating the Entity Class

Step 4.4: Creating Hibernate Utility Class

5. Basic Hibernate Example

Save an Employee to the Database

6. Testing the Hibernate Setup

Conclusion

Syntax of Lambda Expressions

Key Points about Lambda Expressions

Example 1: Basic Lambda Expression with Runnable

Example

Explanation

Output

Example 2: Lambda Expression with Parameters

Example

Explanation

Output

Example 3: Using Lambda with Custom Functional Interface

Example

Explanation

Output

Example 4: Lambda Expression with Block of Statements

Example

Explanation

Output

Example 5: Lambda Expressions with Predicate Functional Interface

Example

Explanation

Output

Example 6: Using Lambda with Function Interface

Example

Explanation

Output

Example 7: Method References with Lambda Expressions

Example

Explanation

Output

Example 8: Lambda Expression with BiFunction

Example

Explanation

Output

Summary

Key Characteristics of Hidden Classes

Creating Hidden Classes

Example Scenarios

Example 1: Creating a Simple Hidden Class

Code Example

Explanation

Example 2: Using Hidden Classes in a Proxy Pattern

Code Example

Explanation

Example 3: Using Hidden Classes with Method Handles for Advanced Reflection

Code Example

Explanation

Example 4: Conditional Access to Hidden Classes

Code Example

Explanation

Key Points to Remember about Hidden Classes

Summary

Key Features of Sealed Classes

Syntax Overview

Example 1: Basic Sealed Class

Explanation

Example 2: Sealed Class with non-sealed Subclass

Explanation

Example 3: Sealed Interface

Explanation

Example 4: Sealed Class with Nested Classes

Explanation