内部类的定义及使用

/*
    内部类：在类中定义的类
    创建对象格式： 外部类名.内部类名 对象名 = new 外部类名(). new 内部类名();

    成员访问细节：
        1.内部类中，访问外部类成员：直接访问，包括私有
        2.外部类中，访问内部类成员：需要创建对象访问
*/
public class InnerTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        System.out.println(oi.num);
        oi.show();

        System.out.println("-----------------------------------");

        MyOuter.MyInner mm = new MyOuter().new MyInner();
        mm.show();
    }
}

class Outer {
    public void method() {
        System.out.println("method...");
        Inner i = new Inner();
        System.out.println(i.num);//通过创建对象访问
    }


    class Inner {
        int num = 10;

        public void show() {
            System.out.println("show...");
            method();//直接访问
        }
    }
}

class MyOuter{

    int num = 30;

    class MyInner{//成员内部类

        int num = 20;

        public void show(){

            int num = 10;

            System.out.println(num); //10
            System.out.println(this.num);//20
            System.out.println(MyOuter.this.num);//30
        }
    }
}
输出如下：
10
show...
method...
10
-----------------------------------
10
20
30

/*
    静态内部类：static修饰的成员内部类

    创建对象格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

    注意：静态只能访问静态
*/
public class StaticInner {
    public static void main(String[] args) {

        OuterClass.InnerClass oi = new OuterClass.InnerClass();
        oi.show();
        OuterClass.InnerClass.method();
    }
}

class OuterClass {

    int num1 = 10;
    static int num2 = 10;
    static class InnerClass {

        public void show() {
            System.out.println("show...");
            System.out.println(num2);//同为静态可以访问

            OuterClass o = new OuterClass();
            System.out.println(o.num1);//静态类访问非静态变量，所以通过对象访问
        }

        public static void method(){
            System.out.println("method...");
        }
    }
}
输出如下：
show...
10
10
method...

/*
    匿名内部类：

        概述：匿名内部类本质上是一个特殊的局部内部类(定义在方法内部)
        前提：需要存在一个接口或类
        格式：
            new 类名\接口名 () {

            }

            new 类名(){} ： 代表继承这个类
            new 接口名(){} : 代表实现这个接口

        结论：匿名内部类可以让代码更加简洁，在定义类的时候对其进行实例化
             匿名内部类可作为方法的实际参数进行传输
*/
public class AnonInner {
    public static void main(String[] args) {

        //问题：方法的形参是接口类型，我们该传入的是什么？
        //答案：转入该接口的实现类的对象
        useInter(new InterImp());

        useInter(new Inter() {     //匿名内部类
            @Override
            public void show() {
                System.out.println("匿名内部类...show");
            }
        });

    }

    public static void useInter(Inter i){   //Inter i = new InterImp();
        i.show();
    }
}

interface Inter{
    void show();
}

class InterImp implements Inter{

    @Override
    public void show() {
        System.out.println("InterImp...show");
    }
}
输出如下：
InterImp...show
匿名内部类...show