Java 内部类

内部类

1为甚么需要内部类

一般来说，内部类继承自某个类或者实现某个接口，内部类的代码操作创建它的外围类的对象，可以认为内部类提供了某种进入其外围类的途径。 
内部类还有其他特性： 
1，内部类可以有多个实例，每个实例都有自己的状态信息，并且与外围类对象的信息相互独立。 
2，在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。 
3，创建内部类时，并不依赖于外部类对象的创建。 
4，内部类是一个独立的实体。

2内部类标识符

由于每个类都会产生一个.class文件，其中包含了如何创建该类型对象的全部信息（此信息产生一个“meta-ckass”，叫做Class对象）。内部类也必须生成一个.class文件以包含它们的Class对象信息。

这些类文件的命名规则：外围类的名字，加上“$”，再加上内部类的名字。如果是匿名类，则会加上一个数字作为标识符。

Outer.class          //外部类 Outer
Outer$1.class        //匿名类 
Outer$Inner.class    //内部类 Inner
Outer$1Inner2.class  //方法里的内部类 Inner2

内部类使用

1，创建内部类

public class Outer {
    class Inner implements PlaceHolder {}       
}

2，方法内部可以创建内部类or匿名内部类

public class Outer {
    //在方法内部也可以包含内部类
    public PlaceHolder innermethod() {
        class Inner2 implements PlaceHolder {
            @Override
            public void next() {
                i++;
            }
        }

        return new Inner2();
    }

    //在方法内部定义匿名类
    public PlaceHolder anonymousinner() {
        return new PlaceHolder(){
            @Override
            public void next() {
                i++;
            }
        };
    }

3，内部类向上转型，可以隐藏实现细节

public static void main(String[] args) {
    Outer out = new Outer(10);
    // 使用内部类的接口向上转型，可以隐藏实现细节
    PlaceHolder holder = out.inner();
    while(!holder.end()) {
        System.out.println(holder.current());
        holder.next();
    }
}

代码

接口定义

public interface PlaceHolder {

    public abstract boolean end();
    public abstract Object current();
    public abstract void next();
}

外部类和内部类定义代码

public class Outer {

    private Object[] items;

    public Outer(int size) {
        items = new Object[size];
    }
    //1.1,典型情况会有一个方法返回内部类的引用
    public PlaceHolder inner() {
        return new Inner();
    }
    //1.0,创建内部类
    class Inner implements PlaceHolder {

        private int i=0;

        @Override
        public boolean end() {
            //1.2,内部类可以链接到外部
            return i == items.length;
        }

        @Override
        public Object current() {
            return items[i];
        }

        @Override
        public void next() {
            i++;
        }

        public Outer getOuter(){
            //1.3,内部类可以通过 类名.this获得外部引用
            return Outer.this;
        }
    }

    //2.1,在方法内部也可以包含内部类
    public PlaceHolder innermethod() {

        class Inner2 implements PlaceHolder {   
            private int i=0;

            @Override
            public boolean end() {
                return i == items.length; 
            }

            @Override
            public Object current() {
                return items[i];
            }

            @Override
            public void next() {
                i++;
            }
        }

        return new Inner2();
    }

    //2.2,在方法内部定义匿名类
    public PlaceHolder anonymousinner() {
        return new PlaceHolder(){

            private int i=0;

            @Override
            public boolean end() {
                return i == items.length;
            }

            @Override
            public Object current() {
                return items[i];
            }

            @Override
            public void next() {
                i++;
            }
        };
    }

    public static void main(String[] args) {
        Outer out = new Outer(10);
        // 3,使用内部类的接口向上转型，可以隐藏实现细节
        PlaceHolder holder = out.inner();
        while(!holder.end()) {
            System.out.println(holder.current());
            holder.next();
        }

        holder = out.innermethod();
        while(!holder.end()) {
            System.out.println(holder.current());
            holder.next();
        }


        holder = out.anonymousinner();
        while(!holder.end()) {
            System.out.println(holder.current());
            holder.next();
        }
    }

}