
Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Private vs Protected vs Final Access Modifier in Java
Whenever we declare a class we need to provide its access level so that JVM can know whether inheritance or instantiation can happen in the program and what is the scope of the class. For this we use access modifiers and these can be used with class, methods and variables etc..
Private access modifier restricts the method or variable access to the class only; that means the method or variable can be accessed within the same class only.
Protected access modifier allows access to the class and any subclass of that class, including classes in other packages.
Final access modifiers do not allow a class to be extended. If applied to a method then it can not be overridden by a subclass. And if a variable is declared final then it can not be assigned after initialization.
Algorithm
To implement private, protected and final access modifier, follow the steps below ?
Step 1 ? Define a class and its members i.e. methods and variables.
Step 2 ? To declare variable or method as private use private keyword as access modifier.
Step 3 ? To declare variable or method as protected use protected keyword as access modifier.
Step 4 ? Define variable as final using final keyword.
Step 5 ? Now members of the same class can access the private variable or methods.
Step 6 ? The methods of the same class or the subclasses can access the protected variables or methods.
Step 7 ? To access the private and protected variables outside of the class, you can use public methods that access these variables.
Step 8 ? The methods that access private and protected variables should be declared public.
Step 9 ? To create a constant that is accessible within the class use private and final keywords together.
Step 10 ? To create a constant that is accessible within the class and subclass use protected and final keywords together.
Syntax
public class Way2Class { private int privateVariable; protected int protectedVariable; final int finalVariable = 5; private void privateMethod() { // method implementation } protected void protectedMethod() { // method implementation } }
Approach 1: Using private access modifier
Here's the code snippet
Example
public class Main { private String name; private int age; public Main(String name, int age) { this.name = name; this.age = age; } private String getDetails() { return "Name: " + name + ", Age: " + age; } public void displayDetails() { String details = getDetails(); System.out.println(details); } public static void main(String[] args) { Main john = new Main("John", 30); john.displayDetails(); // prints "Name: John, Age: 30" String details = john.getDetails(); // Accessing private method, results in a compile-time error String name = john.name; // Accessing private field, results in a compile-time error int age = john.age; // Accessing private field, results in a compile-time error } }
Output
Name: John, Age: 30
Explanation
In the above program if we call getDetails() method and private variables outside the Employee class then we will get compile time error.
Approach 2: Using Protected access modifier
The following is a code example
Example
public class Main { public static void main(String[] args) { Car honda = new Car("Honda", "Civic", 2022, 4); honda.displayDetails(); } } class Vehicle { protected String make; protected String model; protected int year; public Vehicle(String make, String model, int year) { this.make = make; this.model = model; this.year = year; } protected String getDetails() { return "Make: " + make + ", Model: " + model + ", Year: " + year; } } class Car extends Vehicle { private int numDoors; public Car(String make, String model, int year, int numDoors) { super(make, model, year); this.numDoors = numDoors; } public void displayDetails() { String details = getDetails() + ", Number of Doors: " + numDoors; System.out.println(details); } }
Output
Make: Honda, Model: Civic, Year: 2022, Number of Doors: 4
Explanation
The following code executed without any error because we are accessing the protected variable and method inside the same package, class and subclass.
Approach 3: Using final access Modifier
Example
class Animal { final String species; public Animal(String species) { this.species = species; } public void makeSound() { System.out.println("The " + species + " makes a sound."); } } class Cat extends Animal { public Cat() { super("Cat"); } @Override public void makeSound() { System.out.println("Meow!"); } } public class Main { public static void main(String[] args) { Cat cat = new Cat(); cat.makeSound(); } }
Output
Meow!
Explanation
The Cat class extends the Animal class and does not add any new instance variables, but it attempts to override the makeSound() method with its own implementation that simply prints out "Mawo!". However, because the makeSound() method in the Animal class is marked as final, this attempt results in a compile-time error.
Comparison Between Approaches
Private Modifier |
Protected Modifier |
Final Modifier |
---|---|---|
Members can be accessed within the same class as declared. |
Members can be accessed within the class and subclass in the same package. |
members cannot be accessed within the same class or subclass. |
Interfaces can use this modifier |
Interfaces can use this modifier |
Interfaces can not use this modifier |
Private method can be overridden |
Protected method cannot be overridden |
Final method cannot be overridden. |
Conclusion
These access modifiers in Java are used to control the visibility of a class's members (variables, methods, and inner classes). Private limits access to members of the same class only, protected allows access to subclasses and classes in the same package, and final indicates that a member's value cannot be changed or a method cannot be overridden.