Public vs Protected Access Modifier in Java

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.
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 packagepackage pack1; // import required packagesimport java.io.*;import java.util.*; // declaring a public classpublic 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 packagepackage pack2; // import required packagesimport java.io.*;import java.util.*; // importing package pack1import pack1.A; // driver classclass 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 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();    }}
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. 
 
mroshanmishra0072
adnanirshad158
prachisoda1234
Java-Modifier
Picked
Technical Scripter 2020
Difference Between
Java
Technical Scripter
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
Similarities and Difference between Java and C++
Difference between Compile-time and Run-time Polymorphism in Java
Differences and Applications of List, Tuple, Set and Dictionary in Python
Arrays in Java
Arrays.sort() in Java with examples
Split() String method in Java with examples
Reverse a string in Java
Object Oriented Programming (OOPs) Concept in Java