There are two types of modifiers in Java: access modifiers and non-access modifiers.

The access modifiers in Java specifies the accessibility or scope of a field, method, constructor, or class. We can change the access level of fields, constructors, methods, and class by applying the access modifier on it.

There are four types of Java access modifiers:

1. Private: The access level of a private modifier is only within the class. It cannot be accessed from outside the class.
2. Default: The access level of a default modifier is only within the package. It cannot be accessed from outside the package. If you do not specify any access level, it will be the default.
3. Protected: The access level of a protected modifier is within the package and outside the package through child class. If you do not make the child class, it cannot be accessed from outside the package.
4. Public: The access level of a public modifier is everywhere. It can be accessed from within the class, outside the class, within the package and outside the package.

There are many non-access modifiers, such as static, abstract, synchronized, native, volatile, transient, etc. Here, we are going to learn the access modifiers only.

Understanding Java Access Modifiers

Let’s understand the access modifiers in Java by a simple table.

1) Private

The private access modifier is accessible only within the class.

Simple example of private access modifier

In this example, we have created two classes A and Simple. A class contains private data member and private method. We are accessing these private members from outside the class, so there is a compile-time error.

Role of Private Constructor

If you make any class constructor private, you cannot create the instance of that class from outside the class. For example:

Note: A class cannot be private or protected except nested class.

Grab the opportunity to learn Python with Entri! Click Here

2) Default

If you don’t use any modifier, it is treated as default by default. The default modifier is accessible only within package. It cannot be accessed from outside the package. It provides more accessibility than private. But, it is more restrictive than protected, and public.

Example of default access modifier

In this example, we have created two packages pack and mypack. We are accessing the A class from outside its package, since A class is not public, so it cannot be accessed from outside the package.

In the above example, the scope of class A and its method msg() is default so it cannot be accessed from outside the package.

3) Protected

The protected access modifier is accessible within package and outside the package but through inheritance only.

The protected access modifier can be applied on the data member, method and constructor. It can’t be applied on the class.

It provides more accessibility than the default modifer.

Example of protected access modifier

In this example, we have created the two packages pack and mypack. The A class of pack package is public, so can be accessed from outside the package. But msg method of this package is declared as protected, so it can be accessed from outside the class only through inheritance.

Output:Hello

4) Public

The public access modifier is accessible everywhere. It has the widest scope among all other modifiers.

Example of public access modifier

Output:Hello

Learn Coding in your Language! Enroll Here!

Java Access Modifiers with Method Overriding

If you are overriding any method, overridden method (i.e. declared in subclass) must not be more restrictive.

The default modifier is more restrictive than protected. That is why, there is a compile-time error.

Protected Access Modifier – Protected

Variables, methods, and constructors, which are declared protected in a superclass can be accessed only by the subclasses in other package or any class within the package of the protected members’ class.

The protected access modifier cannot be applied to class and interfaces. Methods, fields can be declared protected, however methods and fields in a interface cannot be declared protected.

Protected access gives the subclass a chance to use the helper method or variable, while preventing a nonrelated class from trying to use it.

Example

The following parent class uses protected access control, to allow its child class override openSpeaker() method −

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // implementation details
   }
}

class StreamingAudioPlayer {
   boolean openSpeaker(Speaker sp) {
      // implementation details
   }
}

Here, if we define openSpeaker() method as private, then it would not be accessible from any other class other than AudioPlayer. If we define it as public, then it would become accessible to all the outside world. But our intention is to expose this method to its subclass only, that’s why we have used protected modifier.

Introduction to Private in Java

The keyword ‘private’ in Java is used to establish the limitation of accessibility of the class, method or a variable in the java code block. If a class, method or variable is entitled as private in the program, that means that a particular class, method or variable cannot be accessed by outside the class or method, unlike the public method. The Private keyword is typically used in Java in a fully encapsulated class.

How Private Keyword Works in Java?

Private Keyword in Java works within a particular class. It can’t be accessed outside of the class. It doesn’t work outside the class/classes and interface/ interfaces. Private Keyword works well if the members of the class are PRIVATE and that too in a fully encapsulated class. Private Keyword or variable or method can also be overridden to the sub-class/classes using some access modifiers to invoke PRIVATE METHOD outside of the class. With this, Private Keyword also works outside of the class only using the Private Access Modifiers.

Learn to code from industry experts! Enroll here

Examples

Here are some examples of private modifiers, which are as follows:

Example #1

Here we are illustrating the example of Private Access Modifier, which shows compilation error because of private data member accessing from the class AB, which is shown in the below example. Private methods or Private members can only be accessible within a particular class.

Code:

class AB{
private double number = 100;
private int squares(int a){
return a*a;
}
}
public class Main{
public static void main(String args[]){
AB obj = new AB();
System.out.println(obj.number);
System.out.println(obj.squares(10));
}
}

Output:

Example #2

This is an example of illustrating the use of the PRIVATE keyword with the program below:

Code:

class Emp{
private int id1;
private String name14;
private int age14;
public int getId1() {
return id1;
}
public void setId(int id1) {
this.id1 = id1;
}
public String getName14() {
return name14;
}
public void setName14(String name14) {
this.name14 = name14;
}
public int getAge14() {
return age14;
}
public void setAge14(int age14) {
this.age14 = age14;
}
}
public class Main{
public static void main(String args[]){
Emp e=new Emp();
e.setId(1473);
e.setName14("Pavan Kumar Sake");
e.setAge14(24);
System.out.println(e.getId1()+" "+e.getName14()+" "+e.getAge14());
}
}

Output:

Example #3

Here in this example, you can see how the PRIVATE METHOD is overridden to the sub-class using the access modifier, which is the default. We are not even allowed to invoke the parent class method/methods from the sub-class.

Code:

class ABC{
private void msg()
{
System.out.println("Hey Buddy this is the parent class method"); //Output of the Private Method
}
}
public class Main extends ABC{ // Private method is overridden using the access modifier
void msg()
{
System.out.println("Buddy this is the child class method");
}
public static void main(String args[]){
Main obj=new Main();
obj.msg();
}
}

Output:

Rules and Regulations for Private Constructor in Java

Here are some rules and regulations for private that you should know.

• If the class contains PRIVATE CONSTRUCTOR, you can’t create any object of that particular class from the outside class.
• You should not access a private keyword outside of the class. If you try, it will produce a compilation error for that deed. For that, you have to modify the code.
• Top-level classes can’t be private in this java language.