Java内部类

Java内部类分类

1. 成员内部类

相当于成员，和成员定义位置相同

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

class Outter {
    private int count = 10;
    private int outterCount = 10;
    private Inner inner = null;

    public Outter() {

    }

    public Inner getInnerInstance() {
        if (inner == null)
            inner = new Inner();
        System.out.println(inner.count);
        return inner;
    }

    class Inner {
        private int count = 20;

        public Inner() {

        }

        public void showInfo() {
            System.out.println(count);
            System.out.println(outterCount);
        }
    }
}

1. 成员内部类由于包含外部类实例，故可访问外部类成员和方法即使是私有
2. 当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员,需要Outter.this.xxx
3. 外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问,可以访问私有变量和方法
4. 成员内部类是外部类成员，故要创建成员内部类的对象，前提是必须存在一个外部类的对象。有如下两种创建方式：

//第一种方式：
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
//第二种方式：
Outter.Inner inner1 = outter.getInnerInstance();

5. 外部类只能被public和包访问两种权限修饰，但成员内部类拥有成员的修饰符特性，有4种 public,private,protected,默认

2. 局部内部类

相当于局部变量，定义位置和局部变量位置相同，定义在作用域(方法或者代码块内)

class Outter {
    public void method() {
        final int count = 20;
        class LocalInner {
            public void method() {
                System.out.println(count);
            }
        }
        new LocalInner().method();
    }

}

1. 和局部变量一样不能使用任何的访问修饰符。
2. 会生成两个.class文件，一个是Outter.class ，另一个是Outter$LocalInner.class。
3. 局部内部类只能访问方法中声明的final类型的变量。
4. 我们是无法在外部去创建局部内部类的实例对象的，因为局部内部类是定义在方法中的，而方法是需要所在类的对象去调用。

局部内部类在实际开发中用的并不多，不是很常见的，了解一下就好了。

3. 静态内部类

class Outter {
    private static int a = 20;

    public Outter() {

    }

    static class Inner {
        public Inner() {
            System.out.println(a);
        }
    }
}

1. 静态内部类就是一个普通类，只是位置在另一个类的内部，并不持有外围类的引用
2. 只能访问外部类的静态成员变量或者静态方法
3. 会生成两个.class文件，一个是外部的类Outter.class ， 另一个是 Outter$Inner.class

4. 匿名内部类

• 本质：匿名内部类会隐式的继承一个类或者实现一个接口，或者说，匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象。
• 格式:

new 类名/接口/抽象类(){

}

例如：

new Interface(){

}

• 实例：

public class Test {
    public static void main(String[] args) {
        // 匿名内部类1 如果Air是类，则根据参数使用对应构造方法
        Air air = new Air("rocket") {
            @Override
            void fly() {
                System.out.println("fly");
            }
        };
        air.fly();

        // 匿名内部类2 该匿名类使用类的默认构造方法也就是空构造方法
        Fly fly = new Fly() {
            @Override
            public void fly() {
                System.out.println("fly");
            }
        };
        fly.fly();
    }
}

abstract class Air {
    public Air(String s) {
        System.out.println(s);
    }

    abstract void fly();
}

interface Fly {
    void fly();
}

输出

rocket
fly
fly

编译代码后匿名内部类1会生成Test$1.class, 反编译该字节码得到

static class Test$1 extends Air
{

    void fly()
    {
        System.out.println("fly");
    }

    Test$1(String s)
    {
        super(s);
    }
}

自动生成了带参数的构造方法，并调用了父类的同参数的构造方法

• 特性

1. 匿名内部类由于没有名字，故无法定义构造方法,但编译后会生成构造方法根据传入的参数
2. 匿名内部类编译后生成的.class文件的命名方式是”外部类名称$编号.class”，编号为1，2，3…n，编号为x的文件对应的就是第x个匿名类
3. 匿名内部类

为什么需要内部类

1. 可以弥补没有多继承的缺陷

public class Test {
    public static void main(String[] args) {
        Swan swan = new Swan();
        swan.fly();
        swan.swim();
    }
}

abstract class FlyingAnimal {
    abstract void fly();
}

abstract class SwimmingAnimal {
    abstract void swim();
}

class Swan extends FlyingAnimal {

    @Override
    void fly() {
        System.out.println("Swan.fly()");
    }

    void swim() {
        this.getSwimming().swim();
    }

    SwimmingAnimal getSwimming() {
        return new SwimmingAnimal() {

            @Override
            void swim() {
                System.out.println("Swan.swim()");
            }

        };
    }
}

Swan继承了FlyingAnimal，无法再继承SwimmingAnimal，此时可通过如上匿名内部类方式解决问题

但是，这种设计方式，有明显的缺陷。因为，Swan类本身只继承了FlyingAnimal类，所以它和FlyingAnimal是is - a的关系，它和SwimmingAnimal并没有继承关系，所以并不是is-a的关系，其实更像一种has - a的关系。所以，这并不符合常理。

2. 解决命令冲突(例如抽象类的方法和接口中的方法同名)
3. 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏

内部类问题

1. 局部内部类访问局部变量，该变量必须声明为final类型 ，但如何又可以改变该变量

解决办法:
将该变量可以生命为数组类型
eg:

final int[] counter = new int[1];

这样可以使counter中的内容发生改变

参考

http://www.cnblogs.com/dolphin0520/p/3811445.html