java篇 类的进阶0x06：可见性修饰符（访问修饰符）

可见性修饰符（访问修饰符）

可见性修饰符用在 类、成员方法、构造方法、静态方法、静态变量和成员变量上，其可见性的范围是一样的。

只有 局部变量 和 参数 没有访问控制符。所有可能被分享的，被使用到别的地方的，都可以使用访问修饰符来控制可被访问的程度。

• public： 全局可见，对所有包都可见
• 缺省：当前包可见
• private：当前类可见
• protected【专门为继承打造】：缺省（default）+ 对子类可见

注意：

• private 与 protected 不能用于修饰类与接口。
• 缺省 虽然可以用于修饰类，但是仅仅是对包中的其他类可见，不同的包的类，并不能实现通过 import 来导入这个类，也无法继承这个类。

成员变量都应该是 private

成员变量应该都声明为 private。

• 如果要读写这些成员变量，最好使用 get、set 方法，这些方法应该是 public 的。这样的好处是，如果有需要，可以通过添加一些条件判断的代码，检查每个属性值是否合法。

构造方法可以是 private 的

构造方法如果是 private 的，那么就只有当前的类可以调用这个构造方法。

有些时候，会把所有的构造方法都定义成 private 的，然后使用静态方法调用构造方法（因为该静态方法是 public 的，可以被别的类调用，而该静态方法又和 private的构造方法是同一个类中，可以调用该构造方法，所以就等于通过 public 的静态方法调用了 private 的构造方法）。

• 这样的好处是可以通过代码，检查某个属性值是否合法。等于加了一层过滤，在静态方法中做一些判断，避免直接使用构造方法创建属性是非法的实例。（虽然在构造器中也可以加过滤语句，但实际上调用构造器时，已经在建造实例了，也已经创建出来了，只是在赋值时作过滤，而如果是在静态方法中作过滤，则直接就不会去调用构造器去生成非法实例）

  public class TestClass{
      private TestClass(String name,int age){						// 将构造方法设置为 private
          this.name = name;
          this.age = age;
      }
      public static TestClass createObj(String name,int age){		// 将静态方法设置为 public
          if(age<=0){												// 这样可以加一层过滤，避免传递非法值，构建非法实例
              return null;
          }else{
              // return this(name,age);									// 并不能调用 this()，否则报错，因为 this只能出现在构造器中，并且必须是构造器的第一行代码。这里只是一个静态方法，无法调用this()
              return new TestClass(name,age);
          }
      }
  }
  
  // 调用方
  import com.test.TestClass;
  
  public class TestUse{
      public static void main(String[] args){
          TestClass a = createObj("Tom",13);			// 调用 public 的静态方法来返回一个 TestClass 实例对象
      }
  }
  

public 修饰的东西尽量不要改动

public 的方法类似一种约定，因为 public 就意味着外面的代码可以使用这个方法，也就意味着你不能再对这个方法随意更改，比如不应该更改方法的签名、返回值（但可以优化方法体内的代码逻辑），因为一旦修改，可能外面的代码就可能要跟着修改，否则会出现错误。

所以，尤其是某些 java 的常用类，其中定义的方法会很小心地使用 public。我们知道成员变量都应该定义成 private，然后再用 public 的方法去操作它们。但很多类内部的操作，不需要外部去使用的，也可以定义成 private。定义成 public 的话，你就得保证这个方法，在往后不同的 java 版本中，它的方法签名、返回值不能变，否则就可能出很多问题。

public 方法是我们确定可以长期对外提供功能的。访问修饰符的目的不仅仅是为了限制别人的使用，更加是为了规范地提供一套稳定的方法供别人使用。

而对于 private 的方法，因为类外面调用不到，所以无论怎么改，也不会影响（直接影响）类外面的代码。

非 public 的类，类名可以不和文件名相同

非 public 的类，类名可以不和文件名相同。但因为是非 public，这个类最多就只能被同一个包中的其他类所引用。

疑问1： 一个 java class 文件中是否可以包含多个 class？

经过实验，一个 java class（.java） 文件中是可以同时包含（/定义）多个类的，但只能有一个公共类，并且只要有公共类（public class），这个class 文件的文件名就得和这个公共类名一摸一样（大小写一致），可以有如下两个情况：

• 只有一个公共类：TestClass 文件，包含：class A、class B、public TestClass、class C、…

  • 这种还比较常见，比如说 java 自带的 Math.java 文件，包含了 public class Math，同时还包含了多个非公共类，当然这些类都是相关的，服务于 Math 类的。

• 没有公共类：Test 文件，包含：class A、class B、TestClass、class C、…

疑问2： main 方法只能出现在公共类中么？同一个文件如果可以包含多个类，是否也可以包含多个 main 方法？

经过实验，main 方法既可以出现在公共类（public）中，也可以出现在非公共类中。并且一个 .java文件中可以同时有多个 main 方法，每个类拥有一个 main 方法（哪怕是这个.java 文件同时包含一个公共类与多个非公共类），在 IEDA 中将鼠标定位到哪个类右键，就可以选择执行相应类的 main 方法。

protected 继承专属的访问控制

protected 可见性：default + 对子类可见。

• 即，对同一个包可见，且对子类可见（即便子类不在同一个包）

// org.test.A 包中
public class A{
    protected int age = 10;
    String name = "Tom";
}

// org.test 包中
public class B extends A{						// 多做一层继承，是为了说明 protected 可见的子类是所有子类，而非仅仅是直接子类
    
}

// org.test 包中
public class C extends B{
    public void getAge(){
        System.out.println(this.age);
    }
// 若不注释下面的 getName 方法，编译时会报错，因为找不到 this.name 属性，因为 name 是缺省访问修饰符，只能同一个包中可见。
//    public void getName(){						
//        System.out.println(this.name);
//    }
}


// org.test 包中
// 调用类
public class TestUse{
    public static void main(String[] args){
        C c = new C();
        c.getAge();									// 10
        System.out.println(c.age);					// 报错，因为 TestUse 既不是 A 的子类，也不和 A 在同一个包中，所以无法看到 protected 修复符定义的 .age 属性。
    }
}

// 若将调用类 TestUse 移动到 org.test.A 包中
public class TestUse{
    public static void main(String[] args){
        C c = new C();
        c.getAge();									// 10
        System.out.println(c.age);					// 10
    }
}

子类覆盖父类的方法，不可以用可见性更低的修饰符，但是可以用更高的修饰符。

public > protected > default（缺省） > private

不能用可见性更低的修饰符来覆盖的原因：

public class A{
	protected void sayHi(){
        System.out.println("调用的是 A 的 sayHi");
    }
}
public class B extends A{
	private void sayHi(){
        System.out.println("调用的是 B 的 sayHi");
    }
}
public class TestUse{
    public static void main(String[] args){
        A a = new B();
        a.sayHi();			// 此时因为覆盖，实际调用的应该是 B 中定义的 sayHi。但现在 B 中定义的 sayHi 却是 private，即无法被其他类访问，这就与多态冲突了。
    }
}

既然你覆盖了父类方法，父类的引用在指向你这个对象实例的时候，就要访问你覆盖父类的这个方法，如果你此时访问修饰符让我访问不了，这样就矛盾了。所以你非要用可见性更低的访问修饰符来覆盖，java 就直接给你报错。

所以若用 protected 来修饰方法，则子类若想覆盖该方法需要至少是 protected，或者 public。