Java的抽象类和接口_java接口和类

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

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

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 + "正在蹬腿游泳");
    }
}

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

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;
    }
 
    @Override
    public 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进行重写：

    @Override
    public 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;
 
    @Override
    public 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;
    }
 
    @Override
    public 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;
 
    @Override
    public 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;
    }
 
    @Override
    public 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>{
    @Override
    public 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;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
 
    @Override
    protected 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;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
 
    @Override
    protected 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;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student tmp = (Student) super.clone();
        tmp.m = (Money) this.m.clone();
        return tmp;
    }
}
class Money implements Cloneable{
    public double money;
 
    @Override
    protected 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、获取对象信息