内部类,匿名内部类

内部类

内部类： 定义在类的内部，内部类所在的类称之为外部类。

定义格式:

    class 外部类的名{

      class 内部类的名{

       }
    }

案例

public class Demo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.run();//Inner say()-->40
        //Inner say() Outer.this.num-->10

        //创建内部类的对象
        Outer.Inner inner = outer.new Inner();
        inner.say();//Inner say()-->40
        //Inner say() Outer.this.num-->10

        //创建静态成员的内部类对象
        Outer.Inner_2 inner2 = new Outer.Inner_2();
        inner2.say();//inner 2 say()

    }
}

class Outer {
    int num = 10; //外部类的成员变量

    //内部类作为外问部的成员，如果要访问内部类，需要通过类的对象访问
    class Inner {
        public static final int IP = 100;

        int num = 40;

        public void say() {

            System.out.println("Inner say()-->" + num);

            System.out.println("Inner say() Outer.this.num-->" + Outer.this.num);//在内部类中可以访问其所在外部类的成员
        }
    }

    public void run() {
        Inner inner = new Inner();
        inner.say();
    }

    //外部类的静态成员
    static class Inner_2 {

        public static void say() {
            System.out.println("inner 2 say()");
            //System.out.println("inner 2 say()"+num);//出错：静态内部类不能访问外部类的非静态成员
        }
    }
}

匿名内部类

定义在类的成员方法中的内部类。

案例

public class Demo {

    public static void main(String[] args) {
        Outer1 outer = new Outer1();
        outer.fun();//fun->Inner say()100
    }
}

class Outer1 {

    public void fun() {
        final int num = 100; //注：在jdk 1.8之后，局部内部类访问的局部变量是有效的

        //声明局部内部类
        class Inner {
            public void say() {
                //局部内部类中，如果要访问局变量时，则局部变量需要final修饰
                System.out.println("fun->Inner say()" + num);
            }
        }

        Inner inner = new Inner();
        inner.say();

    }

}

匿名内部类实现接口

/**
 * 匿名内部类实现接口
 * 使用场景:你叫舍友给你收一下衣服，收完之后给你说一声；
 * 建模: CallBack(收完衣服的结果) Sheyou(舍友)  You(你)
 * 接口回调
 */
public class Demo3 {
    public static void main(String[] args) {
        You you = new You();//创建一个你
        Sheyou leifeng = new Sheyou("雷锋");  //创建一个雷锋同学
        you.requestShouyifu(leifeng);//委托雷锋舍友收衣服
    }
}


interface CallBack {
    void result(String msg);
}

class You  {
    /**
     * 请求舍友帮你收衣服(客气点)
     *
     * @param sheyou
     */
    public void requestShouyifu(Sheyou sheyou) {
        System.out.println(sheyou.name + "请帮我收一下衣服，要下雨了");
        sheyou.shouyifu(new CallBack() {
            @Override
            public void result(String msg) {
                System.out.println("我知道" + msg);
            }
        });
    }

}

class Sheyou {
    String name;

    public Sheyou(String name) {
        this.name = name;
    }

    //收衣服
    public void shouyifu(CallBack callBack) {
        System.out.println(this.name + "收衣服中...");
        callBack.result("衣服已经收好了。" + "\t" + this.name + "收的.");
    }
}

运行结果

静态内部类(Static Nested Class)和内部类（Inner Class）的区别?

静态内部类是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

下面的代码哪些地方会产生编译错误？

class Outer {

    class Inner {}

    public static void foo() { new Inner(); }

    public void bar() { new Inner(); }

    public static void main(String[] args) {
        new Inner();
    }
}

Java中非静态内部类对象的创建要依赖其外部类对象，上面的面试题中foo和main方法都是静态方法，静态方法中没有this，也就是说没有所谓的外部类对象，因此无法创建内部类对象。正确的姿势:

    new Outer().new Inner();

Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？

可以继承其他类或实现其他接口

内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制？

一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员