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