class Cat extends Animal implements IRunning {public Cat(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + "正在用四条腿跑");}
}

class Fish extends Animal implements ISwimming {public Fish(String name) {super(name);}@Overridepublic void swim() {System.out.println(this.name + "正在用尾巴游泳");}
}

class Frog extends Animal implements IRunning, ISwimming {public Frog(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + "正在往前跳");}@Overridepublic void swim() {System.out.println(this.name + "正在蹬腿游泳");}
}

接口间的继承相当于把多个接口合并在一起.

7、抽象类和接口的区别

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

8、接口使用实例

给对象数组排序

在学习给对象数组进行排序之前，我们先来回顾一下怎么对一个整型数组进行排序：

import java.util.Arrays;public class Test {public static void main(String[] args) {int[] arr = {1,4,5,3,2,9,7};Arrays.sort(arr);System.out.println(Arrays.toString(arr));}
}

那么这个时候，便会有人写出这样的一段代码：

import java.util.Arrays;class Student{public String name;public int age;public double score;public Student(String name,int age,double score) {this.name = name;this.age = age;this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", score=" + score +'}';}
}public class Test {public static void main(String[] args) {Student[] array = new Student[3];array[0] = new Student("zhangsan",19,90);array[1] = new Student("lisi",86,35);System.out.println("排序前： " + Arrays.toString(array));Arrays.sort(array);System.out.println("排序后: "+ Arrays.toString(array));}
}

经过运行，我们会发现这段代码会进行报错，这是因为我们在排序的时候并没有告诉编译器是按照什么来排序，并且Student是一个自定义类型而导致的。

根据报错，我们可以发现是源码中的转化出了问题，现在我们顺着源码点进去看一下

这段源码的意思是将数组强转为Comparable，那么这个 Comparable又是什么东西呢？我们再来看看它的源码

我们可以发现，它是一个接口

也就是说，他要把数组里面的元素强转为Compareable,然后去调用Compare to方法 

也就是说，此时我们要让Student类型和Compareable之间进行联系：

我们会发现，此时会发生报错，那么此时我们再对compare to进行重写：

    @Overridepublic int compareTo(Student o) {if(this.age - o.age > 0){return 1;}else if (this.age - o.age < 0){return -1;}else {return 0;}}

 那么此时我们再运行代码会发现排序成功：

完整的代码是这个样子的：

import java.util.Arrays;
import java.util.Comparator;class Student implements Comparable<Student> {public String name;public int age;public double score;@Overridepublic int compareTo(Student o) {if(this.age - o.age > 0){return 1;}else if (this.age - o.age < 0){return -1;}else {return 0;}}public Student(String name, int age, double score) {this.name = name;this.age = age;this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", score=" + score +'}';}
}public class Test {public static void main(String[] args) {Student[] array = new Student[3];array[0] = new Student("zhangsan",19,90);array[1] = new Student("lisi",86,35);array[2] = new Student("wangwu",45,18);System.out.println("排序前： " + Arrays.toString(array));Arrays.sort(array);System.out.println("排序后: "+ Arrays.toString(array));}
}

 因此我们得出一个结论：当我们对自定义类型进行比较的时候，一定要实现可比较的接口！也就是说：

import java.util.Arrays;
import java.util.Comparator;class Student implements Comparable<Student> {public String name;public int age;public double score;@Overridepublic int compareTo(Student o) {if(this.age - o.age > 0){return 1;}else if (this.age - o.age < 0){return -1;}else {return 0;}}public Student(String name, int age, double score) {this.name = name;this.age = age;this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", score=" + score +'}';}
}public class Test {public static void main(String[] args) {Student[] array = new Student[3];array[0] = new Student("zhangsan",19,90);array[1] = new Student("lisi",86,35);array[2] = new Student("wangwu",45,18);System.out.println("排序前： " + Arrays.toString(array));bubblesort(array);System.out.println("排序后: "+ Arrays.toString(array));}public static void bubblesort(Comparable[] comparables){for (int i = 0;i < comparables.length-1;i++){for (int j = 0;j < comparables.length-1-i;j++){if(comparables[j].compareTo(comparables[j+1]) > 0){Comparable tmp = comparables[j];comparables[j] = comparables[j+1];comparables[j+1] = tmp;}}}}
}

class AgeComparator implements Comparator<Student>{@Overridepublic int compare(Student o1, Student o2) {return o1.age - o2.age;}
}public class Test {public static void main(String[] args) {Student student1 = new Student("zhangsan",19,90);Student student2 = new Student("lisi",86,35);AgeComparator ageComparator = new AgeComparator();int ret = ageComparator.compare(student1,student2);System.out.println(ret);}}

如果是在不同包中的子类去访问的话，我们一般在这个子类中使用super去访问，这个时候，我们去Student中重写一下我们的clone 方法，那么此时代码报错变成了这个样子：

 此时就是异常的问题了，现在我们将代码处理成这个样子：

public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student = new Student(10);Student student1 = student.clone();}
}

现在，代码报错是这个样子的：

也就是说：我们前面的返回值为Student，而后面的返回值为Object，便牵扯到了向下转型的问题，那么我们再将代码修改成这样：

public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student = new Student(10);Student student1 = (Student) student.clone();}
}

 但是我们会发现在运行后依旧发生了报错：

那么此时，我们为了让代码指出克隆，需要实现Cloneable接口： 当实现这个接口后，我们会发现代码不再进行报错，可以正常运行了

那么这个接口的作用是什么呢？

这个接口叫做标记接口，实现了该接口证明当前类是可以被克隆的

 完整的克隆代码如下：

class Student implements Cloneable{public int age;public Student(int age) {this.age = age;}@Overridepublic String toString() {return "Student{" +"age=" + age +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student = new Student(10);Student student1 = (Student) student.clone();}
}

现在，我们来看一下这段代码及其运行结果：

class Student implements Cloneable{public int age;public Money m = new Money();public Student(int age) {this.age = age;}@Overridepublic String toString() {return "Student{" +"age=" + age +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
class Money{public double money;}public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student1 = new Student(10);student1.m.money = 19.9;Student student2 = (Student) student1.clone();System.out.println(student1.m.money);System.out.println(student2.m.money);System.out.println("======================");student1.m.money = 29.9;System.out.println(student1.m.money);System.out.println(student2.m.money);}
}

运行结果：

 那么这个时候，便会产生疑问了：为什么在完成克隆后将student1的money该成了29.9，student2的money也会随之变化呢？

这是因为，克隆的是Student的里面的成员m，而m存储的是money的地址，因此当student1的money改变时，student2的money也会随之改变 ，我们可以用下面这张图来表示它们之间的关系：

我们将这种拷贝称之为浅拷贝，如果我们能把Money对象也拷贝了，那么便是深拷贝。

那么现在，我们来看一下在这种情景下深拷贝的实现：

class Student implements Cloneable{public int age;public Money m = new Money();public Student(int age) {this.age = age;}@Overridepublic String toString() {return "Student{" +"age=" + age +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {Student tmp = (Student) super.clone();tmp.m = (Money) this.m.clone();return tmp;}
}
class Money implements Cloneable{public double money;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student1 = new Student(10);student1.m.money = 19.9;Student student2 = (Student) student1.clone();System.out.println(student1.m.money);System.out.println(student2.m.money);System.out.println("======================");student1.m.money = 29.9;System.out.println(student1.m.money);System.out.println(student2.m.money);}
}

核心思想就是：每一个对象都要去拷贝！！！

 三、Object类

1、什么是Object类

范例：使用Object接收所有类的对象

class Person{}
class Student{}
public class Test {public static void main(String[] args) {function(new Person());function(new Student());}public static void function(Object obj) {System.out.println(obj);}
}
//执行结果：
Person@1b6d3586
Student@4554617c

所以在开发之中，Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下：

2、获取对象信息