Home » Tutorials » OOP
Category:

OOP

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

  1. Non-discoverable: Hidden classes are not visible in the usual class namespaces, so they cannot be accessed by name after creation.
  2. Dynamic Generation: They are typically generated at runtime, not defined in source code.
  3. Temporary Usage: They are often used in frameworks and libraries where a temporary, disposable class is needed.
  4. 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

  1. Load Bytecode: We load the bytecode of the hidden class (e.g., MyHiddenClass.class) using Files.readAllBytes.
  2. 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.
  3. 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

  1. Define the Interface: We define a Service interface with an execute() method.
  2. Hidden Proxy Class: The ServiceProxy class implements the Service interface and provides the execute method’s implementation.
  3. Dynamic Proxy Creation: Using MethodHandles.Lookup, we load and create an instance of the hidden ServiceProxy class at runtime.
  4. 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

  1. Hidden Compute Class: We create a ComputeClass that provides a compute method to add two numbers.
  2. Defining Hidden Class: The MethodHandles.Lookup is used to define the ComputeClass as hidden.
  3. 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

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

Key Points to Remember about Hidden Classes

  1. Usage: Hidden classes are designed primarily for frameworks and libraries rather than application code.
  2. Method Handles: Hidden classes work closely with MethodHandles and Lookup to define classes and invoke their methods dynamically.
  3. Isolation: Since hidden classes are non-discoverable, they help keep sensitive or temporary classes encapsulated.
  4. 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.

0 comment
0 FacebookTwitterPinterestEmail
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

  1. Explicit Control: Sealed classes explicitly control which classes are allowed to extend them.
  2. Enhanced Security and Maintainability: By restricting subclasses, you can ensure a limited set of extensions, making the code easier to reason about.
  3. 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.

0 comment
0 FacebookTwitterPinterestEmail
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.

0 comment
0 FacebookTwitterPinterestEmail
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.

0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Access Modifiers Tutorial with Examples

written by 75ypsaw71

In Java, access modifiers control the visibility and accessibility of classes, methods, and variables. They are an essential part of encapsulation, which is one of the key principles of Object-Oriented Programming (OOP).

Java provides four types of access modifiers:

  1. Private: Accessible only within the same class.
  2. Default (Package-private): Accessible only within the same package.
  3. Protected: Accessible within the same package and also in subclasses.
  4. Public: Accessible from everywhere.

In this tutorial, we will cover:

Let’s dive into each type of access modifier with examples!

1. What are Access Modifiers?

Access modifiers in Java define how the members (variables, methods, constructors) and classes themselves can be accessed. They control visibility and ensure that sensitive data or behavior is encapsulated within a class or a package.

The Four Types of Access Modifiers:

  • Private: Restricted to the same class.
  • Default (Package-private): Accessible only within the same package. (No explicit keyword is used.)
  • Protected: Accessible within the same package and by subclasses (even in different packages).
  • Public: Accessible from any other class.

2. Private Access Modifier

The private access modifier makes a member visible only within its own class. No other class can access this member, even if they are in the same package.

Example: Private Access Modifier

class PrivateExample {
    private String secretMessage = "This is private";

    private void showSecret() {
        System.out.println(secretMessage);
    }

    public void publicMethod() {
        System.out.println("Public method called.");
        showSecret();  // Private method accessed inside the class
    }
}

public class Main {
    public static void main(String[] args) {
        PrivateExample obj = new PrivateExample();
        obj.publicMethod();  // Output: Public method called. This is private.

        // Below lines will throw errors because secretMessage and showSecret() are private
        // System.out.println(obj.secretMessage);  // Error
        // obj.showSecret();  // Error
    }
}

Explanation:

  • The variable secretMessage and the method showSecret() are marked as private and can only be accessed within the PrivateExample class.
  • The publicMethod() method can call the private method because it is inside the same class.

3. Default (Package-private) Access Modifier

If no access modifier is specified, Java applies default access (also known as package-private access). Members with default access are accessible by any class within the same package but not from other packages.

Example: Default Access Modifier (Package-private)

// Inside package "mypackage"
package mypackage;

class DefaultExample {
    String defaultMessage = "This is default access";

    void showMessage() {
        System.out.println(defaultMessage);
    }
}

// Inside the same package "mypackage"
package mypackage;

public class MainInSamePackage {
    public static void main(String[] args) {
        DefaultExample obj = new DefaultExample();
        obj.showMessage();  // Output: This is default access
    }
}

// Inside a different package "otherpackage"
package otherpackage;

import mypackage.DefaultExample;

public class MainInOtherPackage {
    public static void main(String[] args) {
        DefaultExample obj = new DefaultExample();
        // obj.showMessage();  // Error: showMessage() has package-private access
    }
}

Explanation:

  • The defaultMessage variable and the showMessage() method are package-private, meaning they can only be accessed within the mypackage package.
  • Trying to access them from a class in the otherpackage package will result in an error.

4. Protected Access Modifier

The protected access modifier allows access to members within the same package and to subclasses (even if the subclasses are in a different package).

Example: Protected Access Modifier

// Inside package "mypackage"
package mypackage;

public class Animal {
    protected String sound = "Generic animal sound";

    protected void makeSound() {
        System.out.println(sound);
    }
}

// Inside a subclass in the same package "mypackage"
package mypackage;

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

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // Output: Generic animal sound (inherited from Animal)
        dog.dogBark();    // Output: Dog barks
    }
}

// Inside a subclass in a different package "otherpackage"
package otherpackage;

import mypackage.Animal;

public class Cat extends Animal {
    public void catMeow() {
        System.out.println("Cat meows");
        System.out.println("Animal sound: " + sound);  // Accessing protected member
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();  // Output: Generic animal sound (inherited)
        cat.catMeow();    // Output: Cat meows. Animal sound: Generic animal sound
    }
}

Explanation:

  • The sound variable and makeSound() method are declared as protected in the Animal class.
  • They are accessible in the subclass Dog in the same package and the subclass Cat in a different package (otherpackage).

5. Public Access Modifier

The public access modifier allows a class, method, or variable to be accessible from anywhere. If a member is marked as public, there are no restrictions on its visibility.

Example: Public Access Modifier

// Inside package "mypackage"
package mypackage;

public class PublicExample {
    public String message = "This is public";

    public void showMessage() {
        System.out.println(message);
    }
}

// Inside any package (even outside "mypackage")
package otherpackage;

import mypackage.PublicExample;

public class Main {
    public static void main(String[] args) {
        PublicExample obj = new PublicExample();
        obj.showMessage();  // Output: This is public
    }
}

Explanation:

  • The message variable and showMessage() method are declared as public, making them accessible from any class in any package.
  • The class PublicExample itself is also declared as public, so it can be imported and used in the otherpackage package.

6. Access Modifiers with Classes

In Java, top-level classes can only have public or default (package-private) access. A public class can be accessed from any package, while a class with default access is only accessible within the same package.

Example: Access Modifiers with Classes

// Inside package "mypackage"
package mypackage;

// Default access class (Package-private)
class DefaultClass {
    public void display() {
        System.out.println("Default access class method.");
    }
}

// Public access class
public class PublicClass {
    public void display() {
        System.out.println("Public class method.");
    }
}

// In a different package "otherpackage"
package otherpackage;

import mypackage.PublicClass;

public class Main {
    public static void main(String[] args) {
        PublicClass publicObj = new PublicClass();
        publicObj.display();  // Output: Public class method.

        // DefaultClass defaultObj = new DefaultClass();  // Error: DefaultClass is not public
    }
}

Explanation:

  • The PublicClass is declared public, so it can be accessed from anywhere.
  • The DefaultClass is package-private, so it can only be accessed within the mypackage package, and trying to access it from otherpackage results in an error.

Summary of Java Access Modifiers

Modifier Class Within Package Subclass (Different Package) Other Packages
private Same class only Not accessible Not accessible Not accessible
default Same package only Accessible Not accessible Not accessible
protected Same package + subclasses Accessible Accessible in subclass Not accessible
public Accessible everywhere Accessible everywhere Accessible everywhere Accessible everywhere

7. Examples and Use Cases

Example 1: Using protected in Inheritance

package mypackage;

public class Vehicle {
    protected int speed = 100;

    protected void showSpeed() {
        System.out.println("Speed: " + speed);
    }
}

package otherpackage;

import mypackage.Vehicle;

public class Car extends Vehicle {
    public void displaySpeed() {
        showSpeed();  // Accessing protected method
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.displaySpeed();  // Output: Speed: 100
    }
}

Example 2: Restricting Access with private

class Account {
    private double balance = 5000;

    // Private method
    private void updateBalance(double amount) {
        balance += amount;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            updateBalance(amount);  // Private method can be accessed inside the class
            System.out.println("Deposited " + amount);
        }
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        account.deposit(500);  // Output: Deposited 500
        System.out.println("Balance: " + account.getBalance());  // Output: Balance: 5500

        // account.updateBalance(100);  // Error: updateBalance() is private
    }
}

Conclusion

In Java, access modifiers are essential for controlling the visibility and accessibility of classes, methods, and variables. They are fundamental in implementing encapsulation, one of the four principles of Object-Oriented Programming (OOP). In this tutorial, we covered:

  • Private access for ensuring that methods and variables are only accessible within the same class.
  • Default access for restricting access to members within the same package.
  • Protected access for allowing access within the same package and to subclasses.
  • Public access for allowing unrestricted access to members.
0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Instance Initializer Block Tutorial with Examples

written by 75ypsaw71

In Java, an Instance Initializer Block (IIB) is a block of code that is executed whenever an object of the class is created.

It allows us to initialize instance variables or perform actions that need to be executed each time a new object is instantiated, regardless of the constructor used.

The block runs before the constructor and after instance variables are initialized.

In this tutorial, we will cover:

  1. What is an Instance Initializer Block?
  2. Basic Syntax of Instance Initializer Block
  3. Why Use Instance Initializer Blocks?
  4. Order of Execution: IIB vs Constructor
  5. Multiple Instance Initializer Blocks
  6. Examples and Use Cases

Let’s explore each concept with examples!

1. What is an Instance Initializer Block?

An Instance Initializer Block (IIB) is a block of code enclosed in curly braces {} that is executed before the constructor and is used to initialize instance variables or perform any initialization logic. It gets executed every time an object is created.

Key Characteristics:

  • It is executed before the constructor.
  • It can be used for shared initialization among constructors.
  • It runs each time an instance is created.

2. Basic Syntax of Instance Initializer Block

The syntax for an Instance Initializer Block is straightforward. You simply define a block of code with curly braces {} outside any methods or constructors in the class.

Example 1: Basic Instance Initializer Block

class Example {
    // Instance variable
    int value;

    // Instance Initializer Block
    {
        value = 10;
        System.out.println("Instance Initializer Block executed, value set to " + value);
    }

    // Constructor
    public Example() {
        System.out.println("Constructor executed.");
    }
}

public class InstanceInitializerExample {
    public static void main(String[] args) {
        Example obj = new Example();
        // Output:
        // Instance Initializer Block executed, value set to 10
        // Constructor executed.
    }
}

Explanation:

  • The Instance Initializer Block sets the value of the value variable to 10.
  • The block is executed before the constructor, and the constructor is executed afterward.

3. Why Use Instance Initializer Blocks?

Instance Initializer Blocks are useful when:

  • Multiple constructors share common initialization code. Instead of duplicating the initialization logic in each constructor, you can put it in an IIB.
  • You need to perform complex initialization that can’t be done in field initializations or constructor parameters.
  • You want to ensure certain code is always executed, regardless of which constructor is used.

Example 2: Shared Initialization Code Across Constructors

class Initialization {
    int a;
    int b;

    // Instance Initializer Block
    {
        a = 5;
        b = 10;
        System.out.println("Instance Initializer Block executed: a = " + a + ", b = " + b);
    }

    // Constructor 1
    public Initialization() {
        System.out.println("Default constructor called.");
    }

    // Constructor 2
    public Initialization(int b) {
        this.b = b;
        System.out.println("Parameterized constructor called. b = " + b);
    }
}

public class InitializationExample {
    public static void main(String[] args) {
        Initialization obj1 = new Initialization();
        // Output:
        // Instance Initializer Block executed: a = 5, b = 10
        // Default constructor called.

        Initialization obj2 = new Initialization(20);
        // Output:
        // Instance Initializer Block executed: a = 5, b = 10
        // Parameterized constructor called. b = 20
    }
}

Explanation:

  • The IIB initializes the values of a and b. Both constructors use this shared initialization logic, ensuring that the values are properly set before the constructor logic is executed.

4. Order of Execution: IIB vs Constructor

Instance Initializer Blocks are executed before the constructor but after the instance variables are initialized. The IIB can modify instance variables before the constructor is executed.

Example 3: Execution Order of IIB and Constructor

class ExecutionOrder {
    // Instance variable
    int x = 100;

    // Instance Initializer Block
    {
        System.out.println("IIB executed. Initial value of x = " + x);
        x = 200;  // Modifying the value of x
    }

    // Constructor
    public ExecutionOrder() {
        System.out.println("Constructor executed. Final value of x = " + x);
    }
}

public class ExecutionOrderExample {
    public static void main(String[] args) {
        ExecutionOrder obj = new ExecutionOrder();
        // Output:
        // IIB executed. Initial value of x = 100
        // Constructor executed. Final value of x = 200
    }
}

Explanation:

  • First, the instance variable x is initialized to 100.
  • The IIB modifies the value of x to 200.
  • The constructor is then executed after the IIB, with the final value of x being 200.

5. Multiple Instance Initializer Blocks

You can have multiple Instance Initializer Blocks in a class. They will be executed in the order in which they appear in the class, from top to bottom.

Example 4: Multiple Instance Initializer Blocks

class MultipleIIB {
    int x;
    int y;

    // First Instance Initializer Block
    {
        x = 5;
        System.out.println("First IIB executed: x = " + x);
    }

    // Second Instance Initializer Block
    {
        y = 10;
        System.out.println("Second IIB executed: y = " + y);
    }

    // Constructor
    public MultipleIIB() {
        System.out.println("Constructor executed: x = " + x + ", y = " + y);
    }
}

public class MultipleIIBExample {
    public static void main(String[] args) {
        MultipleIIB obj = new MultipleIIB();
        // Output:
        // First IIB executed: x = 5
        // Second IIB executed: y = 10
        // Constructor executed: x = 5, y = 10
    }
}

Explanation:

  • The first IIB is executed before the second IIB, which means x is initialized before y.
  • After both IIBs have executed, the constructor is called to finalize the object creation.

6. Examples and Use Cases

Example 5: Instance Initializer Block for Resource Initialization

Sometimes, you may want to initialize resources or perform setup actions every time an object is created.

class ResourceInitialization {
    // Instance variable
    String resource;

    // Instance Initializer Block
    {
        System.out.println("Initializing resource...");
        resource = "Database Connection";
    }

    // Constructor
    public ResourceInitialization() {
        System.out.println("Constructor: Resource initialized as " + resource);
    }
}

public class ResourceInitializationExample {
    public static void main(String[] args) {
        ResourceInitialization obj = new ResourceInitialization();
        // Output:
        // Initializing resource...
        // Constructor: Resource initialized as Database Connection
    }
}

Explanation:

  • The IIB simulates resource initialization (such as opening a database connection) every time an object is created.
  • The constructor then completes the object creation process.

Example 6: Instance Initializer Blocks in Inheritance

When a class extends another class, both the parent and child class can have Instance Initializer Blocks.

class Parent {
    {
        System.out.println("Parent IIB executed.");
    }

    public Parent() {
        System.out.println("Parent constructor executed.");
    }
}

class Child extends Parent {
    {
        System.out.println("Child IIB executed.");
    }

    public Child() {
        System.out.println("Child constructor executed.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Child obj = new Child();
        // Output:
        // Parent IIB executed.
        // Parent constructor executed.
        // Child IIB executed.
        // Child constructor executed.
    }
}

Explanation:

  • The IIB in the parent class runs before the IIB in the child class.
  • The constructor in the parent class is executed before the child class constructor, demonstrating the order of execution.

Summary of Key Concepts for Instance Initializer Blocks

Concept Description
Instance Initializer Block (IIB) A block of code that runs before the constructor every time an object is created.
Use for Shared Initialization IIB can be used to avoid duplicating initialization logic across multiple constructors.
Order of Execution IIBs are executed before the constructor, but after instance variables are initialized.
Multiple IIBs If a class contains multiple IIBs, they are executed in the order in which they appear in the class.
IIBs in Inheritance Both parent and child classes can have IIBs, and the parent's IIB executes before the child's IIB.

Conclusion

In Java, Instance Initializer Blocks (IIBs) are a powerful tool for handling common initialization logic. In this tutorial, we covered:

  • The basic syntax of Instance Initializer Blocks and how they are executed.
  • Why and when to use IIBs, especially for shared initialization across constructors.
  • The order of execution between instance initializer blocks and constructors.
  • How to use multiple IIBs and their role in inheritance.
0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Method Overriding Tutorial with Examples

written by 75ypsaw71

Method Overriding is an important feature of Object-Oriented Programming (OOP) in Java that allows a subclass (child class) to provide its own implementation of a method that is already defined by its superclass (parent class).

Method overriding provides a way to achieve runtime polymorphism in Java.

In this tutorial, we will cover:

  1. What is Method Overriding?
  2. Rules for Method Overriding
  3. Using the @Override Annotation
  4. Difference Between Method Overriding and Overloading
  5. Examples of Method Overriding
  6. Best Practices for Method Overriding
  7. Examples and Use Cases

Let’s dive into each topic with code examples!

1. What is Method Overriding?

Method overriding occurs when a subclass provides its specific implementation of a method that is already defined by its parent class.

The method in the subclass must have the same signature (method name, return type, and parameters) as the method in the parent class.

Key Features:

  • Runtime Polymorphism: Method overriding enables runtime polymorphism, allowing Java to determine the method to call at runtime.
  • Same Method Signature: The overridden method in the child class must have the same name, return type, and parameters as the method in the parent class.
  • Subclass-Specific Implementation: The child class can customize the behavior of the method.

2. Rules for Method Overriding

  • The method in the child class must have the same name, return type, and parameter list as the method in the parent class.
  • The access modifier of the overriding method in the child class cannot be more restrictive than the method in the parent class. For example, if the parent method is public, the child method must also be public or more accessible.
  • The overriding method can throw fewer or no exceptions but not more exceptions than the overridden method in the parent class.
  • Static methods and constructors cannot be overridden.

3. Using the @Override Annotation

The @Override annotation is used to indicate that a method is intended to override a method in a parent class.

While it is not mandatory, it helps prevent errors by alerting the developer if the method does not correctly override the parent method.

Example: Basic Method Overriding

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

class Dog extends Animal {
    // Overriding the sound() method in the subclass
    @Override
    public void sound() {
        System.out.println("Dog barks.");
    }
}

public class MethodOverridingExample {
    public static void main(String[] args) {
        Animal animal = new Animal();  // Animal reference, Animal object
        animal.sound();  // Output: Animal makes a sound.

        Animal dog = new Dog();  // Animal reference, Dog object (polymorphism)
        dog.sound();  // Output: Dog barks. (method overridden)
    }
}

Explanation:

  • The method sound() in the Dog class overrides the sound() method in the Animal class.
  • The @Override annotation ensures that this method is overriding the method in the parent class.
  • Polymorphism: The method sound() is called on an Animal reference that holds a Dog object, and the Dog's version of the method is invoked at runtime.

4. Difference Between Method Overriding and Overloading

  • Method Overriding occurs when a subclass provides a specific implementation of a method that already exists in its superclass.
  • Method Overloading occurs when two or more methods in the same class share the same name but have different parameter lists.

Example: Overriding vs. Overloading

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound.");
    }
    
    // Overloading: Two methods with the same name but different parameters
    public void sound(String type) {
        System.out.println("Animal makes a sound: " + type);
    }
}

class Dog extends Animal {
    // Overriding: Same method signature as in Animal class
    @Override
    public void sound() {
        System.out.println("Dog barks.");
    }
}

public class OverloadingVsOverriding {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();  // Output: Dog barks.
        dog.sound("loud bark");  // Output: Animal makes a sound: loud bark (overloaded method)
    }
}

Explanation:

  • Overloading: The sound() method is overloaded with a different parameter list (sound(String)), which allows different method implementations depending on the arguments passed.
  • Overriding: The Dog class overrides the sound() method from the Animal class, replacing its behavior.

5. Examples of Method Overriding

Example 1: Overriding a Parent Class Method

class Vehicle {
    public void startEngine() {
        System.out.println("Vehicle engine started.");
    }
}

class Car extends Vehicle {
    @Override
    public void startEngine() {
        System.out.println("Car engine started with ignition key.");
    }
}

public class VehicleExample {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.startEngine();  // Output: Vehicle engine started.

        Vehicle car = new Car();
        car.startEngine();  // Output: Car engine started with ignition key. (overridden method)
    }
}

Example 2: Calling the Parent Class Method from the Overriding Method

You can use the super keyword to call the method from the parent class within the overriding method.

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

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

public class CallParentMethodExample {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        // Output:
        // Animal is eating.
        // Cat is eating fish.
    }
}

Explanation:

  • The super.eat() method calls the eat() method from the Animal class, and the Cat class adds its custom behavior by overriding the eat() method.

6. Best Practices for Method Overriding

1. Always Use the @Override Annotation

Using the @Override annotation helps ensure that you are overriding the method from the parent class correctly. It helps avoid subtle bugs caused by method signature mismatches.

2. Follow the Access Modifier Rule

When overriding a method, the access modifier of the overridden method cannot be more restrictive than that of the parent class method. For example, if the parent method is protected, the child class method can be protected or public, but not private.

3. Preserve Method Signatures

Make sure the overriding method has the exact same signature (name, parameters, and return type) as the parent class method. Java will throw a compile-time error if the signatures do not match.

7. Examples and Use Cases

Example 1: Overriding toString() Method

The toString() method is defined in the Object class, and it is common to override it to provide a meaningful string representation of an object.

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Overriding the toString() method
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class ToStringOverrideExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        System.out.println(person.toString());  // Output: Person{name='Alice', age=30}
    }
}

Example 2: Overriding equals() and hashCode() Methods

To correctly compare objects for equality, you need to override both the equals() and hashCode() methods. These methods are defined in the Object class.

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Overriding equals() method
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    // Overriding hashCode() method
    @Override
    public int hashCode() {
        return name.hashCode() + age;
    }
}

public class EqualsAndHashCodeExample {
    public static void main(String[] args) {
        Person person1 = new Person("Bob", 25);
        Person person2 = new Person("Bob", 25);


        
        System.out.println(person1.equals(person2));  // Output: true
    }
}

Explanation:

  • equals() is overridden to check if two Person objects are equal based on their name and age values.
  • hashCode() is overridden to maintain the contract between equals() and hashCode(), which ensures that equal objects have the same hash code.

Summary of Key Concepts for Method Overriding

Concept Description
Method Overriding Allows a subclass to provide its own implementation of a method that is already defined in its superclass.
Runtime Polymorphism Method overriding enables runtime polymorphism, where the method to be executed is determined at runtime.
@Override Annotation Used to indicate that a method is intended to override a method in a superclass.
super Keyword Used to call the parent class's method from within the overriding method.
Access Modifier Rule The overriding method cannot have a more restrictive access modifier than the method in the parent class.
Overriding vs Overloading Overriding involves redefining methods with the same signature, while overloading involves different signatures.

Conclusion

In Java, method overriding allows subclasses to customize or replace the behavior of methods defined in their parent classes, enabling runtime polymorphism. In this tutorial, we covered:

  • The rules for method overriding, including the same method signature and access modifier constraints.
  • Using the @Override annotation to prevent mistakes in overriding.
  • Differences between method overriding and method overloading.
  • Real-world examples, including overriding toString(), equals(), and hashCode().
0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Anonymous Classes Tutorial

written by 75ypsaw71

An anonymous class in Java is a type of inner class that is defined without a class name and is declared and instantiated all in a single expression.

Anonymous classes are useful when you need a one-time use implementation of an interface or subclass and don't want to write a full class definition.

They allow for concise code by providing a way to create a new class on the fly and override methods immediately.

In this tutorial, we’ll cover the basics of anonymous classes, their use cases, and multiple examples to demonstrate how they work in Java.

1. What is an Anonymous Class?

An anonymous class is an inner class that:

Has no name: It's declared and instantiated in one expression.
Implements an interface or extends a class.
Overrides methods immediately after creation.
Typically used to provide a short implementation when the class is only needed once.

2. Syntax of Anonymous Classes

The syntax for an anonymous class in Java is:

new () {
    // Method implementations or overrides
};

3. Anonymous Class with an Interface

You can use an anonymous class to implement an interface directly. For example, consider an interface with a single method display():

Example: Anonymous Class Implementing an Interface

interface Message {
    void display();
}

public class AnonymousClassExample {
    public static void main(String[] args) {
        // Anonymous class implementing the Message interface
        Message message = new Message() {
            @Override
            public void display() {
                System.out.println("Hello from the anonymous class!");
            }
        };

        // Call the display method
        message.display();
    }
}

Explanation:

We create an anonymous class that implements the Message interface and provides an implementation for the display() method.
The class has no name and is defined inline at the point of instantiation.

Output:

Hello from the anonymous class!

4. Anonymous Class with a Class (Extending a Class)

Anonymous classes can also extend a class. Let's say you have a class Person with a method sayHello():

Example: Anonymous Class Extending a Class

class Person {
    public void sayHello() {
        System.out.println("Hello from Person");
    }
}

public class AnonymousClassWithClassExample {
    public static void main(String[] args) {
        // Anonymous class extending the Person class
        Person person = new Person() {
            @Override
            public void sayHello() {
                System.out.println("Hello from the anonymous subclass of Person");
            }
        };

        // Call the overridden method
        person.sayHello();
    }
}

Explanation:

We extend the Person class and override the sayHello() method using an anonymous class.
The anonymous class is instantiated and used immediately.

Output:

Hello from the anonymous subclass of Person

5. Anonymous Class with Event Listeners (Real-World Use Case)

Anonymous classes are commonly used in event handling scenarios, such as with GUI components or user interaction. For example, in Java’s Swing library, you can use an anonymous class to handle a button click event.

Example: Anonymous Class in Event Handling (Java Swing)

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class AnonymousClassEventExample {
    public static void main(String[] args) {
        // Create a JFrame window
        JFrame frame = new JFrame("Anonymous Class Event Example");
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Create a JButton
        JButton button = new JButton("Click Me");

        // Add an ActionListener using an anonymous class
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(frame, "Button Clicked!");
            }
        });

        // Add the button to the frame and make it visible
        frame.add(button);
        frame.setVisible(true);
    }
}

Explanation:

We create a button and use an anonymous class to handle its ActionListener.
The anonymous class is instantiated and passed to the addActionListener() method to handle the button click event.
Output: When the user clicks the button, a pop-up message “Button Clicked!” will appear.

6. Anonymous Class with Constructor Parameters

Anonymous classes can also capture and use variables from the surrounding scope, including constructor parameters. However, these variables must be final or effectively final (meaning they are not modified after being initialized).

Example: Anonymous Class with Constructor Parameter

class Animal {
    private String name;

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

    public void sound() {
        System.out.println(name + " makes a sound.");
    }
}

public class AnonymousClassConstructorExample {
    public static void main(String[] args) {
        String animalName = "Dog";

        // Anonymous class using the constructor of Animal class
        Animal dog = new Animal(animalName) {
            @Override
            public void sound() {
                System.out.println(animalName + " barks!");
            }
        };

        // Call the overridden method
        dog.sound();
    }
}

Explanation:

We pass a constructor argument (animalName) to the Animal class, and the anonymous class overrides the sound() method.
The animalName variable is captured inside the anonymous class and used in the overridden method.

Output:

Dog barks!

7. Anonymous Classes and Variable Scope

Anonymous classes can access variables from the enclosing scope, but only if they are final or effectively final. This ensures that the value remains consistent throughout the lifetime of the anonymous class.

Example: Anonymous Class and Final Variables

public class AnonymousClassScopeExample {
    public static void main(String[] args) {
        // Effectively final variable
        String greeting = "Hello";

        // Anonymous class using the greeting variable
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(greeting + " from the anonymous class!");
            }
        };

        // Call the run method
        runnable.run();
    }
}

Explanation:

The variable greeting is effectively final (its value is not modified after initialization).
The anonymous class can use greeting within the run() method because it is effectively final.

Output:

Hello from the anonymous class!

8. Anonymous Classes vs Lambda Expressions

In Java 8 and later, lambda expressions can be used as a more concise alternative to anonymous classes when implementing functional interfaces (interfaces with a single abstract method). Lambdas offer simpler syntax for this purpose.

Example: Anonymous Class vs Lambda Expression

Anonymous Class:

Runnable anonymousClassRunnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running from anonymous class");
    }
};
anonymousClassRunnable.run();

Lambda Expression (Java 8+):

Runnable lambdaRunnable = () -> System.out.println("Running from lambda expression");
lambdaRunnable.run();

Explanation:

Both the anonymous class and lambda expression implement the Runnable interface, but the lambda expression provides a shorter, more readable syntax.
Lambda expressions are generally preferred when using functional interfaces in Java 8+.

Output for Both:

Running from anonymous class
Running from lambda expression

9. Anonymous Class with Multiple Methods (More Complex Example)

In an anonymous class, you can override multiple methods when extending an abstract class or implementing an interface with more than one method.

Example: Anonymous Class with Multiple Methods

interface Vehicle {
    void start();
    void stop();
}

public class AnonymousClassMultipleMethodsExample {
    public static void main(String[] args) {
        // Anonymous class implementing two methods
        Vehicle car = new Vehicle() {
            @Override
            public void start() {
                System.out.println("Car is starting");
            }

            @Override
            public void stop() {
                System.out.println("Car is stopping");
            }
        };

        // Call both methods
        car.start();
        car.stop();
    }
}

Explanation:

The Vehicle interface has two methods (start() and stop()), and we provide an anonymous class that implements both.
We can call both methods on the car object.

Output:

Car is starting
Car is stopping

10. Limitations of Anonymous Classes

While anonymous classes are useful, they come with certain limitations:

Cannot have a constructor: You can pass arguments to the superclass or interface constructor, but you cannot define a constructor in the anonymous class itself.
Cannot be reused: Since anonymous classes are unnamed and instantiated only once, they cannot be reused in different parts of the code.
Cannot define static members: Anonymous classes cannot contain static fields or methods.

Conclusion

Anonymous classes in Java provide a powerful, concise way to create one-time-use classes that implement interfaces or extend existing classes. They are particularly useful in event handling, callbacks, and scenarios where you need a quick implementation without the need for a full class definition.

Key Points:

Anonymous classes are used to implement interfaces or extend classes inline.
They are commonly used for event listeners, callbacks, and functional programming.
Autoboxing and lambda expressions (in Java 8+) provide a more concise syntax for certain use cases of anonymous classes.

By understanding and using anonymous classes effectively, you can write more concise and flexible Java code in situations where creating a full class is unnecessary.

0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Wrapper Classes Tutorial

written by 75ypsaw71

In Java, wrapper classes are used to represent primitive data types as objects. Every primitive data type in Java has a corresponding wrapper class in the java.lang package.

Wrapper classes allow primitives to be used as objects when necessary, such as when working with collections (like ArrayList) or generics.

Wrapper classes provide methods to perform operations on primitive types, such as parsing, conversion, and null handling, which cannot be done with the primitives directly.

In this tutorial, we'll explore Java's wrapper classes with several code examples to demonstrate how they are used and how they convert between primitive types and objects.

1. List of Java Wrapper Classes

Java provides the following wrapper classes for each primitive data type:

Primitive Type Wrapper Class
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

2. Why Use Wrapper Classes?

Wrapper classes are useful in many scenarios:

Collections: Java collections (like ArrayList) only work with objects, so primitive types need to be wrapped in their corresponding wrapper classes.
Type conversion: Wrapper classes provide utility methods for converting between different data types (e.g., parsing strings into numbers).
Null handling: Unlike primitive types, wrapper classes can store null values, which are useful in certain contexts.
Autoboxing and Unboxing: Java automatically converts between primitives and wrapper objects (autoboxing/unboxing), making the code easier to read and write.

3. Creating Wrapper Objects (Boxing)

Wrapper objects can be created in two ways:

Using the constructor of the wrapper class.
Using static factory methods (e.g., valueOf()).

Example: Creating Wrapper Objects

public class WrapperExample {
    public static void main(String[] args) {
        // Creating wrapper objects using constructor (Deprecated in newer versions)
        Integer intObj1 = new Integer(100);  // Deprecated in Java 9
        Double doubleObj1 = new Double(5.5); // Deprecated in Java 9

        // Creating wrapper objects using valueOf() (Preferred method)
        Integer intObj2 = Integer.valueOf(200);
        Double doubleObj2 = Double.valueOf(10.5);

        // Displaying the values
        System.out.println("intObj1: " + intObj1);
        System.out.println("doubleObj1: " + doubleObj1);
        System.out.println("intObj2: " + intObj2);
        System.out.println("doubleObj2: " + doubleObj2);
    }
}

Explanation:

You can create wrapper objects using the constructor (deprecated in newer versions) or the preferred valueOf() method.
Wrapper objects represent the corresponding primitive values.

Output:

intObj1: 100
doubleObj1: 5.5
intObj2: 200
doubleObj2: 10.5

4. Autoboxing and Unboxing

Autoboxing is the automatic conversion of a primitive type into its corresponding wrapper class object. Unboxing is the reverse process: converting a wrapper object back into a primitive type. Java automatically performs these conversions when needed, making the code more concise.

Example: Autoboxing and Unboxing

public class AutoboxingUnboxingExample {
    public static void main(String[] args) {
        // Autoboxing: converting a primitive to a wrapper object
        Integer intObj = 10;  // Equivalent to Integer.valueOf(10)

        // Unboxing: converting a wrapper object to a primitive
        int intValue = intObj;  // Equivalent to intObj.intValue()

        // Displaying the values
        System.out.println("Wrapper object (Integer): " + intObj);
        System.out.println("Primitive value (int): " + intValue);
    }
}

Explanation:

Java automatically converts int to Integer (autoboxing) and Integer to int (unboxing).
This feature makes code easier to read by reducing explicit conversions.

Output:

Wrapper object (Integer): 10
Primitive value (int): 10

5. Wrapper Class Methods

Each wrapper class provides several utility methods for manipulating and converting primitive values. Some common methods include:

parse(): Converts a String into a primitive type.
valueOf(): Converts a String or primitive into a wrapper object.
Value(): Converts the wrapper object to a primitive.

Example: Common Wrapper Class Methods

public class WrapperMethodsExample {
    public static void main(String[] args) {
        // Using parse methods to convert String to primitive types
        int intValue = Integer.parseInt("123");
        double doubleValue = Double.parseDouble("45.67");

        // Using valueOf() to create wrapper objects from strings
        Integer intObj = Integer.valueOf("100");
        Double doubleObj = Double.valueOf("99.99");

        // Converting wrapper objects to primitive types
        int primitiveInt = intObj.intValue();
        double primitiveDouble = doubleObj.doubleValue();

        // Displaying results
        System.out.println("Parsed int: " + intValue);
        System.out.println("Parsed double: " + doubleValue);
        System.out.println("Wrapper Integer object: " + intObj);
        System.out.println("Wrapper Double object: " + doubleObj);
        System.out.println("Primitive int from Integer object: " + primitiveInt);
        System.out.println("Primitive double from Double object: " + primitiveDouble);
    }
}

Explanation:

parseInt() and parseDouble() are used to convert String values to int and double primitives, respectively.
valueOf() is used to create wrapper objects from String values.
Value() methods are used to retrieve the primitive value from wrapper objects.

Output:

Parsed int: 123
Parsed double: 45.67
Wrapper Integer object: 100
Wrapper Double object: 99.99
Primitive int from Integer object: 100
Primitive double from Double object: 99.99

6. Wrapper Classes in Collections

Java collections (such as ArrayList, HashMap, etc.) cannot store primitive types directly. Instead, wrapper classes are used to store primitive values as objects in collections.

Example: Using Wrapper Classes in Collections

import java.util.ArrayList;

public class WrapperInCollectionsExample {
    public static void main(String[] args) {
        // Creating an ArrayList to store Integer objects (autoboxing will occur)
        ArrayList intList = new ArrayList<>();

        // Adding primitive int values (autoboxing to Integer objects)
        intList.add(10);  // Autoboxing converts int to Integer
        intList.add(20);
        intList.add(30);

        // Retrieving and using the values (unboxing to int)
        int sum = 0;
        for (Integer num : intList) {
            sum += num;  // Unboxing converts Integer to int
        }

        // Displaying the sum
        System.out.println("Sum: " + sum);
    }
}

Explanation:

The ArrayList stores Integer objects (not primitive int).
Autoboxing automatically converts the primitive int values into Integer objects when added to the list, and unboxing occurs when they are retrieved.

Output:

Sum: 60

7. Null Handling with Wrapper Classes

One key advantage of wrapper classes is their ability to store null values, unlike primitive types which cannot hold null. This is useful in scenarios where a value may not be present.

Example: Null Handling with Wrapper Classes

public class NullHandlingExample {
    public static void main(String[] args) {
        // Integer can hold null, but int cannot
        Integer nullableInt = null;

        // Trying to use int with null will cause NullPointerException
        try {
            int primitiveInt = nullableInt;  // Unboxing a null value will throw an exception
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException when unboxing null Integer");
        }

        // Safe check for null before unboxing
        if (nullableInt != null) {
            int safeInt = nullableInt;  // Only unbox if not null
            System.out.println("Safe int value: " + safeInt);
        } else {
            System.out.println("No value present");
        }
    }
}

Explanation:

Wrapper classes can hold null values, unlike primitive types.
Unboxing a null value will cause a NullPointerException, so it's important to check for null before unboxing.

Output:

Caught NullPointerException when unboxing null Integer
No value present

8. Performance Considerations

While wrapper classes provide additional functionality, they come with some performance overhead compared to primitive types:

Memory Usage: Wrapper objects consume more memory than primitive types.
Autoboxing/Unboxing: Implicit conversions between primitives and wrapper objects can introduce performance costs.
Null Handling: Wrapper classes are nullable, which adds flexibility but also the risk of NullPointerException.
When performance is critical (e.g., in loops), consider using primitive types to avoid the overhead of autoboxing/unboxing.

Example: Performance Impact of Autoboxing

public class AutoboxingPerformanceExample {
    public static void main(String[] args) {
        long startTime, endTime;

        // Using primitive int
        startTime = System.nanoTime();
        int sum1 = 0;
        for (int i = 0; i < 1000000; i++) {
            sum1 += i;
        }
        endTime = System.nanoTime();
        System.out.println("Time with int: " + (endTime - startTime) + " ns");

        // Using wrapper Integer (autoboxing/unboxing)
        startTime = System.nanoTime();
        Integer sum2 = 0;
        for (int i = 0; i < 1000000; i++) {
            sum2 += i;  // Autoboxing/unboxing occurs
        }
        endTime = System.nanoTime();
        System.out.println("Time with Integer: " + (endTime - startTime) + " ns");
    }
}

Explanation:

The loop that uses int performs faster than the one that uses Integer because of the overhead of autoboxing/unboxing.

Sample Output:

Time with int: 116499 ns
Time with Integer: 3538675 ns

Conclusion

Java wrapper classes are a powerful tool that allows you to treat primitive data types as objects. They provide utility methods for parsing, converting, and manipulating primitive data, and are essential for working with Java collections and generics.

Key Points:

Wrapper Classes: Each primitive type has a corresponding wrapper class (int → Integer, char → Character, etc.).
Autoboxing and Unboxing: Java automatically converts between primitives and wrapper objects.
Utility Methods: Wrapper classes provide methods like valueOf(), parse(), and Value() for conversion and manipulation.
Null Handling: Unlike primitive types, wrapper classes can store null values.
Collections: Java collections can only hold objects, so wrapper classes are used to store primitive values.
Performance Considerations: While convenient, wrapper classes can introduce performance overhead due to memory usage and autoboxing/unboxing.

By understanding and using wrapper classes effectively, you can write more flexible and object-oriented code in Java.

0 comment
0 FacebookTwitterPinterestEmail
OOP

Java Static Binding Tutorial

written by 75ypsaw71

Static Binding (also known as early binding) refers to the process in which the method or variable to be executed is determined at compile time. In Java, static binding occurs for methods and variables that are resolved at compile time, such as static methods, private methods, and final methods. Static binding is the opposite of dynamic binding (late binding), which occurs at runtime.

In this tutorial, we will explore static binding with code examples and cover how it works in Java.

1. What is Static Binding?

In static binding, the compiler determines which method or variable to call at compile time, based on the type of reference rather than the actual object. This is typically applied to:

Static methods: Because they are associated with the class, not instances.
Private methods: Because they cannot be overridden.
Final methods: Since they cannot be overridden.
Member variables: Which are resolved based on the reference type, not the object type.

2. Static vs Dynamic Binding

Static Binding: Method or variable is determined at compile time based on the reference type.
Dynamic Binding: Method is determined at runtime based on the actual object.

3. Static Binding with Static Methods

Static methods are resolved at compile time because they belong to the class, not to a specific instance of the class. Therefore, method calls involving static methods use static binding.

Example of Static Binding with Static Methods:

class Parent {
    // Static method in the parent class
    public static void display() {
        System.out.println("Static method in Parent class");
    }
}

class Child extends Parent {
    // Static method in the child class
    public static void display() {
        System.out.println("Static method in Child class");
    }
}

public class StaticBindingExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();

        // Static methods are bound at compile time, based on reference type
        parent.display();  // 
        Static method in Parent class
        child.display();   // 
        Static method in Parent class (not Child class)
    }
}

Explanation:

Static methods are bound based on the reference type (Parent), so both calls invoke the Parent class's display() method, even though the child reference points to a Child object.

Output:

Static method in Parent class
Static method in Parent class

4. Static Binding with Private Methods

Private methods are not inherited and cannot be overridden, so they are also resolved at compile time using static binding.

Example of Static Binding with Private Methods:

class Parent {
    // Private method in Parent class
    private void display() {
        System.out.println("Private method in Parent class");
    }

    public void callDisplay() {
        display();  // Calls Parent's private method
    }
}

class Child extends Parent {
    // This method is not overriding the Parent's method, it's a separate method
    private void display() {
        System.out.println("Private method in Child class");
    }
}

public class StaticBindingPrivateMethodExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();

        // Private methods are resolved at compile time, based on reference type
        parent.callDisplay();  // 
        Private method in Parent class
        child.callDisplay();   // 
        Private method in Parent class
    }
}

Explanation:

The display() method is private in both Parent and Child. However, the callDisplay() method always calls the Parent class's private method because private methods are statically bound at compile time.

Output:

Private method in Parent class
Private method in Parent class

5. Static Binding with Final Methods

Final methods cannot be overridden, so method calls to final methods are resolved at compile time, using static binding.

Example of Static Binding with Final Methods:

class Parent {
    // Final method in Parent class
    public final void show() {
        System.out.println("Final method in Parent class");
    }
}

class Child extends Parent {
    // This method cannot override the Parent class's final method
    public void display() {
        System.out.println("Display method in Child class");
    }
}

public class StaticBindingFinalMethodExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();

        // Final methods are bound at compile time, based on reference type
        parent.show();  // 
        Final method in Parent class
        child.show();   // 
        Final method in Parent class
    }
}

Explanation:

The show() method in the Parent class is final, so it cannot be overridden in the Child class. The method is resolved at compile time.

Output:

Final method in Parent class
Final method in Parent class

6. Static Binding with Variables

Variables (both static and non-static) are resolved based on the reference type, not the object type. This means variable references are statically bound at compile time.

Example of Static Binding with Variables:

class Parent {
    // Static variable
    public static String staticVar = "Static variable in Parent";
    
    // Instance variable
    public String instanceVar = "Instance variable in Parent";
}

class Child extends Parent {
    // Static variable
    public static String staticVar = "Static variable in Child";
    
    // Instance variable
    public String instanceVar = "Instance variable in Child";
}

public class StaticBindingVariablesExample {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();

        // Static and instance variables are bound at compile time based on reference type
        System.out.println(parent.staticVar);  // 
        Static variable in Parent
        System.out.println(child.staticVar);   // 
        Static variable in Parent

        System.out.println(parent.instanceVar);  // 
        Instance variable in Parent
        System.out.println(child.instanceVar);   // 
        Instance variable in Parent
    }
}

Explanation:

Both staticVar and instanceVar are resolved based on the reference type (Parent), so even though child is pointing to a Child object, it still resolves to the variables in Parent.

Output:

Static variable in Parent
Static variable in Parent
Instance variable in Parent
Instance variable in Parent

7. Static Binding with Method Overloading

Method overloading in Java is resolved at compile time, meaning overloaded methods are statically bound.

Example of Static Binding with Method Overloading:

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

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

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

        // Method overloading is resolved at compile time (static binding)
        int result1 = calculator.add(10, 20);            // Calls method with 2 parameters
        int result2 = calculator.add(10, 20, 30);        // Calls method with 3 parameters

        System.out.println("Result1: " + result1);  // 
        30
        System.out.println("Result2: " + result2);  // 
        60
    }
}

Explanation:

Method overloading is an example of static binding where the method to be executed is determined at compile time based on the method signature (parameter types and count).

Output:

Result1: 30
Result2: 60

8. Static Binding with Static Blocks

Static blocks in Java are also resolved using static binding since they are executed at class loading time.

Example of Static Binding with Static Blocks:

class StaticBlockExample {
    // Static block
    static {
        System.out.println("Static block is executed");
    }

    public static void display() {
        System.out.println("Static method is executed");
    }
}

public class StaticBindingBlockExample {
    public static void main(String[] args) {
        // Static block and method are bound at compile time
        StaticBlockExample.display();  // 
        Static block is executed (executed first), then Static method is executed
    }
}

Explanation:

Static blocks and static methods are both bound at compile time and executed when the class is loaded or when the method is invoked.

Output:

Static block is executed
Static method is executed

Conclusion

Static Binding in Java refers to the compile-time resolution of methods, variables, and static blocks. Static binding is applied to:

Static methods: Since they belong to the class rather than an object, they are resolved at compile time.
Private methods: As they cannot be overridden, they are bound to the class at compile time.
Final methods: These methods cannot be overridden, so they are resolved at compile time.
Variables: Both static and instance variables are resolved based on the reference type rather than the object type.

In contrast to dynamic binding, static binding ensures that method or variable calls are determined at compile time, providing predictability in how methods and variables are resolved. Understanding static binding helps in writing more predictable and efficient code, particularly when working with inheritance, method overriding, and polymorphism.

0 comment
0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts