Java Programming Final Keyword And Access Modifiers Complete Guide

Top 10 Questions and Answers on Java Programming: Final Keyword and Access Modifiers

1. What is the purpose of the final keyword in Java?

Example:

final int MAX_VALUE = 100; // cannot be changed
final class MyFinalClass { } // cannot be subclassed
final void myFinalMethod() { } // cannot be overridden

2. Can you override a final method in Java?

No, you cannot override a final method in Java. The final keyword in Java prevents a method from being overridden in any subclass. This is used when there is a specific implementation in a superclass that must not be changed by subclasses.

Example:

class Parent {
     final void show() {
       System.out.println("Parent Method");
     }
}

class Child extends Parent {
     // void show() { // compile-time error
     //    System.out.println("Child Method");
     // }
}

3. What happens if you try to inherit from a final class in Java?

If you try to inherit from a final class in Java, you will get a compile-time error. The final keyword prevents other classes from extending it.

Example:

final class FinalClass {
      void show() {
         System.out.println("Final class method");
      }
}

class ChildClass extends FinalClass { // compile-time error
      void show() {
         System.out.println("Child class method");
      }
}

4. Can a blank final variable be assigned a value after its declaration?

Yes, a blank final variable (i.e., a final variable that is not initialized during declaration) can be assigned a value in the constructor of the class. This is common when you need to initialize a final variable with a value that is not known at the time of declaration.

Example:

class FinalExample {
     final int value;
     FinalExample(int value) {
         this.value = value; // initialized in constructor
     }
}

5. What are the differences between public, private, protected, and default access modifiers in Java?

• public: The access level is the most permissive and allows access from anywhere, both within and outside the package.
• private: The access level is the least permissive and allows access only within the class.
• protected: The access level allows access within the class, within the package, and from subclasses in different packages.
• default (package-private): If no access modifier is specified, it is considered default. This allows access within the class and within the same package, but not from subclasses in other packages.

Example:

public class AccessModifiers {
    public int publicVar;       // accessible from anywhere
    private int privateVar;     // accessible only within this class
    protected int protectedVar; // accessible within this class, within same package, or subclasses in other packages
    int defaultVar;             // accessible within this class and within same package
}

6. Can a class have both public and default access modifiers?

No, a class cannot have both public and default access modifiers. A class can have only one access modifier. If no access modifier is specified, the class is considered package-private (default).

Example:

public class MyClass { } // correct
class MyClass { }        // correct (default access modifier)
// public default class MyClass { }  // incorrect

7. What happens if both public and default access modifiers are used for a method or a variable?

Java does not allow using both public and default access modifiers together for a method or a variable. This will result in a compile-time error.

Example:

// public int myMethod() { } // correct
// int myMethod() { }        // correct (default access modifier)
// public default int myMethod() { } // compile-time error

8. How do the access modifiers interact with inheritance in Java?

Inheritance rules regarding access modifiers are as follows:

• private members of a superclass are not accessible in subclasses.
• default (package-private) members of a superclass are accessible in subclasses only if they are in the same package.
• protected members of a superclass are accessible in subclasses, regardless of whether they are in the same package or not.
• public members of a superclass are accessible in subclasses, regardless of whether they are in the same package or not.

Example:

class Parent {
     private int privateVar;
     int defaultVar;
     protected int protectedVar;
     public int publicVar;
}

class Child extends Parent {
     void accessVariables() {
         // System.out.println(privateVar); // not accessible
         // System.out.println(defaultVar); // accessible only if Child is in the same package as Parent
         System.out.println(protectedVar); // accessible
         System.out.println(publicVar);    // accessible
     }
}

9. How does the final keyword work with method parameters and local variables?

The final keyword can also be used with method parameters and local variables. When a method parameter or a local variable is declared as final, its value cannot be changed after it has been assigned.

Example:

public void myMethod(final int param) {
    // param = 10; // compile-time error
}

public void localVariableExample() {
    final int localVar = 10;
    // localVar = 20; // compile-time error
}

10. Can a final variable be initialized in instance initializer or constructor?

Yes, a final variable can be initialized in an instance initializer or a constructor, but it must be initialized before the object is used or returned from the constructor. For instance variables declared as final, they must be initialized either in the instance initializer, a constructor, or at the time of declaration.

Example: