Access modifiers in Java

Access Modifiers in Java

Now it is very easy to understand here what is the access level / scope of a class, method, constructor, variable. Access modifiers in Java helps to identify the access level or scope of a class, constructor, variable, method or data member. There are four types of access modifiers available in java:

1. Default – No keyword required
2. Private
3. Protected
4. Public

For better understanding, member level access is formulated as a table:

Important Points:

Default: Ohh it's quite diffent, When no access modifier is specified for a class ,for a method or any data member – It is said to be having the default access modifier in java.

//Java program to illustrate default modifier
package pkg1;

//Class mindclues is having Default access modifier
class Mindclues{
    void display(){
           System.out.println("Hello mindclues!");
       }
}

//Java program to illustrate error while using class from different package with default modifier

//This class is having default access modifier

class MindcluesNew{
    public static void main(String args[]){
          //accessing class from package p1
          Mindclues obj = new Mindclues();
          obj.display();
       }
}

Output:

Compile time error

Above example, we will create two packages and the classes in the packages will be having the default access modifiers and we will try to access a class from one package from a class of second package.

• The data members, class or methods which are not declared using any access modifiers i.e. having default access modifier are accessible only within the same package.

Private: The private access modifier is specified using the keyword private.

In this example, we will create two classes A and B within same package p1. We will declare a method in class A as private and try to access this method from class B and see the result.

//Java program to illustrate error while using class from different package with private modifier

package mindclues;

class A{
   private void display(){
        System.out.println("mindclues");
    }
}

class B{
   public static void main(String args[]){
          A obj = new A();
          //trying to access private method of another class
          obj.display();
      }
}

Output:

error: display() has private access in A
  obj.display();

• The methods or data members declared as private are accessible only within the class in which they are declared.
• Any other class of same package will not be able to access these members.
• Classes or interface can not be declared as private.

protected: The protected access modifier is specified using the keyword protected.

In this example, we will create two packages p1 and p2. Class A in p1 is made public, to access it in p2. The method display in class A is protected and class B is inherited from class A and this protected method is then accessed by creating an object of class B.

//Java program to illustrate protected modifier

package mindclues;
//Class A
public class A{
   protected void display(){
        System.out.println("mindclues");
    }
}

//Java program to illustrate protected modifier

package mindclues;

import mind.*; //importing all classes in package mind Class B is subclass of A

class B extends A{
   public static void main(String args[]){ 

       B obj = new B(); 
       obj.display(); 

   } 
}

Output:

mindclues

• The methods or data members declared as protected are accessible within same package or sub classes in different package.

public: The public access modifier is specified using the keyword public.

//Java program to illustrate public modifier

package mindclues;

public class A{
   public void display(){
          System.out.println("mindclues");
      }
}

package mind;
import mindclues.*;

class B{
    public static void main(String args[]){
          A obj = new A;
          obj.display();
      }
}

Output:
mindclues

• The public access modifier has the widest scope among all other access modifiers.
• Classes, methods or data members which are declared as public are accessible from every where in the program. There is no restriction on the scope of a public data members.
• If other programmers use your class, try to use the most restrictive access level that makes sense for a particular member. Use private unless you have a good reason not to.
• Avoid public fields except for constants.