Access Modifiers in Java

1.7

As the name suggests access modifiers in Java helps to restrict the 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

access-modifiers-in-java

  1. 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 second package.

    //Java program to illustrate default modifier
    package p1;
    
    //Class Geeks is having Default access modifier
    class Geek
    {
        void display()
           {
               System.out.println("Hello World!");
           }
    }
    
    //Java program to illustrate error while 
    //using class from different package with
    //default modifier
    package p2;
    import p1.*;
    
    //This class is having default access modifier
    class GeekNew
    {
        public static void main(String args[])
           {  
              //accessing class Geek from package p1
              Geeks obj = new Geek();
    
              obj.display();
           }
    }
    

    Output:

    Compile time error
    
  2. Private: The private access modifier is specified using the keyword private.

    • 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.

    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 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();
    
  3. protected: The protected access modifier is specified using the keyword protected.
    • The methods or data members declared as protected are accessible within same package or sub classes in different package.

    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 p1;
    
    //Class A
    public class A
    {
       protected void display()
        {
            System.out.println("GeeksforGeeks");
        }
    }
    
    //Java program to illustrate
    //protected modifier
    package p2;
    import p1.*; //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:

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

    • 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.
    //Java program to illustrate
    //public modifier
    package p1;
    public class A
    {
       public void display()
          {
              System.out.println("GeeksforGeeks");
          }
    }
    package p2;
    import p1.*;
    class B
    {
        public static void main(String args[])
          {
              A obj = new A;
              obj.display();
          }
    }
    
    

    Output:

    GeeksforGeeks
    
  5. Important Points:

    • 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.



    This article is contributed by Harsh Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

    Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

    GATE CS Corner    Company Wise Coding Practice

Recommended Posts:



1.7 Average Difficulty : 1.7/5.0
Based on 17 vote(s)










Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.