Keyword

Characteristics of the super Keyword in Java

In Java, the super keyword is utilized to refer to the parent class of a subclass. Here are some key characteristics:

• Calling Superclass Constructors: When a subclass is instantiated, its constructor must invoke the constructor of its parent class using super().
• Calling Superclass Methods: A subclass can invoke a method defined in its parent class using the super keyword, which is helpful when the subclass wants to execute the parent class’s implementation of that method as well.
• Accessing Superclass Fields: A subclass can reference a field from its parent class using the super keyword. This is useful in cases where both the subclass and parent class have a field with the same name.
• Placement in Constructor: The super() statement must be the first line in the constructor of the subclass when invoking a superclass constructor.
• Static Context Restriction: The super keyword cannot be used in a static context, such as within static methods or static variable initializers.
• Optional Use for Method Calls: While the super keyword can be used to call a parent class method, it is not necessary if the method is not overridden in the subclass. In such cases, calling the method directly will invoke the parent class’s version.

Overall, the super keyword is a powerful tool for subclassing in Java, allowing subclasses to inherit and extend the functionality of their parent classes.

Uses of the super Keyword in Java

The super keyword is primarily used in the following contexts:

1. Using super with Variables
2. Using super with Methods
3.Using super with Constructors

1. Using super with Variables : This situation arises when both a derived class and its base class have identical data members, leading to potential ambiguity.

Example:

// Example of super keyword with variables

// Base class Animal
class Animal {
    String type = "Mammal";
}

// Subclass Dog extending Animal
class Dog extends Animal {
    String type = "Canine";

    void display() {
        // Print type from base class (Animal)
        System.out.println("Animal Type: " + super.type);
    }
}

// Driver Program
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.display();
    }
}

Output:

Drawing a circle.
Drawing a shape.

In this example, both the base class and subclass have a member type. The super keyword allows us to access the type variable of the base class.

2. Using super with Methods : This usage occurs when we need to call a method from the parent class. If both the parent and child classes have methods with the same name, the super keyword resolves ambiguity.

Example:

// Example of super keyword with methods

// Superclass Shape
class Shape {
    void draw() {
        System.out.println("Drawing a shape.");
    }
}

// Subclass Circle extending Shape
class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle.");
    }

    void display() {
        // Calls the current class draw() method
        draw();
        // Calls the parent class draw() method
        super.draw();
    }
}

// Driver Program
public class Test {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.display();
    }
}

In this example, when calling the draw() method, the current class’s implementation is executed, but the super keyword allows us to invoke the superclass’s method as well.

3. Using super with Constructors : The super keyword can also be employed to access the constructor of the parent class. It can call both parameterized and non-parameterized constructors, depending on the situation.

Example 1:

// Example of super keyword with constructors

// Superclass Animal
class Animal {
    Animal() {
        System.out.println("Animal class Constructor");
    }
}

// Subclass Dog extending Animal
class Dog extends Animal {
    Dog() {
        // Invoke the parent class constructor
        super();
        System.out.println("Dog class Constructor");
    }
}

// Driver Program
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

Output:

Animal class Constructor
Dog class Constructor

Advantages of Using the super Keyword in Java

The super keyword in Java offers several advantages in object-oriented programming:

• Code Reusability: Using super allows subclasses to inherit functionality from their parent classes, promoting code reuse and reducing redundancy.
• Supports Polymorphism: Subclasses can override methods and access fields from their parent classes using super, enabling polymorphism and allowing for more flexible and extensible code.
• Access to Parent Class Behavior: Subclasses can utilize methods and fields defined in their parent classes through super, allowing them to leverage existing behavior without needing to reimplement it.
• Customization of Behavior: By overriding methods and using super to invoke the parent implementation, subclasses can customize and extend the behavior of their parent classes.
• Facilitates Abstraction and Encapsulation: The use of super promotes encapsulation and abstraction by allowing subclasses to focus on their own behavior while relying on the parent class to manage lower-level details.

The final keyword in Java is a non-access modifier that can be applied to variables, methods, or classes. It is used to impose restrictions on the element to which it is applied.

Key Uses of final in Java:

1. Using super with Variables
2. Using super with Methods
3. Using super with Constructors

By exploring these uses in detail, the Java programming course allows developers to understand how and when to apply the final keyword effectively.

Characteristics of final in Java:

1. Final Variables: When a variable is declared as final, its value cannot be changed once it is initialized. This makes it ideal for defining constants.
2. Final Methods: Declaring a method as final prevents subclasses from modifying or overriding that method, ensuring its behavior is consistent.
3. Final Classes: A final class cannot be extended, meaning no other class can inherit from it. This is useful for creating classes that are intended to be used as-is.
4. Initialization of Final Variables: Final variables must be initialized when they are declared or in a constructor. If not, the program will not compile.
5. Performance: The use of final can sometimes improve performance, as the compiler optimizes final variables or methods better since their behavior is predictable.
6. Security: By making certain variables or methods final, you can prevent malicious code from altering critical parts of your program.

Example of final Variable:

The final keyword in Java is a non-access modifier that can be applied to variables, methods, or classes. It is used to impose restrictions on the element to which it is applied.

Key Uses of final in Java:

1. Variables : A variable declared with final cannot have its value changed after initialization.
2. Methods : A method declared with final cannot be overridden by subclasses.
3. Classes:  A class declared with final cannot be subclassed or extended.

By exploring these uses in detail, the Java programming course allows developers to understand how and when to apply the final keyword effectively.

Characteristics of final in Java:

1. Final Variables: When a variable is declared as final, its value cannot be changed once it is initialized. This makes it ideal for defining constants.
2. Final Methods: Declaring a method as final prevents subclasses from modifying or overriding that method, ensuring its behavior is consistent.
3. Final Classes: A final class cannot be extended, meaning no other class can inherit from it. This is useful for creating classes that are intended to be used as-is.
4. Initialization of Final Variables: Final variables must be initialized when they are declared or in a constructor. If not, the program will not compile.
5. Performance: The use of final can sometimes improve performance, as the compiler optimizes final variables or methods better since their behavior is predictable.
6. Security: By making certain variables or methods final, you can prevent malicious code from altering critical parts of your program.

Example of final Variable:

public class Example {
    public static void main(String[] args) {
        // Declaring a final variable
        final double CONSTANT = 3.14;

        // Printing the value
        System.out.println("Constant value: " + CONSTANT);

        // Attempting to change the value would cause a compile-time error
        // CONSTANT = 3.15;
    }
}

Output:

Constant value: 3.14

Different Ways to Use final Variable:

1. Final Variable Initialization at Declaration:

final int MAX_LIMIT = 100;

2. Blank Final Variable:

final int MAX_LIMIT; // Must be initialized later in the constructor

3. Static Final Variable:

static final double E = 2.718;

4. Static Blank Final Variable Initialized in Static Block:

static final int MAX_VALUE;
static {
    MAX_VALUE = 999;
}

Initialization of Final Variables:

Final variables must be initialized either at declaration or inside constructors. The Java compiler ensures that once a final variable is initialized, it cannot be reassigned.

Example of Blank Final Variable:

class Demo {
    final int THRESHOLD;

    // Constructor to initialize blank final variable
    public Demo(int value) {
        this.THRESHOLD = value;
    }

    public static void main(String[] args) {
        Demo demo = new Demo(10);
        System.out.println("Threshold: " + demo.THRESHOLD);
    }
}

Output:

Threshold: 10

Final Reference Variable (Non-Transitivity):

In the case of reference variables declared as final, you can modify the internal state of the object, but the reference cannot be reassigned.

Example of Final Reference Variable:

class Example {
    public static void main(String[] args) {
        final StringBuilder message = new StringBuilder("Hello");
        System.out.println(message);

        // Modifying the internal state of the final object
        message.append(", World!");
        System.out.println(message);

        // Reassigning the reference would cause a compile-time error
        // message = new StringBuilder("Hi");
    }
}

Output:

Hello
Hello, World!

Final Local Variable:

A final variable inside a method is called a local final variable. It can be initialized once, and any attempt to reassign it will result in an error.

class Example {
    public static void main(String[] args) {
        final int LIMIT;
        LIMIT = 100;  // Variable initialized
        System.out.println("Limit: " + LIMIT);

        // LIMIT = 200; // This line would cause a compile-time error
    }
}

Output:

Limit: 100

Final Classes:

A class declared as final cannot be extended by any subclass. This is useful when you want to ensure the class’s functionality remains intact and is not modified by other developers.

Example of Final Class:

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

// The following class would cause a compile-time error
// class SportsCar extends Car { }

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.start();
    }
}

Output:

Car is starting

Final Methods:

When a method is declared as final, it cannot be overridden by any subclass.

class Parent {
    final void show() {
        System.out.println("This is a final method.");
    }
}

class Child extends Parent {
    // The following method would cause a compile-time error
    // void show() {
    //     System.out.println("Trying to override.");
    // }
}

The static keyword in Java is primarily utilized for memory management. It allows variables or methods to be shared across all instances of a class. Users can apply the static keyword to variables, methods, blocks, and nested classes. Unlike instance members, static members belong to the class itself rather than any particular instance, making them ideal for defining constants or methods that should remain consistent across all objects of the class.

Key Uses of static in Java:

1. Blocks
2. Variables
3. Methods
4. Classes

Characteristics of the static Keyword:

The static keyword plays a crucial role in memory management by enabling class-level variables and methods. For a comprehensive understanding of how to effectively use static, the Java Programming Course offers detailed explanations and practical examples. Here are some key characteristics of the static keyword in Java:

• Shared Memory Allocation: Static variables and methods are allocated memory space only once during the program’s execution. This shared memory space is accessible by all instances of the class, making static members ideal for maintaining global state or shared functionality.
• Accessible Without Object Instantiation: Static members can be accessed without creating an instance of the class. This makes them useful for utility functions and constants that need to be accessible throughout the program.
• Associated with the Class, Not Objects: Static members are tied to the class itself, not to individual objects. Therefore, any changes to a static member are reflected across all instances of the class. Static members can be accessed using the class name rather than an object reference.
• Cannot Access Non-Static Members: Static methods and variables cannot directly access non-static members of a class because they are not associated with any particular instance of the class.
• Can Be Overloaded, but Not Overridden: Static methods can be overloaded (multiple methods with the same name but different parameters), but they cannot be overridden since they are linked to the class rather than any instance.
• Early Access: Static members can be accessed before any objects of the class are created and without referencing any object. For example, in the Java program below, the static method displayMessage() is called without creating an object of the Utility class.

Example Program Accessing Static Method Without Object Creation

// Java program to demonstrate accessing a static method without creating an object

class Utility {
    // Static method
    static void displayMessage() {
        System.out.println("Welcome to the Utility class!");
    }

    public static void main(String[] args) {
        // Calling the static method without creating an instance of Utility
        Utility.displayMessage();
    }
}

Output:

Welcome to the Utility class!

Static Blocks

Static blocks are used for initializing static variables or executing code that needs to run once when the class is loaded. They are executed in the order they appear in the class.

Example of Static Block Usage

// Java program to demonstrate the use of static blocks

class Configuration {
    // Static variables
    static String appName;
    static int version;

    // Static block
    static {
        System.out.println("Initializing Configuration...");
        appName = "MyApp";
        version = 1;
    }

    public static void main(String[] args) {
        System.out.println("Application Name: " + appName);
        System.out.println("Version: " + version);
    }
}

Output:

Initializing Configuration...
Application Name: MyApp
Version: 1

Static Variables

Static variables, also known as class variables, are shared among all instances of a class. They are typically used to store common properties or constants.

Important Points about Static Variables:

• Class-Level Scope: Static variables are declared at the class level and are shared by all instances.
• Initialization Order: Static blocks and static variables are executed in the order they appear in the program.

Example Demonstrating Static Variable Initialization Order

// Java program to demonstrate the initialization order of static blocks and variables

class InitializationDemo {
    // Static variable initialized by a static method
    static int initialValue = initialize();

    // Static block
    static {
        System.out.println("Inside static block.");
    }

    // Static method
    static int initialize() {
        System.out.println("Initializing static variable.");
        return 50;
    }

    public static void main(String[] args) {
        System.out.println("Value of initialValue: " + initialValue);
        System.out.println("Inside main method.");
    }
}

Output:

Initializing static variable.
Inside static block.
Value of initialValue: 50
Inside main method.

Static Methods

Static methods belong to the class rather than any particular instance. The most common example of a static method is the main() method. Static methods have several restrictions:

• They can only directly call other static methods.
• They can only directly access static data.
• They cannot refer to this or super keywords.

Example Demonstrating Restrictions on Static Methods

// Java program to demonstrate restrictions on static methods

class Calculator {
    // Static variable
    static int total = 0;

    // Instance variable
    int count = 0;

    // Static method
    static void add(int value) {
        total += value;
        System.out.println("Total after addition: " + total);

        // The following lines would cause compilation errors
        // count += 1; // Error: non-static variable cannot be referenced from a static context
        // displayCount(); // Error: non-static method cannot be referenced from a static context
    }

    // Instance method
    void displayCount() {
        System.out.println("Count: " + count);
    }

    public static void main(String[] args) {
        Calculator.add(10);
        Calculator.add(20);
    }
}

Output:

Total after addition: 10
Total after addition: 30

When to Use Static Variables and Methods

• Static Variables: Use static variables for properties that are common to all instances of a class. For example, if all students share the same school name, the school name can be a static variable.
• Static Methods: Use static methods for operations that do not require data from instances of the class. Utility or helper methods that perform tasks independently of object state are ideal candidates for static methods.

Example Illustrating Static Variables and Methods

// Java program to demonstrate the use of static variables and methods

class School {
    String studentName;
    int studentId;

    // Static variable for school name
    static String schoolName;

    // Static counter to assign unique IDs
    static int idCounter = 1000;

    public School(String name) {
        this.studentName = name;
        this.studentId = generateId();
    }

    // Static method to generate unique IDs
    static int generateId() {
        return idCounter++;
    }

    // Static method to set the school name
    static void setSchoolName(String name) {
        schoolName = name;
    }

    // Instance method to display student information
    void displayInfo() {
        System.out.println("Student Name: " + studentName);
        System.out.println("Student ID: " + studentId);
        System.out.println("School Name: " + schoolName);
        System.out.println("--------------------------");
    }

    public static void main(String[] args) {
        // Setting the static school name without creating an instance
        School.setSchoolName("Greenwood High");

        // Creating student instances
        School student1 = new School("Emma");
        School student2 = new School("Liam");
        School student3 = new School("Olivia");

        // Displaying student information
        student1.displayInfo();
        student2.displayInfo();
        student3.displayInfo();
    }
}

Output:

Student Name: Emma
Student ID: 1000
School Name: Greenwood High
--------------------------
Student Name: Liam
Student ID: 1001
School Name: Greenwood High
--------------------------
Student Name: Olivia
Student ID: 1002
School Name: Greenwood High
--------------------------

Static Classes (Nested Static Classes)

A class can be declared as static only if it is a nested class. Top-level classes cannot be declared as static. Static nested classes do not require a reference to an instance of the outer class and cannot access non-static members of the outer class.

Example of a Static Nested Class

// Java program to demonstrate the use of static nested classes

class OuterClass {
    private static String outerMessage = "Hello from OuterClass!";

    // Static nested class
    static class NestedStaticClass {
        void display() {
            System.out.println(outerMessage);
        }
    }

    public static void main(String[] args) {
        // Creating an instance of the static nested class without an instance of OuterClass
        OuterClass.NestedStaticClass nestedObj = new OuterClass.NestedStaticClass();
        nestedObj.display();
    }
}

Output:

Hello from OuterClass!

What is an Enum in Java?

In Java, Enum is a special data type used to define collections of constants. It allows you to represent a fixed set of predefined constants, such as the days of the week, the four seasons, etc. An enum is more than just a list of constants—it can contain methods, constructors, and variables, just like any other Java class.

Enums are particularly useful when you know all possible values at compile time and want to prevent invalid values from being used.

Key Properties of Enums

• Enum Constants: Each enum constant is an object of the enum type.
• Implicit Modifiers: Enum constants are public, static, and final.
• Switch Compatibility: You can use enums with switch statements.
• Constructor: An enum can contain a constructor that is invoked once for each constant.
• Method Support: Enums can have methods like regular classes, including abstract methods that must be implemented by each enum constant.

Enum Declaration in Java

Enums can be declared both inside or outside a class, but not inside a method.

1. Declaration Outside the Class

// Enum declared outside the class
enum Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST
}

public class TestEnum {
    public static void main(String[] args) {
        Direction direction = Direction.NORTH;
        System.out.println("The direction is: " + direction);
    }
}

Output:

The direction is: NORTH

2. Declaration Inside the Class

// Enum declared inside a class
public class Weather {
    enum Season {
        SPRING,
        SUMMER,
        FALL,
        WINTER
    }

    public static void main(String[] args) {
        Season current = Season.WINTER;
        System.out.println("The current season is: " + current);
    }
}

Output:

The current season is: WINTER

Enum in Switch Statements

Enums can be used in switch statements to handle different cases based on enum values.

// Enum in a switch statement
public class DaysOfWeek {
    enum Day {
        MONDAY,
        TUESDAY,
        WEDNESDAY,
        THURSDAY,
        FRIDAY,
        SATURDAY,
        SUNDAY
    }

    public static void main(String[] args) {
        Day today = Day.FRIDAY;

        switch (today) {
            case MONDAY:
                System.out.println("It's the start of the work week.");
                break;
            case FRIDAY:
                System.out.println("Almost the weekend!");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("It's the weekend!");
                break;
            default:
                System.out.println("It's a regular workday.");
        }
    }
}

Output:

Almost the weekend!

Looping Through Enum Constants

You can iterate over the constants in an enum using the values() method, which returns an array of all enum constants.

// Looping through enum constants
public class ColorExample {
    enum Color {
        RED, GREEN, BLUE, YELLOW
    }

    public static void main(String[] args) {
        for (Color color : Color.values()) {
            System.out.println("Color: " + color);
        }
    }
}

Output:

Color: RED
Color: GREEN
Color: BLUE
Color: YELLOW

Enum with Constructor and Method

Enums can contain constructors and methods, making them more powerful than just simple constants.

// Enum with constructor and method
public class CarTypeExample {
    enum CarType {
        SEDAN(4), SUV(6), TRUCK(8);

        private int seats;

        // Enum constructor
        CarType(int seats) {
            this.seats = seats;
        }

        public int getSeats() {
            return seats;
        }
    }

    public static void main(String[] args) {
        CarType myCar = CarType.SUV;
        System.out.println("My car type is: " + myCar + " with " + myCar.getSeats() + " seats.");
    }
}

Output:

My car type is: SUV with 6 seats.

Enum with Abstract Methods

Enums can also contain abstract methods that each constant must implement.

// Enum with abstract method
public class PlanetExample {
    enum Planet {
        MERCURY {
            public String getOrbitalPeriod() {
                return "88 days";
            }
        },
        EARTH {
            public String getOrbitalPeriod() {
                return "365 days";
            }
        },
        MARS {
            public String getOrbitalPeriod() {
                return "687 days";
            }
        };

        public abstract String getOrbitalPeriod();
    }

    public static void main(String[] args) {
        Planet planet = Planet.EARTH;
        System.out.println("The orbital period of " + planet + " is " + planet.getOrbitalPeriod());
    }
}

Output:

// Using EnumSet to iterate over a specific range of enum values
import java.util.EnumSet;

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

    public static void main(String[] args) {
        EnumSet<Day> workdays = EnumSet.range(Day.MONDAY, Day.FRIDAY);

        for (Day day : workdays) {
            System.out.println("Workday: " + day);
        }
    }
}

Output:

The orbital period of EARTH is 365 days

Here’s the modified version of the content with different examples, and the output remains as requested:

final Keyword in Java

In Java, final is a reserved keyword, meaning we cannot use it as an identifier (variable name, method name, etc.). It serves distinct purposes depending on where it is applied — whether to variables, methods, or classes.

1. final with Variables

When a variable is declared as final, its value cannot be modified once initialized. Any attempt to change its value will result in a compile-time error.

class Example1 {
    public static void main(String[] args) {
        // Non-final variable
        int x = 10;

        // Final variable
        final int y = 20;

        // Modifying non-final variable: Allowed
        x++;

        // Modifying final variable: Gives a compile-time error
        y++;  // Error: Cannot assign a value to a final variable 'y'
    }
}

Here, attempting to modify the value of the final variable y will cause a compile-time error.

2. final with Classes

If a class is declared final, it cannot be subclassed. In other words, no class can extend a final class.

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

// The following class will cause a compile-time error as `SuperClass` is final and cannot be extended
class SubClass extends SuperClass {
    // Compile-time error: Cannot inherit from final 'SuperClass'
}

3. final with Methods

When a method is declared as final, it cannot be overridden by subclasses.

class ParentClass {
    final void show() {
        System.out.println("Final method in the parent class.");
    }
}

class ChildClass extends ParentClass {
    // The following method will cause a compile-time error
    void show() {
        // Compile-time error: Cannot override the final method from 'ParentClass'
        System.out.println("Trying to override the final method.");
    }
}

In this case, the subclass ChildClass cannot override the final method show() from ParentClass.

Note: final with Classes and Methods

If a class is declared final, all its methods are implicitly final by default. However, its variables are not.

final class FinalClass {
    // Method is final by default
    void display() {
        System.out.println("Final class method.");
    }

    // Static variables can still be modified
    static int value = 50;

    public static void main(String[] args) {
        // Modifying the static variable
        value = 60;
        System.out.println("Value: " + value);  // Output: 60
    }
}

finally Keyword

The finally keyword is associated with try and catch blocks. It ensures that a block of code will always be executed, regardless of whether an exception occurs or not. The finally block is generally used for cleanup operations like closing resources (e.g., file handles, database connections).

Example: finally with Exception Handling

class ExampleFinally {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block");
            throw new RuntimeException("Exception in try");
        } finally {
            System.out.println("Finally block always executes");
        }
    }
}

In this example, even though an exception is thrown, the finally block still executes.

Cases Involving finally Block:

Case 1: No Exception Occurs

class NoException {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block");
            int result = 10 / 2;
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

Output:

Inside try block
Finally block executed

Here, no exception occurs, but the finally block still executes.

Case 2: Exception Occurs and is Caught

class CatchException {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block");
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException");
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

Output:

Inside try block
Caught ArithmeticException
Finally block executed

Case 3: Exception Occurs but No Catch Block

class NoCatchBlock {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block");
            int result = 10 / 0;
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

Output:

Inside try block
Finally block executed
Exception in thread "main" java.lang.ArithmeticException: / by zero

Case 4: System.exit(0) in try Block

class ExitExample {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try block");
            System.exit(0);
        } finally {
            System.out.println("Finally block not executed");
        }
    }
}

Output:

Inside try block

Finalize Method

The finalize method is called by the garbage collector just before an object is destroyed. It is meant for resource cleanup before an object is deleted.

Example: Garbage Collector Calling finalize

class GarbageCollectorExample {
    public static void main(String[] args) {
        GarbageCollectorExample obj = new GarbageCollectorExample();
        obj = null;
        System.gc();
        System.out.println("Main method ends");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Finalize method called");
    }
}

Output:

Main method ends
Finalize method called