java接口、接口回调、和抽象类的区别

为什么java使用接口：

        有时候必须从几个类中派生出一个子类，继承他们所有的方法，但java不支持多继承而接口可以，为什么类不能实现多继承：因为如果多个父类有同样一个方法，而这个方法有不同的定义那这个子类就不知道实现谁的方法了，但接口的方法即使一样它们也不会产生像类那样的情况，因为它们的方法是没有方法体的

接口的特征：

1.接口用interface修饰

2.接口中所有的成员变量都是public static final修饰的

3.接口中所有的方法默认是public abstract修饰的，所以接口需要被类实现

4.接口中没有构造方法，构造方法用于创建对象（接口没办法new对象）

5.实现接口的类中必须实现接口的所有方法，如果不实现所有的方法那么这个类是抽象类

6.接口和接口可以相互继承，同时可以实现多继承

7.与继承关系类似，接口与实现类之间存在多态性

下面用代码来实现接口的多态：

定义一个Eat接口

public interface Eat {
    public void eat();
}

定义一个Run接口

public interface Run {
    public void run();
} 

定义一个Animal抽象类

public abstract class Animal {
    public abstract void drunk();
    public abstract void sport();
} 

由Cat类来继承animal类和多继承实现eat和run接口

public class Cat extends Animal implements Eat,Run{

	@Override
	public void run() {//实现run方法
		// TODO Auto-generated method stub
		System.out.println("猫在跑");
	}

	@Override
	public void eat() {//实现eat方法
		// TODO Auto-generated method stub
		System.out.println("猫在吃鱼");
	}

	@Override
	public void drunk() {//实现drunk方法
		// TODO Auto-generated method stub
		System.out.println("猫在喝水");
	}

	@Override
	public void sport() {//实现sport方法
		// TODO Auto-generated method stub
		System.out.println("猫在抓老鼠");
	}
	public static void main(String[] args) {
		Cat cat=new Cat();//cat可以使用继承的全部方法
		cat.drunk();
		cat.eat();
		cat.run();
		cat.sport();
		
		Eat eat=new Cat();//多态，Eat接口多态只能使用eat方法它自己的方法
		eat.eat();
		
	}
}

 运行结果如图：

 我们可以看到Cat类实现了多继承，接口也可以产生多态。

接口回调：意思就是先调用后实现，看如下代码：

定义一个Usb接口：

public interface Usb {
    void service();
}

定义一个Computer类 ：

public class Computer {
    Usb usb1;//Usb类型的usb1
    Usb usb2;//Usb类型的usb2
    Usb usb3;//Usb类型的usb3
    public void run() {//定义run方法
        System.out.println("电脑开始工作");
        if(usb1!=null) {
            usb1.service();//调用接口中的方法
        }

         if(usb2!=null) {
            usb2.service();//调用接口中的方法
        }

         if(usb3!=null) {
            usb3.service();//调用接口中的方法
        }
    }
}

定义三个类实现USB接口，代码如下：

public class Shubiao implements Usb{

	@Override
	public void service() {
		// TODO Auto-generated method stub
		System.out.println("鼠标开始工作");
	}

}

public class Jianpan implements Usb{

	@Override
	public void service() {
		// TODO Auto-generated method stub
		System.out.println("键盘开始工作");
	}

}

public class Upan implements Usb{

	@Override
	public void service() {
		// TODO Auto-generated method stub
		System.out.println("U盘开始工作");
	}

}

 要想让它们在usb1、usb2、usb3插入什么就让那个工作起来，我们需要用多态的方式实现，如下

public class Test {
	public static void main(String[] args) {
		Computer computer=new Computer();
//usb1是Usb类型的，通过computer调用usb1来定义对象名，而Upan继承了Usb类，
//所以产生了多态，在run方法里调用时，通过面向对象多态的方式实现了调用service方法
		computer.usb1=new Upan();
		computer.usb2=new Jianpan();
		computer.usb3=new Shubiao();
		computer.run();
	}
}

 结果如下：

在computer类的run方法了先调用了Usb接口里的service方法，而不是先实现Usb接口里的方法，我们通过别的类来实现Usb接口中的service方法，再通过多态的方式让usb1、usb2、usb3来实现各自的方法，这种方式就是接口回调。 

接口和抽象类的区别：

1、接口所有的方法默认是public abstract修饰，所有的方法都是抽象方法，而抽象类里可以有普通方法。（java8之后接口方法可以使用default修饰，默认是public）

2.接口中成员实例都是由final修饰的常量，而抽象类不一定

3.接口可以实现多继承，而抽象类不可以

4.一个类实现接口需要实现它所有的方法，而抽象类里有普通方法的时候不用

5.接口不能用new实例化，但可以声明，声明时必须引用一个实现该接口的对象，也就是以上接口回调中的多态。

抽象类是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为规范。