linkin大话面向对象--闭包和回调

先来理解2个概念：闭包和回调

什么是闭包？

闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建他的作用域。通过这个定义，可以看出内部类是面向对象的闭包，因为他不仅包含了外部类对象的信息，还自动拥有一个指向外部类对象的引用，在此作用域里，内部类有权操作所有的成员，包括外部类的private修饰的成员。

什么是回调？

回调就是对象携带一些信息，这些信息允许它在稍后的某个时刻调用初始化的对象。说白了就是说：某个方法一旦获得了内部类对象的引用，就可以在合适的时候反过来调用外部类实例的方法。非静态内部类，可以很方便的实现回调。

值得说明的是：内部类最大的作用就是实现了多继承。java是单继承的，使用内部类可以使得编程更加的灵活。

看下面3种情形：

1，必须在同一个类中以某种方式实现2个接口？

public class Linkin implements A,B{

    @Override
    public void testB() {
        
    }

    @Override
    public void testA() {
        
    }
   
}

interface A{
    public void testA();
}

interface B{
    public void testB();
}

上面的情形很简单，但是举一个例子，说这2个方法同名呢？那要怎么办呢？我们可以在实现类里面直接实现那个方法，但是这样子肯定是不好的。一个接口规范了一个功能，怎么好意思讲同一个实现类同一个实现来实现2个不同规范的功能呢？有解决办法：使用内部类。

public class Linkin implements A{

    //定义一个方法，返回一个实现了B的匿名内部类，去实现B
    B makeB(){
        return new B(){

            @Override
            public void test() {
                System.out.println("实现接口B...");
            }
            
        };
    }
    
    //这里是外部类，直接实现了接口A
    @Override
    public void test() {
        System.out.println("实现接口A...");
    }
   
}

interface A{
    public void test();
}

interface B{
    public void test();
}

2，还是上面一样的情形，但是一个是普通的类，一个是抽象类呢？这个时候就只能使用内部类了。

public class Linkin extends A{
    //使用内部类，可以很好实现多继承
    B makeB(){
        return new B(){

            @Override
            public void test() {
                System.out.println("这里来实现下面那个抽象类B的方法。。。");
            }
            
        };
    }
    
   
}

class A{
    public void test(){
        System.out.println("这里是A类的一个方法。。。");
    }
}

abstract class B{
    abstract public void test();
}

3，还是上面的情形，现在一个是普通的类，一个是接口，里面都包含一个同名的方法，要如何实现写一个新的class来实现上面2个功能呢？如何正常一个直接继承，一个实现，代码是这样子的：

public class Linkin extends A implements Binger{
    
    @Override
    public void test(){
        System.out.println("这里是B类的一个方法。。。");
    }
    
    public static void main(String[] args) {
        Linkin linkin = new Linkin();
        linkin.test();
    }
   
}

class A{
    public void test(){
        System.out.println("这里是A类的一个方法。。。");
    }
}

interface Binger{
    //以后再写接口的时候，就不要再罗里吧嗦的写什么public了  默认都是public abstract的
    void test();
}

很明显的不符合需求，那么要怎么办呢？内部类。

public class Linkin extends A {
    
    public Binger getBinger(){
        return new Binger(){

            @Override
            public void test() {
                System.out.println("这里是B接口的实现。。。");
            }
            
        };
    }
    
    public static void main(String[] args) {
        Linkin linkin = new Linkin();
        linkin.test();
        linkin.getBinger().test();
    }
   
}

class A{
    public void test(){
        System.out.println("这里是A类的一个方法。。。");
    }
}

interface Binger{
    //以后再写接口的时候，就不要再罗里吧嗦的写什么public了  默认都是public abstract的
    void test();
}

上面的代码呢？符合需求了，但是如果我想有的时候直接在外部类就使用到binger这个接口里面的那个规范方法呢？有没有稍微高深点的方法呢？回调。

/**
 *
 * @version 1L
 * @author  LinkinPark 
 * @since   2014-11-6
 * @motto   梦似烟花心似水，同学少年不言情
 * @desc    ^现在的代码就有点NB了，我们既可以直接使用外部类2个不同名的方法，来调用A和BInger里面那2个方法，又可以调用一个方法，得到内部类，使用同名的方法
 */
public class Linkin extends A {
    //A类里面的Test方法通过继承得到
    //这里的这个方法其实就是接口Binger的Test实现方法
    public void otherTest(){
        System.out.println("这里是B接口的实现。。。");
    }
    
    private class BingerImpl implements Binger{
        @Override
        public void test() {
            otherTest();
        }
    }
    
    //这里返回上面那个内部类的引用，在以后使用的时候就不用来每次new内部类了
    public Binger getBinger(){
        return new BingerImpl();
    }
    
    public static void main(String[] args) {
        Linkin linkin = new Linkin();
        linkin.test();
        //下面2行代码功能一样
        linkin.otherTest();
        linkin.getBinger().test();
    }
   
}

class A{
    public void test(){
        System.out.println("这里是A类的一个方法。。。");
    }
}

interface Binger{
    //以后再写接口的时候，就不要再罗里吧嗦的写什么public了  默认都是public abstract的
    void test();
}