Java——访问修饰符

一、访问修饰符是什么

Java中的访问修饰符用于控制类、接口、构造函数、方法和数据成员（字段）的可见性和访问级别。

Java提供了四种访问修饰符：

二、访问修饰符详细介绍

对于访问修饰符修饰变量和修饰方法（包括构造器）的可访问情况都是一致的，我们下面以每个访问修饰符修饰成员变量作为例子。

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 是只能用于成员变量和成员方法的，不能用于类和接口。