Java Review (十五、面向对象----内部类)

@

目录

• 成员内部类
• 局部内部类
• 匿名内部类
• 静态内部类

大部分时候，类被定义成一个独立的程序单元。在某些情况下，也会把一个类放在另一个类的内部定义，这个定义在其他类内部的类就被称为内部类(有的地方也叫嵌套类)，包含内部类的类也被称为外部类(有的地方也叫宿主类)。Java从JDK 1.1开始引入内部类，内部类主要有如下作用。

• 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。
• 内部类成员可以直接访问外部类的私有数据，因为内部类被当成其外部类成员，同一个类的成员之间可以互相访问。但外部类不能访问内部类的实现细节，例如内部类的成员变量。
• 匿名内部类适合用于创建那些仅需要一次使用的类。

定义内部类非常简单，只要把一个类放在另一个类内部定义即可——可以在类的任何位置。

成员内部类

成员内部类实例

class Circle {
    private double radius = 0;
    public static int count =1;
    public Circle(double radius) {
        this.radius = radius;
    }
     
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
            System.out.println(count);   //外部类的静态成员
        }
    }
}

类Draw看起来像是类Circle的一个成员，Circle称为外部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。这是因为在非静态内部类对象里， 保存了一个它所寄生的外部类对象的引用。

非静态内部类对象中保留外部类对象的引用内存示意图

不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法

外部类想访问成员内部类的成员是受到限制的。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：
外部类访问内部类成员实例

class Circle {
    private double radius = 0;
 
    public Circle(double radius) {
        this.radius = radius;
        getDrawInstance().drawSahpe();   //必须先创建成员内部类的对象，再进行访问
    }
     
    private Draw getDrawInstance() {
        return new Draw();
    }
     
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
        }
    }
}

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：

创建成员内部类对象实例

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}
 
class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
      
    class Inner {
        public Inner() {
             
        }
    }
}

局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

class People{
    public People() {
         
    }
}
 
class Man{
    public Man(){
         
    }
     
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

局部类不能用 public或 private访问修饰符进行修饰。它的作用域被限定在声明这个局部类的块中。

匿名内部类

将局部内部类的使用再深人一步。 假如只创建这个类的一个对象，就不必命名了。这种类被称为匿名内部类（anonymous inner class)。

匿名内部类实例

public void start(int interval, boolean beep) {

  ActionListener listener = new ActionListener(){
    public void actionPerformed(ActionEvent event) {
    System.out.println("At the tone, the time is " + new  Date())；
   if (beep) Toolkit.getDefaultToolkit().beep(); 
   } 
  }；
  
  Timer t = new Timer(interval, listener);
   t.start()；

 }

在程序中，创建一个实现 ActionListener 接口的类的新对象，需要实现的方法 actionPerformed 定义在括号内。

匿名内部类语法通常如下：

new SuperType(construction parameters) {
  inner class methods and data
}

• SuperType 如果是 ActionListener 这样的接口， 内部类就要实现这个接口。
• SuperType 如果是一个类，内部类就要继承这个类。

关于匿名内部类还有如下两条规则。

• 匿名内部类不能是抽象类，因为系统在创建匿名内部类时，会立即创建匿名内部类的对象。因 此不允许将匿名内部类定义成抽象类。
• 匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类 可以定义初始化块，可以通过实例初始化块来完成构造器需要完成的事情。

静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

静态内部类实例

public class Test {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();
    }
}
 
class Outter {
    public Outter() {
         
    }
     
    static class Inner {
        public Inner() {
             
        }
    }
}

---

参考

【1】：https://www.runoob.com/w3cnote/java-inner-class-intro.html
【2】：《疯狂Java讲义》
【3】：《Java核心技术 卷一》