Open In App

Public vs Protected Access Modifier in Java

Last Updated : 08 Oct, 2021
Improve
Improve
Like Article
Like
Save
Share
Report

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.

Public Access Modifiers: If a class is declared as public then we can access that class from anywhere.

In the below example we are creating a package pack1 inside that package we declare a class A which is public and inside that class, we declare a method m1 which is also public. Now we create another package pack2 and inside that pack2 we import pack1 and declare a class B and in class B’s main method we create an object of type class A and trying to access the data of method m1.

Java




// creating a package
package pack1;
 
// import required packages
import java.io.*;
import java.util.*;
 
// declaring a public class
public class A {
   
    // declaring method m1
    public void m1() { System.out.println("GFG"); }
}


Compiling and saving the above code by using the below command line: 


Java




// creating a package
package pack2;
 
// import required packages
import java.io.*;
import java.util.*;
 
// importing package pack1
import pack1.A;
 
// driver class
class B {
   
    // main method
    public static void main(String[] args)
    {
        // creating an object of type class A
        A a = new A();
       
        // accessing the method m1()
        a.m1();
    }
}



If class A is not public while compiling B class we will get a compile-time error saying pack1. A is not public in pack1 and can’t be accessed from the outside package.

Similarly, a member or method, or interface is declared as public as we can access that member from anywhere.

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




// import required packages
import java.io.*;
import java.util.*;
 
// declaring a parent class A
class A {
   
    // declaring a protected method m1()
    protected void m1() { System.out.println("GFG"); }
}
 
// creating a child class by extending the class A
class 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();
    }
}



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. 

                         Public Access Modifier                           Protected Access Modifier
This modifier is applicable for both top-level classes and interfaces. This modifier is not applicable for both top-level classes and interfaces.
We can access public members from the non-child class of outside package. We can’t access protected members from the non-child class of outside package.
We can access public members anywhere from the outside package. We can access protected members only through child references from the outside package.
The public modifier is more accessible than the protected modifier. This modifier is more restricted than the public modifier.

 



Similar Reads

Public vs Protected vs Package vs Private Access Modifier in Java
Whenever we are writing our classes we have to provide some information about our classes to the JVM like whether this class can be accessible 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 mo
7 min read
Private vs Protected vs Final Access Modifier in Java
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 mo
5 min read
Protected vs Final Access Modifier in Java
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 mo
5 min read
Abstract vs Public Access Modifier in Java
Access Modifier in Java is the reserved keyword used to define the scope of a class, variable, and methods. It also tells us about that whether child class creation is possible or not or whether object creation is possible or not. Abstract Access Modifier is a modifier applicable only for classes and methods but not for variables. If we declare any
4 min read
Public vs Protected in C++ with Examples
Public All the class members declared under public will be available to everyone. The data members and member functions declared public can be accessed by other classes too. The public members of a class can be accessed from anywhere in the program using the direct member access operator (.) with the object of that class. Example: // C++ program to
2 min read
Private vs Final Access Modifier in Java
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 modi
3 min read
Java - Final vs Static Access Modifier
Final keyword is used in different contexts. First of all, final is a non-access modifier applicable only to a variable, a method, or a class. Following are different contexts where final is used. While the static keyword in Java is mainly used for memory management. The static keyword in Java is used to share the same variable or method of a given
5 min read
Protected vs Package Access Modifiers in Java
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 mo
4 min read
Protected vs Private Access Modifiers in Java
Access modifiers are those elements in code that determine the scope for that variable. As we know there are three access modifiers available namely public, protected, and private. Let us see the differences between Protected and Private access modifiers. Access Modifier 1: Protected The methods or variables declared as protected are accessible wit
2 min read
Method Overriding with Access Modifier
Prerequisites: Method Overriding in java and Access Modifier in Java Method Overriding In any object-oriented programming language, Overriding is a feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by its super-class or parent class. When a method in a subclass has the same name,
3 min read