抽象类，密封类，接口

一、抽象类：

1. 抽象类是一种模板模式，为所有子类提供了一个通用模板，子类可以在这个模板基础上进行扩展，可以避免子类设计的随意性，就可以做到严格限制子类的设计，使子类之间更加通用。

• 抽象类：包含抽象方法的类（或只对部分方法进行抽象），只有方法的声明，没有方法体；

• 抽象方法：在抽象类中不予实现，必须由继承抽象类的子类来实现；
  抽象方法不能被private所修饰，不加访问修饰限定符时默认其为public；

• 抽象类的派生类：
  a.如果是普通类，必须实现抽象类的所有抽象方法；
  b.如果是抽象类，则可以不实现基类的抽象方法；

• 要点：
  a. 有抽象方法的类只能定义为抽象类；
  b. 抽象类不能实例化，即不能用new来实例化抽象类；
  c. 抽象类可以包含属性、实例方法、构造方法，但是构造方法不能用来new实例，只能用来被子类调用；
  d. 抽象类只能用来继承；
  e. 抽象方法必须由子类来实现。

2. 抽象类和普通类的区别

a. 抽象类不能被实例化；
b. 抽象方法只能被public、protected修饰，或者不加访问修饰限定符；
c. 抽象类由abstaract修饰；
d. 抽象方法不能在抽象类中实现。

二、密封类

1. 当一个类被final所修饰的时候，将这个类称为密封类。

• 密封方法：被final修饰的方法。

• 注意：
  a. 该类不能作用于基类，即无法被继承；
  b. 就算派生类也被final所修饰也不可以；
  c. 密封方法不能被重写。

• 密封类的作用：防止有意的派生。

2. 语法格式

final class 类名 [extends 类名] {
	//类体;
}

三、接口

在Java中继承只是单继承，即一个子类只能有一个直接父类，接口的产生正是为了解决Java中单继承的问题。

• 接口是比抽象类还要“抽象”的“抽象类”，可以更加规范的对子类进行约束，全面的实现了：规范和具体实现的分离；

• 接口就是规范，定义的是一组规则，抽象出了一类事物的某种共有的特性；

• 一个接口定义一个协定，接口本身不提供它所定义的成员的实现，只指定继承接口的任何非抽象类型必须实现接口的所有成员；

• 接口类似于抽象类，不能被实例化，可以包含抽象方法和静态常量字段

• 接口声明的基本形式如下：

[接口修饰符] interface 接口名 [extends 基接口列表] {
	//接口体;
}

• 注意：
  a. interface关键字要注意首字母小写；
  b. 接口名称一般以able为后缀，以表明能够支持某种功夫能，或者以字母 I 开头，也表明是一个接口；
  c. 基接口列表以逗号分隔；

• 接口的成员

a. 接口通常是公共契约，故接口中可以声明零个或多个成员，但只能包含其成员的签名，接口的成员包括从基接口继承的成员和本接口声明的成员，接口成员只能包含抽象方法和静态常量字段；
b. 接口的成员变量默认为静态常量字段（public static final）但接口的成员变量不能带除了public static final以外的任何修饰符。
c. 接口的成员方法默认为公共抽象方法（public abstract），同样，接口的成员方法不能带除了public abstract以外的任何修饰符。

• 接口和抽象类的区别

a.接口内的方法不能被实现，抽象类可以有部分非抽象方法；
b.抽象类只能被继承一次，接口可以被实现或继承多个；
c. 抽象类是对类整体的抽象，但是一个接口可以使用关键字extends继承多个接口；
d. 在接口中的成员变量和成员方法默认为public static final和public abstract，抽象类当中的方法和成员变量没有明确要求，但是抽象类当中的方法不能是private。

例：报警门问题

程序代码：

abstract class Door {
    abstract void open();
    abstract void close();
}
interface Alarm {
    void alarm();
}
class AlarmDoor extends Door implements Alarm {
    @Override
    void open() {
    
    }
    @Override
    void close() {

    }
    @Override
    public void alarm() {

    }
}

四、常用接口

1. Cloneable接口：克隆自定义类必须实现cloneable接口，重写object类的clone方法；

• Cloneable源码：
  

• 设计空接口（标记接口）的作用：标记这个类可以进行克隆，若不实现这个接口则JVM不能够识别。

• 浅拷贝

例：

class Money {
    double money = 10.0;
}
class Person2 implements Cloneable { 
    private String name;
    Money m;
    public Person2(String name) {
        this.name = name;
        this.m = new Money();
    }
    //重写Object类的clone();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();   //调用基类的克隆方法
    }
}
public class testDemo3 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person2 person2 = new Person2("caocao");
        Person2 person21 = (Person2) person2.clone();       //克隆返回Object类型
        System.out.println(person2.m.money);
        System.out.println(person21.m.money);
        person2.m.money = 1000;
        System.out.println(person2.m.money);
        System.out.println(person21.m.money);
    }
}

运行结果：

• 深拷贝

例：

class Money implements Cloneable {
    double money = 10.0;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person2 implements Cloneable {
    private String name;
    Money m;
    public Person2(String name) {
        this.name = name;
        this.m = new Money();
    }
    //重写Object类的clone();
    @Override
    protected Object clone() throws CloneNotSupportedException {

        Person2 person2 = (Person2)super.clone();
        person2.m = (Money)this.m.clone();
        return person2;
    }
}

public class testDemo3 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person2 person2 = new Person2("caocao");
        Person2 person21 = (Person2) person2.clone();       //克隆返回Object类型，需强转为Person2;
        System.out.println(person2.m.money);
        System.out.println(person21.m.money);
        person2.m.money = 1000;
        System.out.println(person2.m.money);
        System.out.println(person21.m.money);
    }
}

运行结果：

2. Comparable接口：对它的每个类的对象进行整体排序，此排序被称为该类的自然排序，类的Compare To方法被称为它的自然比较方法。实现此接口的对象列表可以通过Arrays.sort()进行排序。

• 源码：即对自定义类型进行比较排序要实现Comparable接口，重写compareTo方法

例：

class Student implements Comparable<Student>{  
    private String name;
    private int age;
    private double scroe;
    public Student(String name, int age, double scroe) {
        this.name = name;
        this.age = age;
        this.scroe = scroe;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getScroe() {
        return scroe;
    }
    public void setScroe(double scroe) {
        this.scroe = scroe;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + scroe +
                '}';
    }
    @Override
    public int compareTo(Student o) {
        return age-o.age;
    }
}
public class testDemo3 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("小明",13,99);
        students[1] = new Student("小红",15,89);
        students[2] = new Student("小华",12,69);
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

运行结果：

3. Comparator接口：将比较代码嵌入需要进行比较的类的自身代码中。

例：

class Student {
    private String name;
    private int age;
    private double scroe;
    public Student(String name, int age, double scroe) {
        this.name = name;
        this.age = age;
        this.scroe = scroe;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getScroe() {
        return scroe;
    }
    public void setScroe(double scroe) {
        this.scroe = scroe;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + scroe +
                '}';
    }
}
public class testDemo3 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("小明",13,99);
        students[1] = new Student("小红",15,89);
        students[2] = new Student("小华",12,69);
        //Arrays.sort(students);
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return (int)(o1.getScroe()-o2.getScroe());
                //return o1.getName().compareTo(o2.getName());
                //return o1.getAge()-o2.getAge();
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

运行结果：

• Comparatable和Comparator的区别：

  • Comparable可认为是内比较器，内部调用CompareTo方法；
    
  • Comparator是外比较器，内部是compare方法；