22java的回调&内部类

回调（callback，Hook)

回调（callback），又叫钩子（hook），模板方法模式。

在程序中某个位置设定一个钩子（hook），这个钩子具体怎么运行不确定，具体传递哪个对象就调用哪个对象的方法，实现代码的分离。实质上就是多态。

下面看程序实例：

package oop.OopDemo.CallBack;

public class MyCallback {
    public static void drawFrame(IMyFrame frame) {
        System.out.println("启动线程");//这是实例，实际开发时除了frame.print()函数（举例）处均是固定的，
        System.out.println("增加循环");//frame.print()函数具体执行哪个对象还要看传递的是哪个对象，实质上就是多态
        System.out.println("查看消息线");
        //画窗口
        frame.print();
        System.out.println("启动缓存，增加效率");
    }

    public static void main(String[] args) {
        drawFrame(new GameFrame());
//        drawFrame(new WorkFrame());//需要这个类implements IMyFrame
    }
}

class GameFrame implements IMyFrame{//实现（implements）这个接口的所有抽象方法
    @Override
    public void print() {
        System.out.println("This is a GameFrame");
    }
}

class WorkFrame extends MyFrame{//继承这个父类，这里为了测试，当然也可以implements IMyFrame
    @Override
    public void print() {
        System.out.println("This is a WorkFrame");
    }
}

package oop.OopDemo.CallBack;

public class MyFrame {
    public void print() {
        System.out.println("把自己的窗口画出来");
    }
}

interface IMyFrame {//定义一个接口，除了接口还能使用抽象类
     void print();
}

运行结果：

很明显，这就是多态的一个运用。

---

内部类

01.非静态内部类

程序实例：

package oop.OopDemo.InnerClass;

public class TestInnerClass {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();//非静态内部类依托于外部类，创建一个非静态内部类的对象，
        //注意：此处需要借助外部类进行，创建非静态内部类的对象
        inner.show();//访问内部类的方法
        Outer outer1 = new Outer();//创建一个外部类的对象
        outer1.testOuter();//访问外部类的方法
    }

}

class Outer {//外部类
    private int num = 1;
    public void testOuter() {
        System.out.println("testOuter");
//        System.out.println(age);//不能访问内部类的属性
    }

    class Inner {//非静态内部类（成员内部类）
        int age = 2;
        public void show() {
            String str = "java";
            System.out.println("访问外部类的属性：" + Outer.this.num);
            System.out.println("访问内部类的属性：" + this.age);
            System.out.println("局部变量：" + str);
        }
    }
}

运行结果：

静态内部类

package oop.OopDemo.InnerClass;

public class TeatStaticInnerClass {
    public static void main(String[] args) {
        Outer2.Inner2 inner2 = new Outer2.Inner2();
        inner2.print();
        Outer2 outer2 = new Outer2();
        outer2.Outerprint();
    }

}

class Outer2 {
    public int a = 2;

    public void Outerprint() {
        System.out.println("Print Outer2");
    }

    static class Inner2 {
        public void print() {
            //Outer2.Outerprint();//Non-static method 'Outerprint()' cannot be referenced from a 
                                  //static context
            System.out.println("Print static Inner2");
        }
    }
}

运行结果：

---

匿名内部类

package oop.OopDemo.InnerClass;

public class AnnoyInnerClass {//public修饰的类必须和.java文件名相同
    public static void test(AnnoyClass annoyClass) {
        System.out.println("===========");
        annoyClass.testAnnoyClass();
    }

    public static void main(String[] args) {
        test(new AnnoyClass() {
            @Override
            public void testAnnoyClass() {
                System.out.println("testAnnoyClass");
            }
        });//匿名内部类的实现，只被调用一次
    }
}

interface AnnoyClass {
    void testAnnoyClass();
}

运行结果：

---

局部内部类