[Java SE] 抽象类与接口（二）：接口（下）

2.5 实现多个接口

在Java语言中，类和类之间是单继承关系，一个类只可以有一个父类，即Java中不支持多继承关系，但是一个类可以实现多个接口，下面通过Animal类来具体说明

class Animal {
	protected String name;
	public Animal(String name) {
		this.name = name;
	}
}

另外我们再提供一组接口，分别表示这个动物会跑，会游泳，会飞

interface IFlying {
	void fly();
}
interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}

接下来是具体的动物类，比如青蛙是两栖动物，既会跑，有会游泳

class Frog extends Animal implements IRunning, ISwimming {//可以实现多个接口
	public Frog(String name) {
		super(name);
	}
@Override
	public void run() {
		System.out.println(this.name + "正在往前跳");
	}
@Override
	public void swim() {
		System.out.println(this.name + "正在蹬腿游泳");
	}
}

注意：在一个类实现多接口的时候，每一个接口的方法都必须被重写，我们在idea编译器中，可以使用Ctrl+i快速实现接口

再比如鸭子，既会跑，又会游泳，又会飞

class Duck extends Animal implements IRunning, ISwimming, IFlying {
	public Duck(String name) {
		super(name);
	}
@Override
	public void fly() {
		System.out.println(this.name + "正在用翅膀飞");
	}
@Override
	public void run() {
		System.out.println(this.name + "正在用两条腿跑");
	}
@Override
	public void swim() {
		System.out.println(this.name + "正在漂在水上");
	}
}

上面展示了Java中面相对象中最常见的一种用法：一个类继承一个父类，同时实现多个接口
继承表达的含义是is a，即一个类属于什么大类，接口则表示的是can xxx，即一个类具有什么样的特性或能力
这样设计的好处在哪里呢？时刻牢记多态的好处，它可以让程序员忘记类型，有了接口之后，就不必关心具体的类型，而是关注某个类是否具有某种能力

面试题：什么时候会发生多态

在不同类继承一个父类，并且重写了父类中的方法，并且通过父类引用创建的子类对象调用了重写的方法，此时会发生动态绑定并发生向上转型，此时就会发生多态

只要这个类的东西具有某种能力，就可以实现一个接口，比如实现上述接口的类不一定必须是动物类，还可以是其他类，比如机器人也会跑

class Robot implements IRunning {
	private String name;
	public Robot(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		System.out.println(this.name + "正在用轮子跑");
	}
}

2.6 接口之间的继承

在Java中，类和类之间是单继承关系，一个类可以实现多个接口，接口与接口之间可以多继承，即接口可以达到多继承的目的
接口可以继承一个接口，达到复用的效果，使用extends关键字

interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {

}
class Frog implements IAmphibious {

}

通过一个创建一个新接口IAmphibious，并继承了IRunning, ISwimming，来达到合并两个接口的目的，在Frog类中，还需要继续重写run方法和swim方法

2.7 接口的经典使用案例

1. 给对象数组排序
   如果我们有一个数组，这个数组中的数据类型是学生类

public class Student {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Student[] student = new Student[]{
                new Student("zhangsan",95),
                new Student("lisi",89),
                new Student("wangwu",88),
                new Student("zhaoliu",98),
        };
        }
    }

比如我们在这里要对这个数组中的学生按照成绩进行排序，数组中我们有sort方法，能否直接使用这个方法呢？

在这里我们可以看出，编译器在这个地方抛出了异常，为什么呢，是因为一个数组中的对象有两个成员，一个是姓名，一个是成绩，编译器并不知道你要通过哪个成员来比较对象，所以我们这里引入了Comparable接口，通过重写该接口中的compareTo方法来实现对象的比较

public class Student implements Comparable {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Object o) {//重写compareTo方法
        Student s = (Student) o;//object类强转为Student类
        if (this.score > s.score){
            return -1;
        }else if (this.score<s.score){
            return 1;
        }else {
            return 0; 
        }
    }
}

在sort方法中，会自动调用重写的compareTo方法
然后比较当前对象和参数对象的大小关系(按分数来算).
如果当前对象应排在参数对象之前, 返回小于 0 的数字;
如果当前对象应排在参数对象之后, 返回大于 0 的数字;
如果当前对象和参数对象不分先后, 返回 0;
之后的运行就符合预期了

注意事项: 对于 sort 方法来说, 需要传入的数组的每个对象都是 “可比较” 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则.

在这里我们给出几种更加灵活的方法，利用比较器，即实现Compartor接口

public class nameCompare implements Comparator<Student> {//比较什么，尖括号里就写什么
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class sorceCompare implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        if (o1.score > o2.score){
            return -1;
        }else if (o1.score<o2.score){
            return 1;
        }else {
            return 0;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Student[] student = new Student[]{
                new Student("zhangsan",95),
                new Student("lisi",89),
                new Student("wangwu",88),
                new Student("zhaoliu",98),
        };
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
        nameCompare comparator1 = new nameCompare();
        sorceCompare comparator2 = new sorceCompare();
        System.out.println(comparator1.compare(student[0],student[1]));
        System.out.println(comparator2.compare(student[0],student[1]));
        }
}

在这里我们可以看出，与Comparable接口不同的是，它不是在想要比较的类上直接添加，而是单独创建了一个类并创建对象，可以根据成绩比较，可以根据名字比较，返回的是一个整数，若我们想利用比较器对数组进行排序，可不可以实现呢，当然可以，我们在上述代码的基础上稍作改动

public class Main {
    public static void main(String[] args) {
        Student[] student = new Student[]{
                new Student("zhangsan",95),
                new Student("lisi",89),
                new Student("wangwu",88),
                new Student("zhaoliu",98),
        };
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
        nameCompare comparator1 = new nameCompare();
        sorceCompare comparator2 = new sorceCompare();
        System.out.println(comparator1.compare(student[0],student[1]));
        System.out.println(comparator2.compare(student[0],student[1]));
        Arrays.sort(student,comparator1)//传入比较器
        System.out.println(Arrays.toString(student));
        }
    }

在数组类的sort方法中，我们传入了一个关于名字的比较器，是sort的一个重载方法，那么运行结果就会根据名字字母的先后顺序进行排序，运行结果如下

在这里我们给出重载sort方法的源码，方便大家理解

 public static <T> void sort(T[] a, Comparator<? super T> c) {//在这里我们可以看到该方法有比较器的形式参数
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

2.8抽象类与接口的区别

抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! 常见面试题).
核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.
如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口.

class Animal {
	protected String name;
	public Animal(String name) {
		this.name = name;
	}
}