Java-接口vs抽象类

一、接口

public interface Student {
    /**
     * 这是一个学生类接口
     *     接口
     *     1、修饰符：interface
     *     2、接口中只能定义抽象方法(抽象方法是没有方法体的），不能定义普通的成员方法
     *     3、接口中可以定义常量，不能定义成员变量
     *     4、接口不能实例化，必须有一个类来实现它
     *     5、一个类实现该接口，必须实现该接口中的方法（抽象方法）
     *     6、一个类可以实现多个接口(解决了java中类的但继承问题
     *     7、实现类和接口用implements关键字来联系
     *    8、JDK1.8新特性：接口可以有静态方法和default修饰的方法
     *    9、接口中不能定义构造方法
     *
     */

    public static final int age=5;
    public abstract void show();
}

public class Person implements Student {
    public String name;
    @Override
    public void show() {
        System.out.println(name+"is "+age+" years old");
    }
}

public class TestImlpl {
    public static void main(String[] args) {
        Person person=new Person();
        person.name="张三";
        person.show();
    }
}

二、抽象类

public abstract class Animal {
    /**
     * 这是一个抽象类
     * 抽象类：
     * 1、用abstract关键字修饰
     * 2、不能被实例化，只能由继承它的子类来进行实例化
     * 3、抽象类中可以有普通的成员遍历和方法
     * 4、父类和子类之间用extends来联系
     * 5、一个类继承抽象类，必须重写抽象类中的所有抽象方法
     * 6、抽象方法不能是private或者static
     * 7、抽象类不能用final修饰，final修饰的类是不能被继承的，final修饰的变量是常量并不能再更改
     * 8、抽象类中可以定义构造方法
     * 9、子类继承父类，继承了父类中除构造方法以外的所有东西（包括被private修饰的）
     */
    public int age=3;
    public void method(){
        System.out.println("这是一个动物");
    }
    public abstract void  method2();
}

public class Dog extends Animal {
    public String name;
    @Override
    public void method2() {
        System.out.println("这只"+name+"已经"+age+"岁啦");
    }
}

public class TestExtends {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name="萨摩";
        dog.method();
        dog.method2();

    }

}

三、接口案例
比较：Comparable

class Student implements Comparable<Student> {

    private String name;
    private int age;
    private int score;

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

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

    @Override
    public int compareTo(Student o) {
        //指定排序的规则
        //return this.score - o.score;
        return o.age-this.age;

    }
}
public class Test {
        public static void main(String[] args) {
            Student[] students=new Student[3];
            students[0] = new Student("张三", 16, 88);
            students[1] = new Student("李四", 17, 92);
            students[2] = new Student("王五", 16, 90);
            Arrays.sort(students);
            System.out.println(Arrays.toString(students));

        }
    }

克隆：Coneable（深拷贝）

class Student implements Cloneable{
    public String name;
    private int age;
    private String sex;

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

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

    //重写该接口中的克隆方法
    @Override
    protected Student clone() throws CloneNotSupportedException {
        return (Student)super.clone();
    }
}
public class TestClon {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1=new Student("张三",29,"男");
        Student s2= s1.clone();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("############");
        s1.name="王五";
        System.out.println(s1);
        System.out.println(s2);


    }
}