回调的实现

回调实现：

回调函数实际就是定义一个函数，然后通过参数传递给另一个函数调用。

 

实现方式一：其实现可以通过接口定义抽象方法，在工具类中调用该方法，工具类的构造方法需要传递接口对象参数，在使用工具类时会需要接口对象，匿名内部类实现接口，则会实现接口，当调用工具类中的某个方法时会触发接口的方法。

第一步

public interface Mycaller {
public  void showD();
}

第二步

public class Caller {
public Mycaller caller;
public void setcaller(Mycaller caller){
this.caller=caller;
}
public void show(){
caller.showD();
}
}

第三步

public class FileUse implements Mycaller{
static int hour;
static int minutes;
public static void main(String[] args) {
String nowTime="00:20";
int  i=nowTime.indexOf(":");
hour=Integer.parseInt(nowTime.substring(0,i));
minutes=Integer.parseInt(nowTime.substring(i+1,nowTime.length()));
Caller caller=new Caller();
caller.setcaller(new Mycaller() {

@Override
public void showD() {
System.out.println(hour+"");
System.out.println(minutes+"");
}
});
caller.show();//实现方法1
//实现方法2：继承接口重写方法设置监听，调用方法
}

@Override
public void showD() {
System.out.println(hour+"");
System.out.println(minutes+"");
}

}

 

实现方式二：实现回调也可以在抽象类中写抽象方法，将工具类定义为抽象类，在抽象类中的普通方法中调用该抽象方法，在使用该抽象类初始化时会重写抽象类中的抽象方法，而通过在类中抽象类的匿名内部类对象调用普通方法时会触发抽象方法，会调用我们实例化时重写的方法。

 

    抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类。对象不能由 抽象类直接创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象。在抽象类中的成员方法可以包括一般方法和抽象方法。在抽象类中抽象方法只需要声明而不需要实现。当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的，而这个子类也必须是抽象的。 抽象类中不一定包含抽象方法，但是包含抽象方法的类一定要被声明为抽象类

当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的

实例：

布局

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical" >

 

    <Button

        android:id="@+id/button1"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="one" />

    <Button

        android:id="@+id/button2"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="two" />

    <Button

        android:id="@+id/button3"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="three" />

</LinearLayout>

Activity

public class TestActivity extends Activity implements View.OnClickListener{

Button button1,button2,button3;

MyAbstract myAbstract;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_chouxiang);

button1=(Button) findViewById(R.id.button1);

button2=(Button) findViewById(R.id.button2);

button3=(Button) findViewById(R.id.button3);

button1.setOnClickListener(this);

button2.setOnClickListener(this);

button3.setOnClickListener(this);

myAbstract=new MyAbstract() {

@Override

public void myMethod(int i) {

switch(i){

case R.id.button1:

Toast.makeText(TestActivity.this, "你点击了按钮一", Toast.LENGTH_LONG).show();

break;

case R.id.button2:

Toast.makeText(TestActivity.this, "你点击了按钮二", Toast.LENGTH_LONG).show();

break;

case R.id.button3:

Toast.makeText(TestActivity.this, "你点击了按钮三", Toast.LENGTH_LONG).show();

break;

}

}

};

}

@Override

public void onClick(View v) {

switch(v.getId()){

case R.id.button1:

myAbstract.click(R.id.button1);

break;

case R.id.button2:

myAbstract.click(R.id.button2);

break;

case R.id.button3:

myAbstract.click(R.id.button3);

break;

}

}

}

抽象类：

public abstract class MyAbstract {

public void click(int i){

myMethod(i);

}

public abstract void myMethod(int i);

}

 

MyAbstract myAbstract;//是MyAbstract的匿名内部类对象（里式替换原则），实例化时必须重写抽象方法

在MyAbstract 中有方法调用上面重写的方法。当PrinterSample 中的方法调用时则执行的是上重写的方法中的代码。