接口回调/抽象类 接口的区别

顶层接口（规范）、抽象类（覆盖部分接口方法（留些抽象方法给抽象类子类去实现））、类 的 3层设计
抽象类主要用于代码复用。

先有接口使用者，再有接口实现

回调原理：

接口调用自己的抽象方法，相当于接口的实现类调用实现类中重写的抽象方法；

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();

        computer.usb1=new Fan();
        computer.usb2=new Upan();
        computer.usb3=new Mouse();

        computer.run();
    }
}
interface USB {
    void service();
}

class Fan implements USB{
    @Override
    public void service() {
        System.out.println("风扇插入USB，开始转起小风。。。");
    }
}
class Mouse implements USB{
    @Override
    public void service() {
        System.out.println("鼠标插到USB，可以点击了。。。");
    }
}
class Upan implements USB{
    @Override
    public void service() {
        System.out.println("U盘插到USB接口，开始拷备文件。。。");
    }
}
class Computer {
    USB usb1;	//接口变量
    USB usb2;
    USB usb3;	

    public void run(){
        System.out.println("电脑开始运行~~~");
        if (usb1!=null){
            usb1.service(); //接口回调，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调
        }
        if (usb2!=null){
            usb2.service();
        }
        if (usb3!=null){
            usb3.service();
        }
    }
}

interface Person{
     String getHand();
}
class LittleLu implements Person{
    private String name="littleLu";
    private String hand="littleLu的手";
    public void washUp(Person person){
        System.out.println(person.getHand()+"洗好了碗");
    }
    @Override
    public String getHand() {
        return hand;
    }
}
public class LittleSong implements Person{
    private String name="littleSong";
    private String hand="littleSong的手";

    @Override
    public String getHand() {
        return hand;
    }
    public static void main(String[] args) {
        LittleLu littleLu=new LittleLu();
        LittleSong littleSong = new LittleSong();
        littleLu.washUp(littleSong);
    }
}
这就是接口回调的核心要义，
你调用我的方法，然后把你传进去，我的方法在那你调用你的方法干事情
你为了保护自己，仅仅把你实现的接口部分传进去，我也只看接口部分的东西

在小宋类里调用小露的方法。方法中又通过接口回调小宋的方法干事。

引用自：https://blog.youkuaiyun.com/qq_37465638/article/details/108806112
两个接口回调案例：先有接口使用者，再有接口实现

interface AcceptListener{
    public void acceptEvent(String result);
}

class Boss implements AcceptListener{
    public void acceptEvent(String result){
        if (result.equals("ok")){
            System.out.println("BOss OK!");
        }else{
            System.out.println("Boss angry!");
        }
    }
}

class Manager implements AcceptListener{
    @Override
    public void acceptEvent(String result) {
        if (result.equals("ok")){
            System.out.println("MANAGER OK!");
        }else{
            System.out.println("MANAGER shout u!");
        }
    }
}

class Employee{
    AcceptListener listener;

    public void setListener(AcceptListener listener) {
        this.listener = listener;
    }

    public void doWork(){
        System.out.println("玩命工作。");
        if (listener!=null){
            listener.acceptEvent("ok");
        }
    }
}


public class Test{
    public static void main(String[] args) {
        Employee employee = new Employee();
        employee.setListener(new Boss());
        employee.doWork();
    }
}

/**
 * 接口的宏观概念: 接口可以作为一种标准
 * 
 * 相当于接口以形参的形式去实现多态
 * 
 * 案例: 电脑连接usb型的U盘,键盘,鼠标,台灯等
 *
 */

class Disk implements USB{
	@Override
	public void run() {
		System.out.println("硬盘在运转");
	}
}

class Mouse implements USB{
	@Override
	public void run() {
		System.out.println("鼠标在运转");
	}
}

//建立了usb的标准
interface USB{
	public void run();  //标准的具体体现
}

class Computer{
	//----------重载: 耦合性太强---------
	/*
	public void connect(Disk disk) {
		disk.run();
	}
	
	public void connect(Mouse mouse) {
		mouse.run();
	}*/
	
	public void connect(USB usb) {
		usb.run();  //接口回调
	}
}

public class Test {
	public static void main(String[] args) {
		Computer computer = new Computer();
		computer.connect(new Disk());  //电脑连接硬盘
		computer.connect(new Mouse()); //电脑连接鼠标
	}
}

接口 ：特殊的抽象类

抽象类与普通类一样，可以有成员变量、成员方法和构造方法，静态变量，方法，代码块等，但是抽象方法，不能有方法体。

相同之外：

不能创建对象，只能通过子类继承/实现来使用。
是引用类型/
可编绎成字节码文件（.class文件）/
都可以声明静态常量，抽象方法/
子类必须重写父抽象方法，除非子类也是抽象的。/
都可以实现多态/

不同之外：

抽象类单继承，接口可多实现/
接口属性默认public final static 修饰的静态常量/
接口方法默认public abstract 修饰/
接口中没有构造方法，动静态代码块，静态方法子类不可继承，却可调用,
抽象类 有构造方法，动静态代码块，静态方法子类 可继承， 可调用,
抽象类简化代码，实现代码复用
接口提高程序可扩展性，可维护性