Java访问修饰符

   本文对java中的修饰符问题做个简单梳理，java中的修饰符包括成员的修饰符、类和接口的修饰符，内部类与外部类的修饰符，以下对上述三个方面分别说明。

   1.成员的访问控制修饰符

   public修饰的成员可以在当前类、子类、同包、其他包中被访问。private修饰的类属性和方法仅在当前类有效，子类重写父类的private修饰的方法是没有意义的，相当于定义一个新方法。以后只要是编写方法，99%的情况下都使用public进行定义。default对于同一个包中的其他类相当于公开（public），它不仅能在设置了该权限的类中访问，也可以在同一包中的类或子类中访问，对于不是同一个包中的其他类相当于私有（private）。protected除了具有default的访问权限外，还可以在不同包中所继承的子类访问，对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。要想更深入地理解这些访问权限，一方面需要明白各自的作用域，另一方面更是要弄清楚各自所体现出来的编程思想，比方说，private表现的封装思想，public表现的面向接口编程的思想等。<!--EndFragment-->

   关于default和protected区别的测试代码

package test1;
public class Car {
String color;
protected int wheels;
}
package test1;
public class Pickup extends Car {
String color = "silver";
protected int wheels = 4;
void print(){
System.out.println(super.color);
System.out.println(super.wheels);
}
}
package test1;
public class TestDemo {
public static void main(String[] args) {
Pickup p = new Pickup();
System.out.println(p.color);
System.out.println(p.wheels);
p.print();
}
}
package test2;
import test1.Car;
public class Pickup extends Car {
void print(){
System.out.println(super.color);//The field Car.color is not visible
System.out.println(super.wheels);
}
}
package test2;

import test1.Pickup;

public class Truck {
 
Pickup p = new Pickup();
 
void print(){
  
System.out.println(p.color);//The field Pickup.color is not visible
  
System.out.println(p.wheels);//The field Pickup.wheels is not visible
 
}
}

   2.类和接口的修饰符

   成员访问控制修饰符中的public和default还可以修饰类，在同一个java文件里，公有类有且仅有一个，并且该文件命名为类名.java。

   abstract和final修饰符只能二选一。

   3.内部类与外部类的修饰符

<!--EndFragment-->

class Outer { //  定义了外部类
private String title = "HELLO WORLD" ;
public void fun() {
new Inner().print() ;
}
class Inner { //  定义内部类
public void print() {
System.out.println(title) ;
}
}
}
public class TestDemo {
public static void main(String args[]) {
Outer out = new Outer() ;
out.fun() ;
}
}

   外部类也可以直接操作内部类中的私有属性。

class Outer { //  定义了外部类
private String title = "HELLO WORLD" ;
class Inner { //  定义内部类
private String msg = " 你好" ;  //  私有属性
public void print() {
System.out.println(Outer.this.title) ;
}
}
public void fun() {
Inner in = new Inner() ;
System.out.println(in.msg) ;//  这是直接访问私有属性
}
}
public class TestDemo {
public static void main(String args[]) {
Outer out = new Outer() ;
out.fun() ;
}
}

   对于内部类而言，也可以使用static关键字进行定义，使用了static定义的内部类严格来讲就变为了一个外部类。

class Outer { //  定义了外部类
private static String info = "Hello " ;
static class Inner {
public void print() {
System.out.println("Hello World .") ;
System.out.println(info) ;
}
}
}
public class TestDemo {
public static void main(String args[]) {
Outer.Inner in = new Outer.Inner() ;
in.print() ;
}
} 

<!--EndFragment-->

   同时需要注意的是，如果此时要想通过内部类访问外部类中的属性，则外部类中的属性一定要使用static定义。

   除了普通类可以定义内部类之外，也可以在抽象类或接口的内部定义内部类、内部抽象类、内部接口等等。特别说明的是：如果在定义内部接口的时候使用了static，那么就表示定义的是外部接口。

interface A {
static interface B {
public void printB() ;
}
}
class X implements A.B {
public void printB() {}
}

   匿名内部类

interface A{
public void fun() ;
}
public class TestDemo{
public static void main(String args[]) {
A a = new A(){
public void fun(){
System.out.println("Hello World .");
}
};//匿名内部类，前面的部分可以认为是父类的引用，后面直接重写父类方法。
a.fun();
}
}

<!--EndFragment-->