Access modifiers in Java are used to specify access levels for classes, variable methods and constructor.

 default: The scope of default access modifier is limited to the package only. If we do not mention any access modifier, then it acts like a default access modifier.

Let’s see a practical example to understand this better.

1
2
3
4
5
6
7
8
9
10
package packageOneDefault;
 
public class DefaultClassOne {
 
// Here I didnt mention any modifier so it acts as a default modifier.
protected int myMethod(int x){
return x;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package packageTwoDefault;
 
import packageOneDefault.DefaultClassOne;
 
public class DefaultClassTwo {
public static void main(String args[]){
// Created an object of ClassOne
DefaultClassOne obj = new DefaultClassOne();
// Trying to access the default method of ClassOne which is in packageOne
// You can find an error at obj.myMethod
 
obj.myMethod(10);
}
}

private: The scope of private access modifier is only within the classes.

Note: Class or Interface cannot be declared as private

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package packageThreePrivate;
 
public class PrivateClassOne {
 
private int x = 100;
int y = 200;
 
private int myMethod(int a){
return a;
}
int myMethodOne(int a){
return a;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package packageThreePrivate;
 
public class PrivateClassTwo {
public static void main(String args[]){  
PrivateClassOne obj = new PrivateClassOne();  
// Here I am trying to access the private data member and private method of ClassOne
// It throws compilation error
System.out.println(obj.x);
System.out.println(obj.myMethod(1000));
// Here I am trying to access default data member and default method of ClassOne
// No error. We can comfortable access default modifier with in the package
System.out.println(obj.y);
System.out.println(obj.myMethodOne(2000));
   }
}

protected: The scope of protected access modifier is within a package and also outside the package through inheritance only.

Note: Class cannot be declared as protected

1
2
3
4
5
6
7
8
9
package packageFourProtected;
 
public class ProtectedClassFour {
 
protected int myMethod(int a){
return a;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
package packageFiveProtected;
 
import packageFourProtected.ProtectedClassFour;
 
public class ProtectedClassFive extends ProtectedClassFour{
public static void main(String args[]){
ProtectedClassFive obj = new ProtectedClassFive();
System.out.println(obj.myMethod(100));
}
 
}

public: The scope of public access modifier is everywhere. It has no restrictions. Data members, methods and classes that declared public can be accessed from anywhere.

1
2
3
4
5
6
7
8
9
10
package packageSixPublic;
 
public class PublicClassSix {
 
// Here I didnt mention any modifier so it acts as a default modifier.
public int myMethod(int x){
return x;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package packageSevenPublic;
 
import packageSixPublic.PublicClassSix;
 
public class PublicClassSeven {
public static void main(String args[]){
// Created an object of ClassOne
PublicClassSix obj = new PublicClassSix();
// Trying to access the public method of PublicClassSix which is in packageSixPublic
 
obj.myMethod(10);
 
// We tried the same example with Default and we faced an error. Hope you remember
}
}

See this simple table to understand access modifiers easily

Must Read: Java Tutorial