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.
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:
Example #4
Here in this example, I am illustrating that the PRIVATE METHOD cannot be invoked/called outside of the class. Here now, the private method is calling from the Outside class by changing class runtime behavior.
Code:
import java.lang.reflect.Method;
class ABC {
private void display()
{
System.out.println("Hey Now private method is invoked/Called");
}
}
public class Main{
public static void main(String[] args)throws Exception{
Class d = Class.forName("ABC");
Object p= d.newInstance();
Method n =d.getDeclaredMethod("display", null);
n.setAccessible(true);
n.invoke(p, null);
}
}Output:
Example #5
This is an example of a private method and field in Java Programming Language. Here private method/methods use static binding at the compile-time, and it even can’t be overridden. Don’t confuse with the Private variable output because the Private variable is actually accessible inside the inner class/classes. If PRIVATE variable/variables are invoked/called outside of the class, definitely the compiler will produce an error.
Code:
public class Main {
private String i_m_private1 = " \n Hey Buddy I am a private member and i am not even accessible outside of this Class";
private void privateMethod1() {
System.out.println("Outer Class Private Method");
}
public static void main(String args[]) {
Main outerClass = new Main();
NestedClass nestc = outerClass.new NestedClass();
nestc.showPrivate(); //This syntax shows private method/methods are accessible inside the class/inner class.
outerClass = nestc;
nestc.privateMethod1(); //It don't call/invoke private method from the inner class because
// you can not override the private method inside the inner class.
}
class NestedClass extends Main {
public void showPrivate() {
System.out.println("Now we are going to access Outer Class Private Method: " + i_m_private1);
privateMethod1();
}
private void privateMethod1() {
System.out.println("Nested Class's Private Method");
}
}
}Output:
Advantages
Here we are going to explain the advantages of using Private methods/fields in Java below.
- It can be applied to the methods, fields and inner classes too in Java Programming Language.
- We can’t assign private to the outer interface or class.
- Always the top-level classes can’t be Private in Java Programming Language.
- Of course, we know that private variables or private methods can’t be accessible outside of the java class, but they can be accessible in another way via a reflection using the setAccessible(true) and by changing there the PRIVATE visibility.
- In Java Programming language, this methods cannot be overridden, even not inside the inner classes.
- PRIVATE members allow Java Virtual Machine and Compiler to optimize it for better performance.
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.
Conclusion
Coming to the end of the main topic, we actually happy to know how helpful and easy using Private Keyword in Java. In this article, I hope you understand the private keyword, private variable, access modifier, private constructor, and how to use these private keywords in programs.
Recommended Articles
This is a guide to a Private constructor in java. Here we discuss the basic concept, working, advantages, rules, and private regulations in java and their examples and implementation. You may also look at the following articles to learn more –
