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();

}

巴特西

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

最新文章

热门文章