Java继承,多态,和抽象类及接口与Cloneable,Comparable,Comparator

Java继承,多态,和抽象类及接口

Java中有继承,多态等特殊属性,这些特殊属性实现对应普通类,抽象类和接口.

首先得知道关于定义这些特殊功能的关键字.
1.定义普通类就是常用的class
2.定义抽象类:abstract
3.定义接口:interface
普通类A与普通类B之间继承用extends,其意义就是A可以复用B的代码,但在继承时要注意子类也就是B要先帮助父类A构造,实现接口用implements,与继承不同的是,当一个类B实现Running接口时要实现接口中所有的方法,且接口中的方法自带public static final,同时不能实例化.
代码如下

interface Running{
    void run();
}
class Animal{
    public String name;

    public Animal(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println(this.name+" :eat");
    }
}
class Dog extends Animal implements Running{
    public Dog(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(this.name+" :正在跑");
    }

    @Override
    public void eat() {
        System.out.println(this.name+" :eat");
    }
}

上述代码定义了一个Animal普通类,让Dog继承了Animal,在实现Dog构造方法时先用super(name);帮助父类实现了构造,同时对于eat()方法进行了重写.实现Running接口后也实现了Running中的所有方法.

调用时先用一个goRun方法

public static void goRun(Running running){
        running.run();
    }

那么使用时候就只需要这样

Running running=new Dog("33");
        goRun(running);

        goRun(new Dog("dog"));

就可以完成调用,打印结果如下

在goRun方法中传参的时候,需要的是一个Running型的变量,但是传入的是new Dog();
此时就发生了向上转型,但是在输出的时候并不会调用接口中的方法,因为运行时又发生了运行时绑定.

如果有一个Student类,创建了一个数组存放Student类型数据,如Student[] students=new Student[3];
如果想让这些数据有序,按照以往的方法使用Arrats.sort();让数组有序,但是该数组是一个Student类型,无法比较,此时要实现Comparable接口才可以比较;代码如下

class Student implements Comparable<Student>{
    public String name;
    public 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(Student o) {
        if(this.score>o.score)
            return 1;
        else if(this.score==o.score)
            return 0;
        else return -1;
    }
}

重写了一个compareTo方法比较score作为排序的标准.
调用时直接用Arrats.sort(students);
还有一种方法是重新写一个类命名为NameComparator比较students的名字,

public class NameComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

调用时代码如下

		Student[] students=new Student[3];
        students[0]=new Student("gaobo",28);
        students[1]=new Student("gaozhe",17);
        students[2]=new Student("gaoshuang",18);
        System.out.println(Arrays.toString(students));
        System.out.println("=====================");
        ScoreComparator scoreComparator=new ScoreComparator();
        Arrays.sort(students,scoreComparator);
        System.out.println(Arrays.toString(students));
        System.out.println("=====================");
        NameComparator nameComparator=new NameComparator();
        Arrays.sort(students,nameComparator);
        System.out.println(Arrays.toString(students));

图中代码还使用了比较分数而新建的类ScoreComparator.分别进行排序对比输出;

对于理解Cloneable还可以引出深拷贝和浅拷贝的问题,先摆代码再来看问题

class Money implements Cloneable{
    public int money=100;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public String name;
    public int age;
    Money m=new Money();
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test2 {
    public static void main(String[] args)throws CloneNotSupportedException {
        Person person1=new Person("gaobo",28);
        Person person2=(Person) person1.clone();
        System.out.println(person1.name+" , "+person1.age+" , "+person1.m.money);
        System.out.println(person2.name+" , "+person2.age+" , "+person2.m.money);
        System.out.println("=====================");
        person2.name="gaoshuang";
        person2.m=(Money)person1.m.clone();
        System.out.println(person1.name+" , "+person1.age+" , "+person1.m.money);
        System.out.println(person2.name+" , "+person2.age+" , "+person2.m.money);
        System.out.println("=====================");
        person2.m.money=999;
        System.out.println(person1.name+" , "+person1.age+" , "+person1.m.money);
        System.out.println(person2.name+" , "+person2.age+" , "+person2.m.money);
    }
}

Person类有姓名和年龄两个属性,new一个person1后用person2去接收person1拷贝出来的内容,拷贝前首先得让Person类实现Cloneable接口,再重写clone方法,否则clone方法无法使用,之后拷贝内容到person2,结果如图

修改person2未影响到person1的内容,说明clone方法是深拷贝
其次再加入Money类,在Person类中对Money实例化,此时person2与person1的money值同时改变,这是因为用clone方法拷贝内容时拷贝的是Money对象的引用,没有重新引用新对象.如果要对Money也进行深拷贝,那就需要对Money类也实现Cloneable接口,拷贝person1时对Money也进行拷贝,即person2.m=(Money)person1.m.clone();就完成了深拷贝.