Java——访问修饰符

一、访问修饰符是什么

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