Java Access Modifers

In java access modifiers helps to restrict the scope of a class, constructor, variable and method. There are four types of access modifiers available in java:

  1. 1. Default
  2. 2. Private
  3. 3. Protected
  4. 4. Public
Default Private Protected Public
Same Class Yes Yes Yes Yes
Same package sub class Yes No Yes Yes
Same package non-sub class Yes No Yes Yes
Different package sub class No No Yes Yes
Different package non sub class No No No Yes
Default:

When no access modifier is specified for a class, method, or data member – It is said to be having the default access modifier by default.

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.

In this 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 the second package.


    // Java program to illustrate default modifier
    package com.java.session.six;
    
    // Class AccessModifierEx1 is having Default access modifier
    public class AccessModifierEx1
    {
        void display()
        {
            System.out.println("Hello World!");
        }
    }
    


    // Java program to illustrate error while
    // using class from different package with
    // default modifier
    package com.java.session.six;
    import package com.java.session.six.p1.*;

    // This class is having default access modifier
    class AccessModifierEx1New
    {
        public static void main(String args[])
        {
            // Accessing class from different package
            AccessModifierEx1 obj = new AccessModifierEx1();

            obj.display();
        }
    }

Output: Compile time error

Private:

The private access modifier is specified using the keyword private.

  1. - The methods or variables of a class can declared as private are accessible only within the class in which they are declared.
  2. - Any other class of the same package will not be able to access these members.
  3. - Top-level classes or interfaces can not be declared as private.
  4. - private means “only visible within the enclosing class”.

Hence these modifiers in terms of application to classes, apply only to nested classes and not on top-level classes. In this example, we will create two classes A and B within the same package com.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 com.p1;

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

    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();

protected:

The protected access modifier is specified using the keyword protected. The methods or varible of a class can declared as protected are accessible within the same package or subclasses in different packages. In this example, we will create two packages com.p1 and com.p2. Class A in com.p1 is made public, to access it in com.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 com.p1;

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


    // Java program to illustrate
    // protected modifier
    package com.p2;
    import com.p1.A; // importing all classes in package p1

    // Class B is subclass of A
    class B extends A
    {
      public static void main(String args[])
      {
        B obj = new B();
        obj.display();
      }  
    }

Output:: NavabITSolutions

public:

The public access modifier is specified using the keyword public.

  1. - The public access modifier has the widest scope among all other access modifiers.
  2. - Classes, methods, or data members that are declared as public are accessible from everywhere in the program. There is no restriction on the scope of public data members.


    // Java program to illustrate
    // public modifier
    package com.p1;
    public class A
    {
      public void display()
      {
        System.out.println("NavabITSolutions");
      }
    }



    package com.p2;
    import com.p1.*;
    class B {
      public static void main(String args[])
      {
        A obj = new A();
        obj.display();
      }
    }

Output:: NavabITSolutions