Access Modifiers in Java
There are two types of modifiers in Java: access modifiers and non-access
modifiers.
The access modifiers in Java
specifies the accessibility or scope of a field, method, constructor, or class.
We can change the access level of fields, constructors, methods, and class by
applying the access modifier on it.
There are four types of Java access
modifiers:
- Private: The access level of a private modifier is
only within the class. It cannot be accessed from outside the class.
- Default: The access level of a default modifier is
only within the package. It cannot be accessed from outside the package.
If you do not specify any access level, it will be the default.
- Protected: The access level of a protected modifier is
within the package and outside the package through child class. If you do
not make the child class, it cannot be accessed from outside the package.
- Public: The access level of a public modifier is
everywhere. It can be accessed from within the class, outside the class,
within the package and outside the package.
There are many non-access modifiers,
such as static, abstract, synchronized, native, volatile, transient, etc. Here,
we are going to learn the access modifiers only.
Details of Java Access Modifiers
|
Access Modifier |
Applicable for |
within class |
within package |
outside package by subclass only |
outside package |
|
Private |
Method, Fields |
Y |
N |
N |
N |
|
Default |
Class, Method, Fields |
Y |
Y |
N |
N |
|
Protected |
Method, Fields |
Y |
Y |
Y |
N |
|
Public |
Class, Method, Fields |
Y |
Y |
Y |
Y |
1) Private
The private access modifier is
accessible only within the class.
Example :
In the below example PrivateExample class
contains private data member and private method. We are accessing these private
members from outside the class, so there is a compile-time error.
public class PrivateExample {
private int age =40;
private String name =
"Rahul";
}
public class AccessModifierTest {
public
static void main(String[] args) {
PrivateExample
obj = new PrivateExample();
System.out.println(obj.age);//compilation
error
System.out.println(obj.name);//compilation
error
}
}
Role of Private
Constructor
If you make any class constructor
private, you cannot create the instance of that class from outside the class.
For example:
public class PrivateExample {
private PrivateExample (){
//arguments
}
}
public class AccessModifierTest {
public
static void main(String[] args) {
PrivateExample
obj = new PrivateExample();//compilation error
}
}
Note: A class cannot be
private or protected except nested class.
2) Default
If you don't use any modifier, it is
treated as default by default. The default modifier is
accessible only within package. It cannot be accessed from outside the package.
It provides more accessibility than private. But, it is more restrictive than
protected, and public.
Example :-
In this example, we are accessing the
data members of DefaultExample class from outside its package, since age &
name are not public, so it cannot be accessed from outside the package.
package com.test1;
public class DefaultExample {
int age =40;
String name =
"Rahul";
}
import com.test1.*;
package com.test2;
public class AccessModifierTest {
public
static void main(String[] args) {
DefaultExample
obj = new DefaultExample ();
System.out.println(obj.age);//compilation
error
System.out.println(obj.name);//compilation
error
}
}
The scope of age & name in class PrivateExample
is default, so it cannot be accessed from outside the package.
3) Protected
The protected access modifier is
accessible within package and outside the package but through inheritance only.
The protected access modifier can be
applied on the data member, method and constructor. It can't be applied on the
class.
It provides more accessibility than
the default modifier.
Example :-
We have created the two packages test1
and test2. The ProtectedExample
class of test1 package is public, so can be accessed from outside the package.
But age variable of this class is
declared as protected, so it cannot be accessed from outside the class only
through inheritance.
package com.test1;
public class ProtectedExample {
protected int age =40;
public String name =
"Rahul";
}
import com.test1.*;
package com.test2;
public class AccessModifierTest {
public
static void main(String[] args) {
ProtectedExample
obj = new ProtectedExample ();
System.out.println(obj.age);//compilation
error
System.out.println(obj.name);
}
}
4) Public
The public access modifier is
accessible everywhere. It has the widest scope among all other modifiers.
Example :-
package com.test1;
public class ProtectedExample {
public int age =40;
public String name =
"Rahul";
}
import com.test1.*;
package com.test2;
public class AccessModifierTest {
public
static void main(String[] args) {
PrivateExample
obj = new PrivateExample();
System.out.println(obj.age);
System.out.println(obj.name);
}
}
Java Access Modifiers with Method Overriding
If you are overriding any method, overridden
method (i.e. declared in subclass) must not be more restrictive.
class A{
protected void msg(){
System.out.println("This is parent");
}
}
public class Simple extends A{
void msg(){
System.out.println("This is child");
}//C.T.Error
public static void main(String args[]){
Simple obj=new Simple();
obj.msg();
}
}
The default modifier is more
restrictive than protected.
Comments
Post a Comment