总结：内部类与泛型

内部类

实例内部类

class OuterClass {
    public int data1 = 10;
    public static int data2 = 20;

    /*
     * 实例内部类---问题：
     * 1.如何拿到实体内部类的对象？
     * 2.在实例内部类当中，是否可以定义static的数据成员？
     *   可以，必须用static final修饰 -》必须是在编译时期确定的！
     * 3.内部类可以访问外部类的所有数据成员，包括私有的。
     * 4.实例内部类是否有额外的开销？包含了外部类的this。
     * 5.InnerClass是OuterClass 的 成员。
     * 6.OuterClass.this->拿到外部类的对象的引用。*/
    class InnerClass {
        public int data3 = 100;
        public static final int data4 = 200;
        public int data1 = 10000;

        public InnerClass() {
        }

        public void func() {
            System.out.println("InnerClass::func()");
            System.out.println("data1: " + this.data1);
            System.out.println("data2: " + data2);
            System.out.println("data3: " + data3);
            System.out.println("data4: " + data4);
            //实例内部类包含了外部类的this
            System.out.println("Outerdata1: " + OuterClass.this.data1);
        }
    }
}

public class InnerClassTest {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        /*访问(拿到)实例内部类的对象：
         * 外部类名.实例内部类名  变量名称 = 外部类对象的引用.new 内部类对象*/
        OuterClass.InnerClass in = outerClass.new InnerClass();
        in.func();
    }
}

静态内部类

class OuterClass2 {
    public int data1 = 16;
    public static int data2 = 18;

    /**
     * 静态内部类-》static
     * 1.如何拿到静态内部类的实例对象？--将静态内部类看成外部类的静态成员.
     */
    static class InnerClass2 {
        public int data3 = 100;
        public static final int data4 = 200;
        public int data1 = 300;
        public OuterClass2 o = null;

        public InnerClass2() {
        }

        public InnerClass2(OuterClass2 out) {
            this.o = out;
        }

        public void func() {
            System.out.println("InnerClass2::func()");
            System.out.println("data3:" + data3);//100
            System.out.println("data4:" + data4);//200
            System.out.println("data1:" + data1);//300
            System.out.println("data2:" + data2);//18
            System.out.println("out-data1:" + OuterClass2.data2);//16
            //问题：静态内部类能否访问外部类的实例成员，不能直接访问;
            //System.out.println("outdata1: "+ OuterClass2.this.data1);---error
            /*间接访问的步骤：
             * 1. public InnerClass2(OuterClass2 out) {
             *    this.o = out;}
             * 2. public OuterClass2 o = null;
             * 3.OuterClass2 outerClass2 = new OuterClass2();
             *   OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2(outerClass2);
             * 4.System.out.println("out2-data1:" + o.data1);*/
            System.out.println("out2-data1:" + o.data1);//16
        }
    }

}

public class StaticInnerClass {
    public static void main(String[] args) {
        OuterClass2 outerClass2 = new OuterClass2();
        /*访问静态内部类对象：
         *外部类名.静态内部类名  in = new 外部类类名.内部类();*/
        OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2(outerClass2);
        innerClass2.func();
        int ret = OuterClass2.InnerClass2.data4;
//        System.out.println(ret);//200
    }
}

匿名内部

//new MyThread();//匿名对象
        /**
         * 匿名内部类-》MyThread的一个子类
         */
        new MyThread(){
            @Override
            public void func() {
                //super.func();
                System.out.println("inner::MyThread::func()");
            }
        }.func();

泛型

1.泛型：MyArrayList:他只是一个占位符；
证明当前的类是一个泛型类。
2.泛型注意事项
（1） 坑1：泛型是不能够new 泛型数组的 T[] a = new T[];—ERROR
（2）坑2：泛型的参数必须是引用类型，不能是内置类型(简单类型)
3.泛型的意义：
（1）a:可以进行自动类型检查。
（2）b:可以自动进行类型转换。
4.泛型到底是怎么编译的？
类型的擦除机制；擦成了Object类型，并不是替换。
5.泛型参数是不参与类型的组成的。