Private vs Protected vs Final Access Modifier in Java - GeeksforGeeks

08 Oct, 2021
Whenever we are writing our classes, we have to provide some information about our classes to the JVM like whether this class can be accessed from anywhere or not, whether child class creation is possible or not, whether object creation is possible or not, etc. we can specify this information by using an appropriate keyword in java called access modifiers. So access modifiers are used to set accessibility of classes, methods, and other members.
Access modifiers:
PrivateProtectedFinal
Private
Protected
Final
Let us do discuss them in-depth to get a better understanding before getting to the differences between them.
Private Access Modifier: This modifier is not applicable for top-level classes or interfaces. It is only applicable to constructors, methods, and fields inside the classes. If a variable or methods or constructor is declared as private as we can access them only from within the class i.e from outside the class we can’t access them.
Java
// Java Program to illustrate Private Access Modifier // Importing required packagesimport java.io.*;import java.util.*; // Class 1// Helper classclass A {     // Method of this class    private void m1() {         // Print statement whenever this method is called        System.out.println("GFG");    }} // Class 2// Main classclass B {     // Main driver method    public static void main(String[] args) {        // Creating an object of above class        A a = new A();         // Accessing the method m1() of above class        // by creating object of above class in        // main() method of this class        a.m1();    }}
  
Protected Access Modifier: This modifier can be applied to the data member, method, and constructor, but this modifier can’t be applied to the top-level classes and interface. A member is declared as protected as we can access that member only within the current package but only in the child class of the outside package.
 
Java
// Java program to illustrate Protected Access Modifier// import required packagesimport java.io.*;import java.util.*;   // declaring a parent class Aclass A {         // declaring a protected method m1()    protected void m1() { System.out.println("GFG"); }}   // creating a child class by extending the class Aclass B extends A {         // main method    public static void main(String[] args)    {        // creating an object of parent class        // using parent reference        A a = new A();                 /// calling method m1        a.m1();                 // creating an object of child class        // using child reference        B b = new B();                 // calling method m1        b.m1();                 // creating an object of child class        // using parent reference        A a1 = new B();                 // calling m1 method        a1.m1();    }}
  
GFG
GFG
GFG
Output Explanation: In the above example, we create three objects using parent reference and child reference and call m1() method on it, and it successfully executed so from the above example we can say that we can access the protected method within the current package anywhere either by using parent reference or by child reference.
 
Final Access Modifier: It is a modifier applicable to classes, methods, and variables. If we declare a parent class method as final then we can’t override that method in the child class because its implementation is final and if a class is declared as final we can’t extend the functionality of that class i.e we can’t create a child class for that class i.e inheritance is not possible for final classes. Every method present inside the final class is always final y default, but every variable present inside the final class need not be final. The main advantage of the final keyword is we can achieve security and we can provide a unique implementation. But the main disadvantage of the final keyword is we are missing key benefits of OOPs like Inheritance(Because of the final class), Polymorphism(Because of the final method)  hence if there are no specific requirements then it is not recommended to use the final keyword. 
 
Java
// Java program to illustrate Final keyword   // import required packagesimport java.io.*;import java.util.*;// Declaring parent class Pclass P {    // Declaring a first name    // method    public void firstName()    {        // Display firstname        System.out.println("Rahul ");    }    /// Declaring a final surName    // method    public final void surName()    {        // Display surname        System.out.println("Trivedi");    }}// Creating a child class// of above parent classclass C extends P {    // overriding the surName    // method    public void surName()    {        // Display surname        System.out.println("Sharma");    }    // Main method    public static void main(String[] args)    {        // Display message        System.out.println("GFG");    }}
Output:
Now after having an understanding of all of them let us do land on differences between them to conclude out. 
gabaa406
prachisoda1234
Java-Modifier
Difference Between
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Difference between var, let and const keywords in JavaScript
Difference Between Method Overloading and Method Overriding in Java
Difference between Prim's and Kruskal's algorithm for MST
Difference between Internal and External fragmentation
Differences and Applications of List, Tuple, Set and Dictionary in Python
Arrays in Java
Split() String method in Java with examples
For-each loop in Java
Arrays.sort() in Java with examples
Reverse a string in Java