Four types of access modifiers in Java: Public, Protected, default (no modifiers, defaults), private.
- Four modifiers that can be modified (class, method, member variable)
|
Public |
Protected |
Default |
Private |
Class |
√ |
X |
√ |
x(inner class can be decorated with private) |
Method |
√ |
√ |
√ |
√ |
Member variables |
√ |
√ |
√ |
√ |
- Access permissions for four modifiers
Public: Visible to all classes
Protected: Visible to classes in the same package, to the same package, and to subclasses in different packages
Default: Visible to classes in the same package, to subclasses in the same package
Private: Visible only to the class itself
Visible is accessible meaning that the components (classes, methods, member variables) that are decorated by these modifiers can be accessed by other classes. A subclass can be seen to be inherited by a child class.
It is important to note that the difference between protected and default is that subclasses in different packages can inherit.
Access rights |
Class |
Same package |
Subclasses in the same package |
Subclasses in different packages |
Different packages |
Public |
√ |
√ |
√ |
√ |
√ |
Protected |
√ |
√ |
√ |
√ |
X |
Default |
√ |
√ |
√ |
X |
X |
Private |
√ |
X |
X |
X |
X |
Package1:parentclass, Childclassone, Testone
Package2:childclasstwo, Testtwo
Package3:testthree
where ParentClass is
public class ParentClass {public int a=2;protected int b = 3;int c = 4;private int d = 5;}
1. for Testone, ParentClass classes, A, B, and C are visible, and D is not visible. That is, you can new a ParentClass object in Testone, and the A,B,C variable in the object can be manipulated. As follows:
public class Testone {public static void main (String args[]) {ParentClass obj = new ParentClass (); System.out.println (OBJ.A); System.out.println (OBJ.B); System.out.println (OBJ.C);//system.out.println (OBJ.D); D not visible}}
2. Childclassone inherits ParentClass and is in the same package, A, B, c are visible, D is not visible.
public class Childclassone extends parentclass{public static void main (String args[]) {Childclassone obj = new Childclasso NE (); System.out.println (OBJ.A); System.out.println (OBJ.B); System.out.println (OBJ.C);//system.out.println (OBJ.D); D not visible}}
3. Childclasstwo inherit ParentClass, then a, b are visible, D is not visible, because the subclass and ParentClass are not in the same package, so C (default type) is not visible.
public class Childclasstwo extends parentclass{public static void main (String args[]) {Childclasstwo obj = new Childclasst Wo (); System.out.println (OBJ.A); System.out.println (OBJ.B);//system.out.println (OBJ.C); C not visible//system.out.println (OBJ.D); D not visible}}
4. For Testtwo, the ParentClass class, A are visible, B, C, d are not visible. Since Testtwo and ParentClass are not in the same package, only public-modified components are visible.
public class Testtwo {public static void main (String args[]) {ParentClass obj = new ParentClass (); System.out.println (OBJ.A);//system.out.println (OBJ.B); b not visible//system.out.println (OBJ.C); C not visible//system.out.println (OBJ.D); D not visible}}
- It is also worth noting that the visibility between the subclasses of the inherited parent class and the other classes depends on the visibility of the other classes to the parent class.
For Testone, Childclassone in A,b,c are visible, D is not visible, this is because Testone and ParentClass in the same package.
For Testthree, only a visible in Childclassone is due to testthree and ParentClass in different packages.
Need to note:
Although a, B to childclasstwo visible, Testtwo and Childclasstwo in the same package,
But for Testtwo, only a is visible in Childclasstwo, because Testtwo and ParentClass are in different packages, only public adornments are visible.
Four types of access modifiers in Java