Difference Between Access Specifiers and Modifiers

In Java, the access modifiers are used for restricting the scope of a class and its data members, member function, and constructor. Access modifiers play an important in designing Java programs and Java applications.

Java has the following access modifiers:

private
protected
public
default

Default Access Modifiers

When we define class, data members, and member function without specifying any access modifier, it has a default access modifier by default. The class, data members, and member functions that we defined without using access modifiers can be accessed only within the same package. Outside of the current package, we cannot use the classes and methods.

Let's implement the code for default access modifiers to understand its behavior.

DefaultModifiersExample1.java

package javaTpoint.MicrosoftJava;

class DefaultModifiersExample1 {
	void showData() {
		System.out.println("DefaultModifiersExample1 class method call."); 
	}
}

DefaultModifiersExample2.java

package sssit.JavaExample;
import javaTpoint.*; 

public class DefaultModifiersExample2 {
	public static void main(String args[]) 
    { 
        // try to access showdata() method of the DefaultModifiersExample1 from javaTpoint.MicrosoftJava package
		DefaultModifiersExample1 obj = new DefaultModifiersExample1(); 
    		obj.showData(); 
    } 
}

Output:

When you compile the DefaultModifiersExample2 class, it throws a compile-time error.

Public Access Modifiers

It is another access modifier which we use in Java. We use the public access modifier by using the public keyword. It is one of the access modifiers which have the widest scope. We can access the methods and variables of a class from anywhere in the program, which is declared as public. In simple words, no restriction is allowed on the scope of public data members.

Let's implement the code for public access modifiers to understand its behavior.

PublicModifiersExample1.java

package javaTpoint.JavaExample;
class Test{ 
	public void display() 
    { 
        System.out.println("Public Access Modifier"); 
    } 
}
public class DefaultModifiersExample3 
{
	public static void main(String args[]) 
	{ 
		Test obj = new Test(); 
		// accessing private method of another class  
		obj.display();
	} 
}

Output:

Protected Access Modifiers

The protected is another access modifier which we use in Java by adding the protected keyword to the data members and member functions of a class. We can access the protected data members and member functions of a class within the same package or the subclasses in different packages.

Let's implement the code for protected access modifiers to understand its behavior.

ProtectedModifierExample1.java

package javaTpoint.JavaExample;
class Person 
{
	protected String signature = "Mr.";
	protected String firstName = "Paul";
	protected String lastName = "Doe";
	protected String email = "pauldoe@gmail.com.com";
	protected int age = 21;
}
class ProtectedModifierExample1 extends Person 
{
	private int passOut = 2020;
	public static void main(String[] args) {
		ProtectedModifierExample1 newObj = new ProtectedModifierExample1();
	    System.out.println("Name: " + newObj.signature+ " "+ newObj.firstName + " " + newObj.lastName);
	    System.out.println("Email: " + newObj.email);
	    System.out.println("Age: " + newObj.age);
	    System.out.println("Graduation Year: " + newObj.passOut);
	}
}

Output:

Private Access Modifiers

The private is another access modifier which we use in Java by adding the private keyword to the data members and member functions of a class. The scope of the private data member and member function is limited and can access them only within the same class in which they declare.

If we try to access them from a different package or from a different class within the same package, it will throw a compiler time error.

Let's implement the code for private access modifiers to understand its behavior.

PrivateModifierExample1.java

package javaTpoint.JavaExample;
class NewTest 
{
	private int passOut = 2020;
}
public class PrivateModifierExample1 extends NewTest
{
	protected String signature = "Mr.";
	protected String firstName = "Paul";
	protected String lastName = "Doe";
	protected String email = "pauldoe@gmail.com.com";
	protected int age = 21;	
	public static void main(String[] args) {
		PrivateModifierExample1 newObj = new PrivateModifierExample1();
	    System.out.println("Name: " + newObj.signature+ " "+ newObj.firstName + " " + newObj.lastName);
	    System.out.println("Email: " + newObj.email);
	    System.out.println("Age: " + newObj.age);
	    //System.out.println("Graduation Year: " + newObj.passOut);
	}
}

Output:

If we uncomment the last statement in which we access the private variable passOut, it throws a compile-time error.

Difference Between Access Specifiers and Access Modifiers

The meaning of both the access specifiers and the access modifiers is the same. There are no differences between the specifiers and modifiers, and the use of both is the same. The access modifier is an official term and the new term that we use instead of modifier is specifier.

So, default, public, protected, and private access modifiers can also be referred to as default, public, protected, and private access specifiers.

Next TopicDifference Between Java and PHP

← prev next →