访问控制修饰符：
用来控制对类、方法和变量访问权限的修饰符。
Java 支持 4 种不同的访问权限：
default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）
访问控制
| 修饰符 | 当前类 | 同一包内 | 子孙类(同一包) | 子孙类(不同包) | 其他包 |
|---|---|---|---|---|---|
public |
Y | Y | Y | Y | Y |
protected |
Y | Y | Y | Y/N | N |
default |
Y | Y | Y | N | N |
private |
Y | N | N | N | N |
- 其中，
protected访问控制修饰符子孙类不同包时访问权限为Y/N是指：
当子类与基类在不同包时，那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法(Y)，而不能访问基类实例的protected方法(N)。
示例
- default:
- 同包父子类
package pA;
public class Father {
String defaultName = "default-name";
void printDefaultName() {
System.out.println("Father's name : " + defaultName);
}
}
package pA;
public class Son extends Father {
@Override
void printDefaultName() {
super.printDefaultName();
System.out.println("Son's name : " + defaultName);
}
}
- 不同包的子类：
package pB;
import pA.Father;
public class AnotherSon extends Father {
@Override
void printDefaultName() {
super.printdefaultName();
System.out.println("Another son's name : " + defaultName);
}
}
此时出现错误了：
如上图，不同包子类不能访问父类的
default变量和方法，因此printName()不能调用也不能重写，defaultNmae也不能访问。
- 与
Father类同包的测试：
package pA;
public class Test {
public static void main(String[] args) {
Father father = new Father();
Son son = new Son();
father.printDefaultName();
son.printDefaultName();
}
}
运行结果：
- protected
- 同包父子类
package pA;
public class Father {
protected String protectedName = "protected-name";
protected void printProtectedName() {
System.out.println("Father's name : " + protectedName);
}
}
package pA;
public class Son extends Father {
@Override
protected void printProtectedName() {
super.printProtectedName();
System.out.println("Son's name : " + protectedName);
}
}
- 不同包子类
package pB;
import pA.Father;
public class AnotherSon extends Father {
public void printAnother() {
System.out.println("Another son从父类继承来的protected方法：");
printProtectedName();
System.out.println("访问父类实例的protected方法：");
Father father = new Father();
father.printProtectedName(); // 第12行
}
}
- Father同包测试：
package pA;
import pB.AnotherSon;
public class Test {
public static void main(String[] args) {
Father father = new Father();
Son son = new Son();
AnotherSon anotherSon = new AnotherSon();
father.printProtectedName();
son.printProtectedName();
anotherSon.printProtectedName();
anotherSon.printAnother();
}
}
- 运行结果：
image.png
AnotherSon类第12行报错，因为不同包子类不能访问父类实例的protected方法。但是AnotherSon可以访问自己继承的父类的protected方法。
另外，在测试Test中，访问了不同包的AnotherSon实例的protected方法anotherSon.printProtectedName();却没有报错，这是因为它的anotherSon的printProtectedName()方法是继承自与Test同包的Father，因此没有报错。
- private
-
Father
可以访问当前类的private变量； -
同包子类
不能访问（重写，调用）父类的private方法和private变量； -
不同包的子类
不能访问（重写，调用）父类的private方法和private变量； -
同包
Test
不能访问father的private方法和变量。
- public
- Father
package pA;
public class Father {
public String publicName = "public-name";
public void printPublicName() {
System.out.println("Father's name : " + publicName);
}
}
- 同包的子类
package pA;
public class Son extends Father {
@Override
public void printPublicName() {
System.out.println("同包子类可以调用父类public方法：");
super.printPublicName();
System.out.println("Son's name : " + publicName);
}
}
- 不同包的子类
package pB;
import pA.Father;
public class AnotherSon extends Father {
@Override
public void printPublicName() {
System.out.println("不同包的子类访问父类的public方法：");
super.printPublicName();
System.out.println("Another son's name : " + publicName);
}
}
- 同包测试：
package pA;
import pB.AnotherSon;
public class Test {
public static void main(String[] args) {
Father father = new Father();
Son son = new Son();
AnotherSon anotherSon = new AnotherSon();
father.printPublicName();
System.out.println();
son.printPublicName();
System.out.println();
anotherSon.printPublicName();
}
}
运行结果：
另外，补充：
- 如果子类不能访问父类的某方法或变量，则子类也不能继承；
- 对于不能被外部直接访问的变量，可以通过
getter方法访问； -
静态方法不能使用类的非静态变量，因此，在
mian函数中，要访问当前类的非静态变量，要先生成一个当前类的实例，然后访问实例的变量才可。
