Java Tutorials and Java Concept
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
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 indicates 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 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 Palindrome {
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(“Palindrome”);
} else {
System.out.println(“Not Palindrome”);
}
}
public static void main(String[] args) {
Palindrome ob = new Palindrome();
ob.input();
ob.palin();
}
}
Originally published at https://javaknowhow.blogspot.com.