一、访问修饰符是什么
Java中的访问修饰符用于控制类、接口、构造函数、方法和数据成员(字段)的可见性和访问级别。
Java提供了四种访问修饰符:
访问修饰符 | 同一类内 | 同一包内 | 不同包的子类 | 不同包的非子类 | 适用对象 |
---|---|---|---|---|---|
public | 可见 | 可见 | 可见 | 可见 | 类、接口、变量、方法 |
protected | 可见 | 可见 | 可见 | 不可见 | 变量、方法 |
默认 | 可见 | 可见 | 不可见 | 不可见 | 类、接口、变量、方法 |
private | 可见 | 不可见 | 不可见 | 不可见 | 变量、方法 |
二、访问修饰符详细介绍
对于访问修饰符修饰变量和修饰方法(包括构造器)的可访问情况都是一致的,我们下面以每个访问修饰符修饰成员变量作为例子。
1、public
- 访问权限:最高,可以被任何其他类访问。
- 适用范围:类、接口、构造器、方法和字段。
com.pack2 包中:
package com.pack2;
public class Example {
//public 修饰字段(成员变量),以此为例
public int publicVar;
public void example() {
System.out.println(publicVar);//同一个类中可以访问 publicVar
}
}
package com.pack2;
public class SamePackage {
public Example e = new Example();
public void show() {
System.out.println(e.publicVar);//可以在同一个包中被访问 publicVar
}
}
这里可以看到同一类中可以访问 public 修饰的成员变量,同一个包中可以访问 public 修饰的成员变量。
com.pcak1 包中:
package com.pack1;
import com.pack2.Example;
public class NotSamePackNotSubclass {
public static void main(String[] args) {
Example e1 = new Example();
System.out.println(e1.publicVar);//在不同包的非子类中访问 publicVar
}
}
package com.pack1;
import com.pack2.Example;
public class Subclass extends Example {
public void foo() {
System.out.println(publicVar);//在不同包的子类中访问 publicVar
}
}
这里可以看到在不同包的非子类和子类中都可以访问到 public 修饰的成员变量。
2、protected
- 访问权限:可以被同一个包中的任何类访问,以及不同包中的子类访问。不能被不同包的非子类访问。
- 适用范围:构造函数、方法和字段。
com.pack2 包中:
package com.pack2;
public class Example {
//protected 修饰的成员变量
protected int protectedVar;
public void show() {
System.out.println(protectedVar);//同一个类中可以访问 protectedVar
}
}
package com.pack2;
public class SamePackage {
Example example = new Example();
public void show() {
System.out.println(example.protectedVar);//同一个包中可以访问 protectedVar
}
}
可以看到这里 protected 修饰的成员变量可以在同一个类中和同一个包中访问。
com.pcak1 包中:
package com.pack1; import com.pack2.Example; public class NotSamePackNotSubclass { public static void main(String[] args) { Example example = new Example(); //System.out.println(example.protectedVar);//不同包的非子类不能访问 protectedVar //这里会报错 } }
可以发现这里 protected 修饰的成员变量不能在不同包的非子类中访问。这里会报以下错:
但是在子类中就可以访问,就像下面:
package com.pack1;
import com.pack2.Example;
public class Subclass extends Example{
public void show() {
System.out.println(protectedVar);//不同包的子类可以访问 protectedVar
}
}
可以发现 protected 修饰的成员变量可以在不同包的子类中被访问。
3、默认(没有访问修饰符)
- 访问权限:可以被同一个包中的任何类访问,但不能被不同包中的类访问。
- 适用范围:类、接口、构造函数、方法和字段。
com.pack2 包中:
package com.pack2;
public class Example {
//无修饰(默认)的成员变量
int defaultVar;
public void show() {
System.out.println(defaultVar);//同一个类中可以访问 defaultVar
}
}
package com.pack2;
public class SamePackage {
Example example = new Example();
public void show() {
System.out.println(example.defaultVar);//同一个包中可以访问 defaultVar
}
}
可以发现默认的访问权限(没有访问修饰符)的成员变量可以在同一个类中访问,也可以在同一个包中访问。
com.pcak1 包中:
package com.pack1; import com.pack2.Example; public class NotSamePackNotSubclass { public static void main(String[] args) { Example example = new Example(); //System.out.println(example.defaultVar);//不同包的非子类不能访问 defaultVar //这里会报错 } }
可以发现默认访问权限(没有访问修饰符)的成员变量不能在不同包的非子类中访问。这里会报错:
package com.pack1; import com.pack2.Example; public class Subclass extends Example{ public void show() { //System.out.println(defaultVar);//不同包的子类不能访问 defaultVar //这里会报错 } }
可以发现默认访问权限(没有访问修饰符)的成员变量不能在不同包的子类中访问。这里会报错:
4、private
- 访问权限:最低,只能被定义它的类内部访问。
- 适用范围:构造函数、方法和字段。
com.pack2 包中:
package com.pack2;
public class Example {
//private 修饰的成员变量
private int privateVar;
public void show() {
System.out.println(privateVar);//同一个类中可以访问 privateVar
}
}
可以发现 private 修饰的成员变量只能在同一个类中被访问。
package com.pack2; public class SamePackage { Example example = new Example(); public void show() { //System.out.println(example.privateVar);//同一个包中不能访问 privateVar //这里会报错 } }
可以发现 private 修饰的成员变量不能在同一个包中被访问。这里会报错:
com.pcak1 包中:
package com.pack1; import com.pack2.Example; public class NotSamePackNotSubclass { public static void main(String[] args) { Example example = new Example(); //System.out.println(example.privateVar);//不同包的非子类不能访问 privateVar //这里会报错 } }
可以发现 private 修饰的成员变量不能在不同包的非子类中被访问。这里会报错:
package com.pack1; import com.pack2.Example; public class Subclass extends Example{ public void show() { //System.out.println(privateVar);//不同包的子类不能访问 privateVar //这里会报错 } }
可以发现 private 修饰的成员变量不能在不同包的子类中被访问。这里会报错:
三、补充
1、适用范围
我们在文章最开始就给出了这个表格:
这里标出了这四个访问修饰符的适用对象。
对于 public 和默认(什么都不写)是适用于类、接口、成员变量和成员方法的。
但是对于 protected 和 private 是只能用于成员变量和成员方法的,不能用于类和接口。