Java 内部类

2017-11-04 21:58:46

内部类概述：把类定义在其他类的内部，这个类就叫做内部类。

内部类作用： 1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整

　　　　　　 2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏

　　　　　　 3.方便编写事件驱动程序

　　　　　　 4.方便编写线程代码

　　　　　　 5.内部类的存在使得Java的多继承机制变得更加完善

内部类的访问特点：内部类可以直接访问外部类的成员，包括私有；

　　　　　　　　　外部类要访问内部类的成员必须创建对象；

内部类的分类：成员内部类（成员位置）

　　　　　　   局部内部类（函数内部）

　　　　　　   静态内部类

　　　　　　   匿名内部类

• 成员内部类

访问成员内部类格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象

成员内部类访问修饰符：跟成员变量一样没有作用域修饰符限制（创建依赖于外部类，即在外部类中如果要访问成员内部类成员时，需要先创建外部类对象，通过外部类对象引用来访问内部类对象），创建成员内部类方式：new OutterClass().new InnerClass();

一般需要加上private进行保护，但是这样就不能在外部访问了，但是可以在类内提供一个成员方法进行访问。

class OuterClass{
    private int num = 10;

    class Inner{
        public void show(){
            System.out.println(num);
        }
    }
}

public class InnerClass {
    public static void main(String[] args) {
　　　　 // 创建方法
        OuterClass.Inner inner = new OuterClass().new Inner();
        inner.show();
    }
}

成员内部类重名访问问题的解决：

/**
 * 依次输出30，20，10
 */
class OuterClass{
    private int num = 10;


    class Inner{
        private int num=20;
        public void show(){
            int num=30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(OuterClass.this.num);
        }
    }
}

public class InnerClass {
    public static void main(String[] args) {
        OuterClass.Inner inner = new OuterClass().new Inner();
        inner.show();
    }
}

内部类是很少用来作为继承用的。但是当用来继承的话，要注意两点：

1）成员内部类的引用方式必须为 外部类名.内部类名

2）构造器中必须有指向外部类对象的引用，并通过这个引用调用super()

class WithInner{
    class Inner{}
}
public class InheritInner extends WithInner.Inner{
    InheritInner(WithInner wi){
        wi.super(); //wi的父类是object
    }
    public static void main(String[] args){
        WithInner wi = new WithInner();
        InheritInner ii = new InheritInner(wi);
    }
}

 而进一步，当被继承的内部类只有非默认构造器时应该怎么办呢？

class WithInner{
    class Inner{
        public Inner(int i){
            System.out.println(i);
        }
    }
}
public class InheritInner extends WithInner.Inner{
    InheritInner(WithInner wi){
        int i=0;
        wi.super(i);//如代码所示，当被继承的构造器需要参数时，应把参数传递给这个super函数
    }
    public static void main(String[] args){
        WithInner wi = new WithInner();
        InheritInner ii = new InheritInner(wi);
    }
}

我们可以看出要想创建Inner的对象必须先创建WithInner的对象之后才能创建Inner对象，那么现在你要用一个类InheritInner继承Inner类，在继承过程中构造方法会被调用，即使你不写也会调用默认构造方法，但问题出现了，在调用父类Inner构造方法时找不到WithInner的对象，所以就必须给InheritInner类的构造方法传入WithInner对象再通过wi.super();方法调用Inner的默认构造方法，因为这是创建对象的基本流程，所以这句话wi.super();是必须的。

• 静态内部类

访问成员内部类格式：外部类名.内部类名 对象名 = 外部类名.内部类对象

静态内部类访问修饰符：跟静态变量一样没有作用域修饰符限制，创建静态内部类方式：new OutterClass.InnerClass();

被静态修饰的成员内部类只能访问外部类的静态成员

内部类方法被静态修饰后的方法可以是静态方法，也可以是非静态方法

class OuterClass{
    private static int num = 10;

    static class Inner{
        public void show(){
            System.out.println(num);
        }
    }
}

public class InnerClass {
    public static void main(String[] args) {
        OuterClass.Inner inner = new OuterClass.Inner();
        inner.show();
    }
}

• 局部内部类

局部内部类的访问修饰符：跟局部变量一样不能有作用域修饰符

局部内部类的访问特点：局部内部类可以直接访问外部类的成员

　　　　　　　　　　   在局部位置，可以创建内部类对象，通过对象可以调用内部类的方法，来使用局部类功能

　　　　　　　　　　   局部内部类访问局部变量必须是final修饰的

局部变量使用final修饰的原因：局部变量是随着方法的调用儿调用的，随着调用完毕而消失（所以局部变量不能声明为static）；

　　　　　　　　　　　　　　而堆内存的内容不会立即消失，所以，我们需要加上final修饰符；

　　　　　　　　　　　　　　在加入fianl修饰符后，这个变量就变成了常量，编译器会进行优化，类似于C++里的宏变量，会直接将所有出现这个final的地方用它的值进行简单替换。

class Outer
{
  int num =2;

  public void method()
  {
     final int num2 = 3;
     
     class Inner
    {
       System.out.println(num);
       System.out.println(num2);
    }
  }
}                

• 匿名内部类

匿名内部类：其实就是内部类的简化写法，省略了类名。好处是匿名内部类在使用完后就会被回收。

前提：存在一个类或者接口（这里的类可以是具体类也可以是抽象类）

匿名内部类访问修饰符：无修饰符

匿名内部类的本质：是一个继承了该类或者实现了该接口的实现类的对象

匿名内部类的缺陷：

1）它仅能被使用一次，创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用

2）匿名内部类中是不能定义构造函数的

3）匿名内部类中不能存在任何的静态成员变量和静态方法

4）匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法

5）匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效

匿名内部类的格式：

new 类名或接口名(){
  重写方法；
}

匿名内部类在访问局部变量的时候也需要是final类型，但是，局部内部类和匿名内部类访问的局部变量必须由final修饰，java8开始，可以不加final修饰符，由系统默认添加。java将这个功能称为：Effectively final 功能。

interface Interdemo {
    public void show();
}

class OuterClass {
    public void method() {
        //final int num = 2;
        int num = 2;
        Interdemo interdemo = new Interdemo() {
            @Override
            public void show() {
                System.out.println(num);
            }
        };

        interdemo.show();
    }
}

public class InnerClass {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.method();
    }
}

匿名内部类初始化：

我们一般都是利用构造器来完成某个实例的初始化工作的，但是匿名内部类是没有构造器的！那怎么来初始化匿名内部类呢？使用构造代码块！利用构造代码块能够达到为匿名内部类创建一个构造器的效果。Java中匿名内部类的双括号初始化，形如：

// 新建一个列表并赋初值A、B、C
    ArrayList<String> list = new ArrayList<String>() {{
        add("A");
        add("B");
        add("C");
    }};

// 新建一个Map并给初值
HashMap<Character, Integer> map = new HashMap<Character, Integer>(){
        {
            put('I', 1);
            put('V', 5);
            put('X', 10);
            put('L', 50);
            put('C', 100);
            put('D', 500);
            put('M', 1000);
        }
    };

这种方法被称为双大括号初始化（double brace initialization）或者匿名内部类初始化法，实际上是一种取巧的方式。

这里以ArrayList的例子解释，首先第一层花括号定义了一个继承于ArrayList的匿名内部类 (Anonymous Inner Class)：

// 定义了一个继承于ArrayList的类，它没有名字
new ArrayList<String>(){
  // 在这里对这个类进行具体定义
};

第二层花括号实际上是这个匿名内部类实例初始化块 (Instance Initializer Block)（或称为非静态初始化块）：

new ArrayList<String>(){
  {
    // 这里是实例初始化块，可以直接调用父类的非私有方法或访问非私有成员
  }
};

我们通过new得到这个ArrayList的子类的实例并向上转型为ArrayList的引用：

ArrayList<String> list = new ArrayList<String>() {{}};

• 我们得到的实际上是一个ArrayList的子类的引用，虽然这个子类相比ArrayList并没有任何功能上的改变。
• 可以认为这是个本身装有数据的子类（因为它的数据来自于自身的初始化），而不是取得引用后再赋值。
• 非静态内部类的对象会隐式强引用其外围对象，所以在内部类未释放时，外围对象也不会被释放，从而造成内存泄漏。