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
Leave a Reply