抽象类

抽象类
1.包含抽象方法的类，叫做抽象类。由abstract修饰。
2.抽象类当中：可以有非抽象方法。
3.抽象类不能创建实例对象。
抽象方法
1.在抽象类内部不给予实现。当有一个类，继承了当前的抽象类后，需要实现。
2.抽象方法不能被private修饰，如果不加访问修饰限定符，默认为public。
抽象类的派生类
1.如果是普通类，那么必须实现抽象类的抽象方法。
2.如果是抽象类，可以不实现基类的抽象方法。
抽象类和普通类的区别
1、抽象类不能被实例化。
2、抽象方法不能被private修饰。
3、抽象类被abstract修饰。
4、抽象方法不能在抽象类当中实现。

如下代码为抽象类的例子：

abstract class Animals {
    public abstract void bark();
}
//派生类为普通类，必须实现基类的抽象方法
class Cat extends Animals {
    public void bark() {
        System.out.println("Cat:喵~~喵~~喵~~");
    }
}
class Dog extends Animals {
    public void bark() {
        System.out.println("Dog:汪~~汪~~汪~~");
    }
}
//派生类为抽象类，可以不实现基类的抽象方法
abstract class Pig extends Animals {
    public void fun() {
        System.out.println("abstract class Pig:fun()");
    }
}
public class TestDemo5 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.bark();//Dog:汪~~汪~~汪~~
        Cat cat = new Cat();
        cat.bark();//Cat:喵~~喵~~喵~~
    }
}

密封类

密封类
一个类被final修饰，称为密封类，为了防止有意的派生
密封方法
被final修饰的方法，不能被重写
使用时应注意
1.该类不能作为基类。
2.派生类被final所修饰，该类也不可以作为基类。

如下代码为密封类的例子：

final class Student {
    private String grade;
    private int id;
    private String name;
    public void setId(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
}

接口

接口

接口由interface定义
属性默认修饰符为public static final
方法默认修饰符为public abstract
如：

interface One {
    public static final int COUNT = 1;//修饰符为默认的，只写int COUNT即可
    public abstract void methods1();
}

接口和抽象类的区别

1.接口内的方法，必须不能被实现，而抽象类可以存在非抽象方法。

2.抽象类只能继承一次，但是接口可以被实现或者继承多个。

a. 一个抽象类可以继承一个抽象父类，但是一个接口可以使用关键字
extends继承多个接口
b. 抽象类是对类整体的抽象而接口是对行为(方法)进行抽象
c. 接口中的成员变量和成员方法默认为public static final
和public abstract
d. 抽象类当中的方法和成员变量的修饰符没有明确要求，但是抽象类当中的
方法不能用private修饰。

interface One {
    public static final int COUNT = 1;
    public abstract void methods1();
}
interface Two {
    void methods2();
}
//这样写新的接口可以不实现extends后接口的方法
interface Three extends One, Two {
    void methods3();
}
//实现接口Three
class Test implements Three {
    public void methods1() {
        System.out.println("One.methods1()");
    }
    public void methods2() {
        System.out.println("Two.methods2()");
    }
    public void methods3() {
        System.out.println("Three.methods3()");
    }
}
public class TestDemo5 {
    public static void main(String[] args) {
        Test test = new Test();
        test.methods1();//One.methods1()
        test.methods2();//Two.methods2()
        test.methods3();//Three.methods3()
        One one = test;
        one.methods1();//One.methods1()
        Two two = test;
        two.methods2();//Two.methods2()
        Three three = test;
        three.methods3();//Three.methods3()
    }
}

三种接口

1.Comparator

在类外实现 int compare(T o1, T o2)方法

class Teacher {
    private int id;
    private String subject;
    private String name;
    public Teacher(int id, String subject, String name) {
        this.id = id;
        this.subject = subject;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSubject() {
        return subject;
    }
    public void setSubject(String subject) {
        this.subject = subject;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", subject='" + subject + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        Teacher[] teacher = new Teacher[3];
        teacher[0] = new Teacher(04, "History", "H.s");
        teacher[1] = new Teacher(02, "Math", "M.a");
        teacher[2] = new Teacher(03, "English", "E.n");
        System.out.println(Arrays.toString(teacher));
        System.out.println("========按姓名排序=========");
        Arrays.sort(teacher, new Comparator<Teacher>() {
            @Override
            public int compare(Teacher aa, Teacher bb) {
                return aa.getName().compareTo(bb.getName());
            }
        });
        System.out.println(Arrays.toString(teacher));
        System.out.println("========按id排序=========");
        Arrays.sort(teacher, new Comparator<Teacher>() {
            @Override
            public int compare(Teacher aa, Teacher bb) {
                return (aa.getId() - bb.getId());
            }
        });
        System.out.println(Arrays.toString(teacher));
    }
}

输出结果：
在这里插入图片描述

2.Comparable

在类内实现compareTo(T o)方法

class Teacher implements Comparable <Teacher>{
    private int id;
    private String subject;
    private String name;
    public Teacher(int id, String subject, String name) {
        this.id = id;
        this.subject = subject;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSubject() {
        return subject;
    }
    public void setSubject(String subject) {
        this.subject = subject;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", subject='" + subject + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
    @Override
    public int compareTo(Teacher aa) {
        return subject.compareTo(aa.subject);
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        Teacher[] teacher = new Teacher[3];
        teacher[0] = new Teacher(04, "History", "H.s");
        teacher[1] = new Teacher(02, "Math", "M.a");
        teacher[2] = new Teacher(03, "English", "E.n");
        Arrays.sort(teacher);
        System.out.println(Arrays.toString(teacher));
    }
}

3.Clonable

public interface Cloneable {
}

此接口在源代码中为空接口，空接口的作用是标记这个类可以进行clone，如果不实现这个接口JVM不能够识别。

实例：

class Color implements Cloneable {
    String name;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Size implements Cloneable {
    Color color;
    public Size() {
        this.color = new Color();
    }
    //重写Object的克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Size size = (Size) super.clone();
        size.color = (Color) this.color.clone();
        return size;
    }
}
public class TestDemo4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Size size = new Size();
        Size size1 = (Size) size.clone();
        System.out.println(size.color.name);
        System.out.println(size1.color.name);
        size1.color.name = "red";
        System.out.println(size.color.name);
        System.out.println(size1.color.name);
    }
}