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

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

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

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){						// 将构造方法设置为 privatethis.name = name;this.age = age;}public static TestClass createObj(String name,int age){		// 将静态方法设置为 publicif(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();									// 10System.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();									// 10System.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 就直接给你报错。