Java Access Modifiers

Java Access Modifiers
Java Access Modifiers

Java Access Modifiers

In this tutorial, I’ll describe how Java access modifiers work in detail. They manage the visibility and their members (methods and data). There are three Java access modifiers public, private, and protected. There is another modifier namely default which is implemented by default.
Java Access Modifiers Explained With Examples
Access Modifier
within class
within package
outside package by subclass only
outside package
Outside Class
Public
Y
Y
Y
Y
Y
Protected
Y
Y
Y
Y
N
Private
Y
N
N
N
N
Default
Y
Y
Y
N
N

Public Access Modifier

The accessibility of this modifier visible everywhere. We can say that public modifier doesn’t put any restriction on the access. This indicate that any public class, method, variable, interface, or constructor is accessible throughout the package. But if it belongs to another package then we need to import it. It has a broad scope among all other modifiers. The public access modifier can be useful to classes and interfaces along with methods, data members and variables.
Example of public modifier
public class FirstClass
{
    public void display()
    {
        System.out.println("I am Public Modifier");
    }
}
public class SecondClass
{
   public static void main()
   {
       FirstClass ob = new FirstClass();
       ob.display();
    }
       
}

Output:

I am Public Modifier
Here, in SecondClass, we can instantiate the FirstClass because its access modifier is public. The variables and methods inside the SecondClass class are also public. Hence, you are able to use it directly in your L SecondClass.

Private Access Modifier
This modifier can access Data members, methods and constructors within the class.             We cannot develop subclasses to that class which has only private constructors. Classes or interface cannot be declared as private because private modifier will make the class useless.
public class PrivateExampleBase
{
   private void display()
    {
        System.out.println("I am Private Modifier");
    }
}
In PrivateExampleBase display() method declare as private and when we called display() method from PrivateExampleDrive then it will generate error “display() has private access in PrivateExampleBase”
public class PrivateExampleDrive
{
   public static void main()
   {
       PrivateExampleBase ob = new PrivateExampleBase();
       ob.display();
    }
}
Another Example: This program is used to show that private members of a class can be accessed in the class only

class StudentClass {
    //private members of the class

    private int rollNo; // define as a private modifier

    private void show() {
        rollNo = 10;
       
        System.out.println("RollNo = " + rollNo);
    }
}

public class PrivateDataMember {
    public static void main(String args[]) {
        //creating StudentClass object
        StudentClass ob = new StudentClass();
        System.out.println(ob.rollNo);
        ob.show();
    }
}
In PrivateDataMember class we will try ti access private data member(rollNo) and also try to access show() method. But it will not be accessecible as it is define as private. And it'll display error as "Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - rollNo has private access in MyFirstApp.StudentClass
            at MyFirstApp.PrivateDataMember.main(PrivateDataMember.java:15)"
Note: Private constructor cannot able to create an instance in another class.

Protected Access Modifier

The protected access modifier methods or data members are accessible within the same package or subclasses in a different package. We cannot declared protected in the classes because it used in the parent-child relationship. But the protected access modifier can be used on the data member, method and constructor.

package MyFirstApp;

class StudentClass {
    //protected members of the class
    protected int rollNo;
    protected void show()
    {
        rollNo = 10;
        System.out.println("RollNo = " + rollNo);
    }
}
public class ProtectedDataMember {
    public static void main(String args[]) {
        //creating Student class object
        StudentClass ob = new StudentClass();
        ob.show();
    }
}

Default Access Modifier

If we don’t mention any access modifier for a class, method or data member then we can say it is a default modifier. It can be accessed into all classes within the same package only. The default access modifier is also sometimes known as the package access modifier.

import java.util.Scanner;
public class Palindrom {
    int n, rev, m, a; // default access modifier
    void input() // this method contain no modifier
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter a number:");
        n = sc.nextInt();
        m = n;
    }

    void palin() // this method contain no modifier
    {
        rev = 0;
        while (m != 0) {
            a = m % 10;
            rev = rev * 10 + a;
            m /= 10;
        }
        if (rev == n) {
            System.out.println("Palindrom");
        } else {
            System.out.println("Not Palindrom");
        }

    }

    public static void main(String[] args) {
        Palindrom ob = new Palindrom();
        ob.input();
        ob.palin();
    }
}

More Tutorials

Linked List in Java

ArrayList in Java

Basic Features of java



SHARE THIS
Previous Post
Next Post