15-咸鱼学Java-内部类

实例内部类

实例内部类简而言之就是类里面嵌入着类，就像环套环一样
Demo:

class OuterClass2   //外部类
{
    private int a = 1000;

    public OuterClass2()
    {
        System.out.println("OutClass Init");
    }
    public void show()
    {
        System.out.println("OutClass Show");
    }
    /**
     * 1·为什么实例内部类中不能定义一个编译期间可以确定的立即数
     *      ·1static  实例块  
     *      ·2实例内部类的设计意义，必须有一个外部类对象，依赖外部类对象
     *      .3如果拥有static的话就会破坏其结构性
     * 2·实例内部类有没有额外的内存消耗
     *      实例内部类 还可以拥有外层的this
     *      实例内部类和外部类一样其本身都是类一样都会消耗内存，造成额外开销
     */
    class InnerClass2{
        private int a = 10;
        public InnerClass2() {
            System.out.println("InnerClass Init");
        }
        public void show()
        {
            System.out.println(a);
            System.out.println(OuterClass2.this.a);//通过外部类名.this.参数 访问实例数据
        }
        //不能有static方法
        /*public static void sho1w()
        {
        }*/
    }
}

实例内部类的​​new​​必须通过一个外部类的对象进行new。

OuterClass2 i = new OuterClass2();
//  InnerClass2 i2 = new InnerClass2(); erro
    OuterClass2.InnerClass2 i1 = i.new InnerClass2();
    i1.show();

第二行因为没有所可以依赖的对象，所以会报错。
结果

OutClass Init
InnerClass Init
10   //inner.a
1000 //outer.a

因为其实例内部类依赖于对象，所以可以直接访问outer类的实例方法，但是其自身不能拥有static方法已经static变量，因为其一旦有了static方法或者变量，就会破坏外部类的完整性，造成信息泄露。
如

因实例内部类可以直接访问外部类的实例数据
定义一个static方法获取其外部类的private参数，就会破坏其外部类的安全性。
而且通过static还可以直接获取到实例内部类。
如static InnerClass2 a = new InnerClass2();
可以通过外部类.实例内部类.a直接获取实例内部类

静态内部类

静态内部类和实例内部类不同的只是其通过static标志符进行了修饰
Demo:

class OuterClass    //外部类
{
    private int a = 10;
    private static int c = 20;

    public OuterClass()
    {
        System.out.println("OutClass Init");
    }
    public void show()
    {
        System.out.println("OutClass Show");
    }
    static class InnerClass //静态内部类  --->静态成员方法/变量
    {
        private OuterClass outer =null;
        /**
         * 静态内部类怎么访问外部类的实例成员变量
         * 1.因为实例成员变量 依赖外部类对象
         * 2.能否传入一个外部类对象，构造函数 传入
         * 3.主函数 new 外部类
         * 4.构造方法传入
         * 5.接受外部类对象
         * 6.内部类拿到对象
         * 7.输出
         */
        public InnerClass(OuterClass o)         //传入外部类
        {
            outer = o;                          
            System.out.println("InnerClass Init");
        }
        public void show2()
        {
            System.out.println(outer.a);    //不能访问外部类的实例对象，必须通过传入后调用  
            System.out.println(c);          //可以直接访问外部类的静态成员变量
            System.out.println("InnerClass Show");
        }
    }
}

静态内部类​​new​​​的时候必须通过外部类​​.​​内部类来new一个静态内部类。

OuterClass o = new OuterClass();
    OuterClass.InnerClass i = new OuterClass.InnerClass(o);
    i.show2();

运行结果

OutClass Init
InnerClass Init
10  //outer.a
20  //outer.c
InnerClass Show

静态内部类必须依靠于外部类。
可以通过导包的方式跳过外部类.内部类 直接进行new静态内部类。