Java private keyword

A Java private keyword is an access modifier. It can be assigned to variables, methods, and inner classes. It is the most restricted type of access modifier.

Points to remember

The private access modifier is accessible only within the same class.
We can't assign private to outer class and interface.
The best use of private keyword is to create a fully encapsulated class in Java by making all the data members of that class private.
If we make any class constructor private, we cannot create the instance of that class from outside the class.
If we are overriding any method, overridden method (i.e., declared in the subclass) must not be more restrictive.
According to the previous point, if we assign a private modifier to any method or variable, that method or variable can be overridden to sub-class using all type of access modifiers. However, still, we can't invoke private method outside the class.

Examples of private keyword

Example 1

Let's see an example to determine whether the private variable is accessible or not outside the class.

class A
{
 private String msg="Try to access the private variable outside the class";
	 
}
public class PrivateExample1 {
public static void main(String[] args) {
	A a=new A();
   System.out.println(a.msg);
	
}
}

Output:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The field A.msg is not visible

Example 2

Let's see an example to determine whether the private method is accessible or not outside the class.

class A
{
private void display()
 {
	 System.out.println("Try to access the private method outside the class ");
 }
	 
}
public class PrivateExample2 {
public static void main(String[] args) {
	A a=new A();
   a.display();
	
}
}

Output:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The method display() from the type A is not visible

Example 3

Let's see an example to determine whether we can assign the private modifier to the outer class.

private class PrivateExample3 {
void display()
{
	System.out.println("Try to access outer private class");
}
public static void main(String[] args) {
	PrivateExample3 p=new PrivateExample3();
	p.display();
	
}
}

Output:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:

Example 4

In the above example, we learn that the private method can't be invoked outside the class. Here, we call the private method from outside the class by changing the runtime behavior of that class.

import java.lang.reflect.Method; 

class A {  
  private void display()
  {
	  System.out.println("private method is invoked");
  }  
}  	 
 
public class PrivateExample4{  
public static void main(String[] args)throws Exception{  
  
    Class c = Class.forName("A");  
    Object o= c.newInstance();  
    Method m =c.getDeclaredMethod("display", null);  
    m.setAccessible(true);  
    m.invoke(o, null);  
}  
}  

Output:

private method is invoked

Example 5

Let's see an example to determine whether we create the instance of private constructor outside the class.

class A
{
 String msg;
private A(String msg)
 {
	this.msg=msg;
 }
void display()
{
	System.out.println(msg);
}
	 
}
public class PrivateExample5 {
public static void main(String[] args) {
	A a=new A("Try to create the instance of private constructor outside the class");	
	a.display();
}
}

Output:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The constructor A(String) is not visible

Example 6

In this example, the private method is overridden to sub-class using default access modifier. However, still, we are not allowed to invoke parent class method from sub-class.

class A{ 
private void msg()
{
	System.out.println("parent class method");	
}  
}  
  
public class PrivateExample6 extends A{
	
void msg()
{
	System.out.println("child class method");
	
}
 public static void main(String args[]){  
	 PrivateExample6 obj=new PrivateExample6();  
     obj.msg();  
   }  
} 

Output:

child class method

Example 7

Let's see the real use of private keyword with the help of an example.

class Employee{ 
private int id;
private String name;
private int age;
public int getId() {
	return id;
}
public void setId(int id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
}  
  
public class PrivateExample7{

 public static void main(String args[]){  
	Employee e=new Employee();  
    e.setId(101);
    e.setName("John William");
    e.setAge(25);
    System.out.println(e.getId()+" "+e.getName()+" "+e.getAge());
   }  
} 

Output: