Java 四种访问权限_java四种访问权限

一、访问权限控制

指的是本类及本类内部的成员(成员变量、成员方法、内部类)对其他类的可见性，即这些内容是否允许其他类访问。Java 一共有四种访问权限控制，其权限大小为：public > protected > default(包访问权限) > private

1️⃣public：Java 访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且可以跨包访问。
2️⃣protected：介于 public 和 private 之间的一种访问修饰符，一般称之为“保护访问权限”。被其修饰的属性以及方法只能被类本身及其子类访问，即使子类在不同的包中。外包的非子类不可以访问。
3️⃣default：“默认访问权限“或“包访问权限”，即不加任何访问修饰符。只允许在同包访问，外包的所有类都不能访问。接口例外
4️⃣private：Java 访问限制最窄的修饰符，一般称之为“私有的”。被其修饰的属性以及方法只能被该类的对象访问，其子类不能访问，更不允许跨包访问。

注意：

1. 所谓的访问，可以分为两种不同方式：通过对象实例访问；直接访问。
   比如说，某父类 protected 的成员，子类可以直接访问。换言之，子类继承了父类除 private 成员外的所有成员，包括 protected 成员。所以与其说是子类访问了父类的 protected 成员，不如说子类访问了自己从父类继承来的 protected 成员。另一方面，如果该子类与父类不在同一个包里，那么通过父类的对象实例是不能访问父类的 protected 成员的。

2. 要区分开 protected 权限、包访问权限，正确使用它们：
   ①当某个成员能被所有的子类继承，但不能被外包的非子类访问，就是用 protected；
   ②当某个成员的访问权限只对同包的类开放，包括不能让外包的类继承这个成员，就用包访问权限。

3. 使用访问权限控制的原因：
   ①禁止用户碰触那些不该碰触的部分；
   ②类库设计者可以更改类的内部工作的方式，而不用担心对用户产生重大影响。

二、访问权限控制的五种使用场景

1️⃣外部类的访问控制
外部类(外部接口)是相对于内部类(也称为嵌套类)、内部接口而言的。外部类的访问控制只能是这两种：public、default 。

①public 访问权限的外部类，所有类都可以使用此类

public class OuterClass {}
1

②default 访问权限的外部接口，所有类、接口均可以使用此接口

interface OuterInterface{}
1

2️⃣类成员的访问控制
类成员分为三类：成员变量、成员方法、成员内部类(内部接口)。类成员的访问控制可以是四种，也就是可以使用所有的访问控制权限。

public class AccessRights {
	//可以被所有的类访问
    public String publicStr = "public";
    //可以被本包的类及所有子类使用
    protected String protectedStr = "protected";
    //只允许同包访问
    String defaultStr = "default";
    //只允许同类访问
    private String privateStr = "private";
    public void publicMethod() {
        System.out.println("publicMethod");
    }
    protected void protectedMethod() {
        System.out.println("protectedMethod");
    }
    //default 访问权限，在本包范围内使用
    void method() {
        System.out.println("defaultMethod");
    }
    //private权限的方法，只能在本类使用
    private void privateMethod() {
        System.out.println("privateMethod");
    }
    //private权限的内部类，即这是私有的内部类，只能在本类使用
    private class privateMethod {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

注意：
此处的类成员是指类的全局成员，并没有包括局部的成员(局部变量、局部内部类，没有局部内部接口)。或者说，局部成员是没有访问权限控制的，因为局部成员只在其所在的作用域内起作用，不可能被其他类访问到。

  public void count(){
    //局部成员变量
    public int amount;//编译无法通过，不能用public修饰
    int money;//编译通过
    //局部嵌套接口
    class customer{//编译通过
    }
}
1
2
3
4
5
6
7
8

上面的两种场景几乎可以适应所有的情况，但有一些情况比较特殊，还做了些额外访问权限的要求。

3️⃣抽象方法的访问权限
普通方法可以使用四种访问权限，但抽象方法不能用 private 来修饰，即抽象方法不能是私有的。否则，子类就无法继承实现抽象方法。

4️⃣接口成员的访问权限
接口由于其自身特殊性，所有成员的访问权限都规定得死死的。下面是接口成员的访问权限：

变量： public static final
抽象方法： public abstract
静态方法： public static，JDK1.8 后支持
内部类、内部接口 ： public static
也因为所有的一切都默认强制规定好了，所以在用的时候，并不一定需要完整写出所有的修饰符，编译器会帮忙完成。也就是，可以少写修饰符，但不能写错修饰符。

public interface Interface_Test {
    public int aa = 6; //少写了  static final 
    int bb = 5; //
    //嵌套接口，可以不写public static
     interface cc{    
    }
}
1
2
3
4
5
6
7

5️⃣构造器的访问权限，可以是以上四种权限中的任意一种：
①采用 public：对于内外包的所有类都是可访问的。
②采用 protected：就是为了能让所有子类继承这个类，但是外包的非子类不能访问这个类。
③采用包访问控制：比较少用，此类对象只能在本包中使用，但是如果此类有static成员，那么该类还是可以在外包使用(也许可以用于该类的外包单例模式)。
注意：外包的类不能继承该类。
④采用 private：一般是不允许直接构造此类的对象，再结合工厂方法(static方法)，实现单例模式。注意：所有子类都不能继承它。

注意：构造方法有点特殊。因为子类的构造器初始化时，都要调用父类的构造器，所以一旦父类构造器不能被访问，那么子类的构造器调用失败，意味着子类继承父类失败。

三、子类异常、访问权限与父类的关系

子类的对象可以作为父类的对象(引用时是对父类方法的引用，但是传入的对象是子类的对象，即用子类的对象来对父类进行实例化)，但是反过来不行。所以：

1️⃣子类的访问权限一定要比父类大或相等。【子访问权限>父访问权限】

例：
父类A拥有的方法public void setXXX(){}可以被其他任意对象调用。该方法被子类B重写后为void setXXX(){}，即默认的访问权限只能被本包及其子类所访问。假设其它包中的对象C调用方法为：get(A a=new B()){a.setXXX();}。而此时传入的对象为B类对象b，此时b将转型为a，但是b中的setXXX()调用权限已经被缩小了这将造成错误。所以子类的方法的访问权限不能小于父类。

以上只是一个例子还有其他出于易维护、易代码结构设计的设计思想原因。

2️⃣子类重写父类的方法时，抛出的异常大小不能比父类的异常大。【子异常<父异常】