java接口简述及注意事项、三个常用接口compareble、comparator、clonable

接口

1. 使用interface来修饰。interface IA { }
2. 接口当中，可以有static的方法
3. 里面的所有方法都是public 的
4. 抽象方法，默认是·public abstract 的
5. 接口是不可以被通过关键字new来实例化的
6. 接口中的方法一定是抽象方法, 因此可以省略 abstract。接口中的方法一定是 public, 因此可以省略 public

interface IShape {
    void draw();
}
class Cycle implements IShape {
     @Override
    public void draw() {
        System.out.println("○");
    }
}
public class Test {
    public static void main(String[] args) {
        IShape shape = new Rect();
        shape.draw();
    }
}

7. 对于字段来说, 接口中只能包含静态常量(final static).

interface IShape {
    void draw();
    public static final int num = 10;
}

其中的 public, static, final 的关键字都可以省略. 省略后的 num 仍然表示 public 的静态常量

提示：

1. 我们创建接口的时候, 接口的命名一般以大写
2. 接口的命名一般使用 “形容词” 词性的单词
   
   
3. 类和接口之间的关系是通过implements实现的
4. 当一个类实现了一个接口，就必须要重写接口当中的抽象方法
5. 接口当中的成员变量，默认是public static final修饰的
6. 当一个类实现一个接口之后，重写这个方法的时候，这个方法前面必须加上public

一个错误代码：

interface IShape {
    abstract void draw() ; // 即便不写public，也是public
}
class Rect implements IShape {
    void draw() {
        System.out.println("□") ; //权限更加严格了，所以无法覆写。
    }
}

12. Java 中只支持单继承, 一个类只能 extends 一个父类. 但是可以同时实现多个接口,通过implements实现多个接口，接口之间使用逗号隔开， 也能达到多继承类似的效果。
通过类来表示一组动物：

class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
}

再提供一组接口, 分别表示 “会飞的”, “会跑的”, “会游泳的”.

interface IFlying {
    void fly();
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}

创建几个具体的动物
猫, 是会跑的.

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

还有一种神奇的动物, 水陆空三栖, 叫做 “鸭子”

class Duck extends Animal implements IRunning, ISwimming, IFlying {
    public Duck(String name) {
        super(name);
}
    @Override
public void fly() {
    System.out.println(this.name + "正在用翅膀飞");
}
    @Override
public void run() {
    System.out.println(this.name + "正在用两条腿跑");
}
    @Override
public void swim() {
    System.out.println(this.name + "正在漂在水上");
    }
}

13. 类和接口之间是通过implements来操作的，接口与接口之间是通过extends来操作的。此时，这里面意为：拓展。
一个接口B extends来拓展另外一个接口C的功能。此时当另外一个类D通过implements实现这个接口B的时候，此时重写的方法不仅仅是B的抽象方法，还有它从C接口拓展来的功能或者方法。

三个常用的接口：
comparable
comparator
clonable
给对象数组排序
给定一个学生类

class Student {
    private String name;
    private int score;
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
}
    @Override
public String toString() {
    return "[" + this.name + ":" + this.score + "]";
    }
}

给定一个学生对象数组, 对这个对象数组中的元素进行排序(按分数降序)

Student[] students = new Student[] {
    new Student("张三", 95),
    new Student("李四", 96),
    new Student("王五", 97),
    new Student("赵六", 92),
};

按照之前的理解, 数组我们有一个现成的 sort 方法, 能否直接使用这个方法呢?

Arrays.sort(students);
System.out.println(Arrays.toString(students));
// 运行出错, 抛出异常.
Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to
java.lang.Comparable

和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系怎么确定? 需要额外指定.
让 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

class Student implements Comparable {
    private String name;
    private int score;
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
}
    @Override
public String toString() {
    return "[" + this.name + ":" + this.score + "]";
}
    @Override
public int compareTo(Object o) {
    Student s = (Student)o;
    if (this.score > s.score) {
    return -1;
} else if (this.score < s.score) {
    return 1;
} else {
    return 0;
    }
    }
}

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.
然后比较当前对象和参数对象的大小关系(按分数来算).

1. 如果当前对象应排在参数对象之前, 返回小于 0 的数字;
2. 如果当前对象应排在参数对象之后, 返回大于 0 的数字;
3. 如果当前对象和参数对象不分先后, 返回 0;
   再次执行程序, 结果就符合预期了

// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]

注意事项: 对于 sort 方法来说, 需要传入的数组的每个对象都是 “可比较” 的, 需要具备 compareTo 这样的能力. 通过
重写 compareTo 方法的方式, 就可以定义比较规则