java中的内部类

内部类分类

内部类分为四种：
1:实例内部类:定义在类的内部的一个类
2:静态内部类:定义在类的内部的一个类,但是由static来修饰的
3:匿名内部类
4:本地内部类:方法里面定义的类，没有意义，可以不看

实例内部类

如何实例化内部类对象

方式：
OuterClass.InnerClass innerClass2 = out.new InnerClass();
外部类名.内部类名 变量 = 外部类对象的引用.new 内部类();

代码示例

//实例内部类
class OuterClass {
    public int data1 = 3;
    public static final int data4 = 4;
    //InnerClass就是我们的实例内部类
    class InnerClass {
        public int data3;
        //实例内部类可以书写构造方法
        public InnerClass() {
        }
        /*注意实例内部类内部不能定义静态的成员变量
        例如public static int data = 9;这种就不能定义
        */
        //如果非要定义静态的成员变量,要加上final
        public static final int data5 = 9;
        public void test() {
            System.out.println("InnerClass::test()");
            System.out.println(data3);
            System.out.println(this.data3);
            System.out.println(OuterClass.this.data1);
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        //实例内部类实例化对象的方式
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass innerClass = outer.new InnerClass();

    }
}

注意事项:

1、只要是内部类，那么生成的字节码文件格式：外部类$内部类.class
2、在实例内部类当中，不能定义静态的成员变量！！
如果非要定义，那么一定要是在编译时期确定的值,即常量
其定义方式为public static final
3、先来看一段代码:思考我们的data1最后的输出结果是多少?

class OuterClass {
    public int data1 = 3;
    class InnerClass {
        public int data1 = 10;
        public void test() {
            //最后输出的data1的值为10
            System.out.println(data1);
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        //实例内部类实例化对象的方式
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass innerClass = outer.new InnerClass();
        //结果为10
        innerClass.test();
    }
}

可以看到最后的输出结果为10，所以说当一个类和其内部类声明了相同的一个成员变量的时候，最后输出的成员变量的值一定是这个内部类的这个成员变量的值
但是注意了：此时我们就想用外部类的data1的值，不想用内部类的该怎么办呢?,来看代码：

class OuterClass {
    public int data1 = 3;
    public static final int data2 = 4;
    class InnerClass {
        public int data1 = 10;
        public static final int data4 = 9;
        public InnerClass() {
        }
        public void test() {
            //最后输出的data1的值为3，注意书写方式
            System.out.println(OuterClass.this.data1);
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        //实例内部类实例化对象的方式
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass innerClass = outer.new InnerClass();
        //结果为3
        innerClass.test();
    }
}

总结
格式:System.out.println(OuterClass.this.data1);
可以看到使用外部类名.this.变量名就可以获取到对应的值了
这里就说明一个问题：this实际上也是一个静态的成员
同时也说明实例内部类拥有两个this,一个是实例内部类自己的，一个是外部类的：来看代码:

class OuterClass {
    public int data1 = 3;
    class InnerClass {
        public int data1 = 10;
        public InnerClass() {
        }
        public void test() {
            //此处输出的data1的值为10
            System.out.print(this.data1);
            //最后输出的data1的值为3
            System.out.println(OuterClass.this.data1);
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        //实例内部类实例化对象的方式
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass innerClass = outer.new InnerClass();
        //结果为10,3
        innerClass.test();
    }
}

可以看到我们可以使用this获取到内部类的data1,可以使用外部类名.this获取到外部类中的data1.

所以这里有个面试题：同学，实例内部类，是否有额外的内存开销？？
答：当然有,实例内部类拥有两个this,一个是实例内部类自己的，一个是外部类的

静态内部类

概念

定义在类的内部的一个类。但是由static来修饰的.

如何实例化对象

OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
= new 外部类.静态内部类();
下面来看代码:

class OuterClass {
    public int data1 = 3;

    static class InnerClass {

        public InnerClass() {
        }

        public void test() {
            /*注意此时不能访问外部类中的非静态数据成员
            System.out.print(data1);        
             */
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        //静态内部类实例化对象的方式
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        //结果为10,3
        innerClass.test();
    }
}

总结：
1：静态内部类的实例化方式我已经写在了代码中
2：只要是内部类，此处尽管是静态内部类，那么生成的字节码文件格式仍为：外部类$内部类.class
3：静态内部类当中，是不可以访问外部类的非静态数据成员的！！！！
因为，外部类的非静态数据成员 是依赖于外部类对象的
那么假如面试官非要我们访问的话，该怎么办呢？

思路:给个外部类对象的引用就好了：来看代码：

class OuterClass {
    public int data1 = 3;

    static class InnerClass {
        public OuterClass out;

        //构建一个有参的构造函数
        public InnerClass(OuterClass out) {
            this.out = out;
        }

        public void test() {
            System.out.println(out.data1);
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        //传入一个out变量
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass(out);
        //结果为3
        innerClass.test();
    }
}

匿名内部类

代码示例

/*
匿名内部类
 */
class OuterClass {
    
    public void test() {
        System.out.println("匿名内部类");
    }
}


public class TestMain {
    public static void main(String[] args) {
        new OuterClass(){

        }.test();

    }
}

可以看到直接在主方法main的内部直接new一个类名,这样的写法就叫做匿名内部类，然后如果想要调用OuterClass内的方法,直接在后面.方法名即可.

此时我们也可以重写OuterClass类中的test方法

/*
匿名内部类
 */
class OuterClass {

    public void test() {
        System.out.println("匿名内部类");
    }
}


public class TestMain {
    public static void main(String[] args) {
        new OuterClass(){
            @Override
            public void test() {
                System.out.println("重写我们的匿名内部类");
            }
        }.test();
//重写后的输出结果为:重写我们的匿名内部类
    }
}

注意此处我们在匿名内部类重写了外部类中的test方法，最终的输出结果也一定是重写后的test方法当中的输出结果

匿名内部类的变量捕获

先来看一段代码：

class Test {
    public void func() {
        System.out.println("func()");
    }
}

public class TestMain {
    public static void main(String[] args) {
        int a = 100;
        new Test() {
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("我是捕获到变量 a == " + a + " 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

可以看到我们在匿名内部类的外部有一个变量a，其值为100，这个变量是可以在匿名内部类中是可以被捕获到并且进行输出的，最终输出的值仍为100

假设此时我们想要对这个a重新在内部类中进行赋值输出的话，最后能够成功输出吗？来看代码：

/*
匿名内部类
 */
class Test {
    public void func() {
        System.out.println("func()");
    }
}

public class TestMain {
    public static void main(String[] args) {
        int a = 100;
        new Test() {
            @Override
            public void func() {
                //重新赋值
                a = 50;
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("我是捕获到变量 a == " + a + " 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

此时编译就直接报错啦

总结：
1：在上述代码当中的变量a就是捕获的变量。这个变量要么是被final修饰，是一个常量，不能被修改，要么就不是被final修饰的
2：如果不是被final修饰的你要保证在使用之前，没有修改。即如果上面的代码我要是在匿名内部类外面已经定义了一个变量a的话，在匿名内部类中是不能对这个变量a进行修改的.否则会编译出错.