学习JAVA回调方法（一）

首先扯点别的：7月4号第一天上班。公司是上海迅傲信息科技。现在正是提高自己的大好时机，克服当前的困难就是提升，坚持!!!

今天记录的是： java回调函数。为了以后不用再去找，也为了自已以后提高。

回调的目的： 回调的目的是在代码的行为上提供更大的灵活性。例如我现在想写一个通用的排序方法，既能排字符串，还能排int型的整数，这个咋整？

解决方法

1. 为每一种排序写一个方法，就是不通用呗，比如说我想排字符串，就写个方法叫sortString，想排int型数据就写一个sortInt。这样不大好吧。

2. 使用回调机制。

3. 别的方法就靠自己发挥了。

接下来就讲一讲回调机制。
第一，在java中实现回调，你首先得有接口才行。

/**
 * 通用比较接口
 *
 */
public interface MyCompare {

    //小于
    boolean lessThan(Object lhs,Object rhs);
    //小于或者等于
    boolean lessThanOrEqual(Object lhs,Object rhs);

}

第二，调用方要预留回调函数接口（下面的排序类就是调用方，用来对不同类型的数据进行排序，方法的细节不必在意，就是一个快速排序，我也不大懂，这是Think in java书中的一个方法，我只是粘贴过来而已）

import java.util.Vector;

/**
 * 排序类
 *
 */
public class SortVector extends Vector {

    private MyCompare compare;

//构造函数中的参数就是预留的回调接口，你必须把被调用方传过来
    public SortVector(MyCompare comp) {
        this.compare = comp;
    }

    public void sort() {
        quickSort(0, size() - 1);
    }

    /**
     * 
     * @param left
     * @param right
     */
    private void quickSort(int left, int right) {
        if (right > left) {
            Object o1 = elementAt(right);
            int i = left - 1;
            int j = right;
            while (true) {
        //这里执行的是被调用方的方法（方法具体的实现是被调用方实现的）
                while (compare.lessThan(elementAt(++i), o1))
                    ;
                while (j > 0)
            //这里执行的是被调用方的方法（方法具体的实现细节是被调用方实现的）
                    if (compare.lessThanOrEqual(elementAt(--j), o1))
                        break; // out of while
                if (i >= j)
                    break;
                swap(i, j);
            }
            swap(i, right);
            quickSort(left, i - 1);
            quickSort(i + 1, right);
        }
    }

    /**
     * 交换
     * @param loc1
     * @param loc2
     */
    private void swap(int loc1, int loc2) {
        Object tmp = elementAt(loc1);
        setElementAt(elementAt(loc2), loc1);
        setElementAt(tmp, loc2);
    }
}

第三：被调用方要实现接口

/**
 * 比较String，具有自己的比较方法
 * @author lenovo
 *
 */
public class MyStringComp implements MyCompare{

    @Override
    public boolean lessThan(Object lhs, Object rhs) {
        return ((String)lhs).compareTo(((String)rhs))<0;
    }

    @Override
    public boolean lessThanOrEqual(Object lhs, Object rhs) {
        return ((String)lhs).compareTo(((String)rhs))<=0;
    }

}

/**
 * 进行整数比较
 *
 */
public class MyIntegerComp implements MyCompare{

    @Override
    public boolean lessThan(Object lhs, Object rhs) {
        return ((int)lhs)<((int)rhs);
    }

    @Override
    public boolean lessThanOrEqual(Object lhs, Object rhs) {
        return ((int)lhs)<=((int)rhs);
    }

}

上面的MyStringComp类和MyIntegerComp都实现了相同的MyCompare接口，并实现了lessThan和lessThanOrEqual方法，但是他们的逻辑显然不一样。

下面编写一个测试方法

import java.util.Enumeration;


public class Test {

    public static void main(String[] args) {

        //现在比较String
        MyStringComp stringComp=new MyStringComp();
        SortVector sv=new SortVector(stringComp);
        sv.addElement("d");
        sv.addElement("A");
        sv.addElement("C");
        sv.addElement("c");
        sv.addElement("Abcdd");
        sv.addElement("B");
        sv.addElement("D");
        sv.addElement("a");
        sv.sort();
        Enumeration e = sv.elements();
        while(e.hasMoreElements())
        System.out.println(e.nextElement());
        //现在比较int

        MyIntegerComp integerComp=new MyIntegerComp();
        SortVector intSv=new SortVector(integerComp);
        intSv.addElement(6);
        intSv.addElement(0);
        intSv.addElement(-9);
        intSv.addElement(88);
        intSv.addElement(88);
        intSv.addElement(5);
        intSv.sort();
        Enumeration intElement = intSv.elements();
        while(intElement.hasMoreElements())
        System.out.println(intElement.nextElement());
    }
}

当比较字符串的时候传过来的被调用方是一个MyStringComp类型的对象

MyStringComp stringComp=new MyStringComp();
        SortVector sv=new SortVector(stringComp);
        sv.sort();

调用sort()方法的时候，会调用quickSort（），看一看quickSort()方法中的

while (compare.lessThan(elementAt(++i), o1));
                while (j > 0)
                    if (compare.lessThanOrEqual(elementAt(--j), o1))
                        break; // out of while

lessThan和lessThanOrEqual方法其实就是调用MyStringComp 中的方法

当比较int类型的数据时，传过来的是一个MyIntComp类型的对象，lessThan和lessThanOrEqual方法其实就是调用MyIntComp类中的方法

综上，为什么叫回调方法呢，因为调用方SortVector对象在其方法内部quickSort()中调用了被调用方（可能是MyStringComp类型的对象也可能是MyIntComp类型的对象）中的方法。

结尾：对于回调方法我也不是了解的很透彻，如果文中有错误欢迎指正，感激不尽。