接口与Cloneable接口、Comparator接口

接口的基本概念

接口由interface关键字定义

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

注解

[ ]表示可选部分
接口名一般以able为后缀(Cloneable)，以表明能支持某种功能；或以字母I开头(IMyInterface)，以表明是一个接口
接口体可为空

接口的成员

接口的成员变量默认为 public static final
接口的方法默认为 public abstract
都不能带除默认方法以外的任何修饰符

接口的继承

接口可以被实现或者继承多个。

接口的实现

接口可以由类来实现，派生类使用关键字implements实现接口。

interface C extends A,B{} :可以不实现A,B接口的方法。

class D implements A,B :必须实现A,B接口的方法。

interface IMyInterface1 {
    public static final int AGE = 10;
    public abstract void fun1();//不能有具体的实现
}

interface IMyInterface2 {
    int AGE = 100;
    void fun2();
}

interface IMyInterface3 extends IMyInterface1,IMyInterface2{
    void fun3();
}
class  Fairy implements IMyInterface1,IMyInterface2{
    @Override
    public void fun1() {
        System.out.println("IMyInterface1");
    }

    @Override
    public void fun2() {
        System.out.println("IMyInterface2");
    }
}

接口和抽象类的区别

接口内的方法必须不能被实现，而抽象类可以有部分非抽象方法.
抽象类只能继承一次，但是接口可以被实现或者继承多个。
一个抽象类可以继承一个抽象父类，但是一个接口可以使用关键字extends继承多个接口。
抽象类是对类整体的抽象而接口是对行为进行抽象。
在接口中的成员变量和成员方法默认为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() {

    }
}

常用的接口

Cloneable接口

如果要克隆自定义类必须实现Cloneable接口，然后重写Object类的克隆方法。

接口与Cloneable接口、Comparator接口

敲重点！！！

源代码中接口内什么都没有，叫做空接口或标记接口。

空接口设计的作用：

标记当前类可以进行克隆，如果不实现这个接口，JVM不能够识别。

class Money implements Cloneable{
    double money = 10.0;

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

    @Override//重写Object类的clone()方法
    protected Object clone() throws CloneNotSupportedException {
       //浅拷贝
       //return super.clone();
       //深拷贝
        Person person = (Person)super.clone();
        person.m = (Money)this.m.clone();
        return person;
    }
}
public class Demo10 {
    public static void main(String[] args)throws CloneNotSupportedException {
        Person person = new Person("小可爱");
        Person person1 = (Person) person.clone();
        System.out.println(person.m.money);
        System.out.println(person1.m.money);
        System.out.println("===================");
        person.m.money = 100.0;
        System.out.println(person.m.money);
        System.out.println(person1.m.money);

    }
}
//运行结果
10.0
10.0
===================
100.0
10.0

Comparable接口

//源码定义
public interface Comparable<T> {
      public int compareTo(T o);
}

package com.tulun.src;

import java.util.Arrays;

class Student implements Comparable<Student>{
     private String name;
     private int age;
     private double score;
     public Student(String name,int age,double score){
         this.name = name;
         this.age = age;
         this.score = score;
     }

     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 getScore() {
         return score;
     }

     public void setScore(double score) {
         this.score = score;
     }

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

    @Override  //重写方法
    public int compareTo(Student o) {
        //return name.compareTo(o.name); 根据名字排序
        return age-o.age; //根据年龄排序
    }
}
 public class Demo8{
     public static void main(String[] args) {
         Student[] students = new Student[3];
         students[0] = new Student("zhang",10,99.0);
         students[1] = new Student("li",20,59.0);
         students[2] = new Student("an",30,19.0);
         Arrays.sort(students);
         System.out.println(Arrays.toString(students));
     }
 }
 //运行结果
 [Student{name='zhang', age=10, score=99.0}, Student{name='li', age=20, score=59.0}, Student{name='an', age=30, score=19.0}]

Comparator接口

//源码
public interface Comparator<T> {
    int compare(T o1, T o2);
}

package com.tulun.src;

import java.util.Arrays;
import java.util.Comparator;

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

     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 getScore() {
         return score;
     }

     public void setScore(double score) {
         this.score = score;
     }

     @Override
     public String toString() {
         return "Student{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 ", score=" + score +
                 '}';
     }
}
 public class Demo8{
     public static void main(String[] args) {
         Student[] students = new Student[3];
         students[0] = new Student("zhang",10,99.0);
         students[1] = new Student("li",20,59.0);
         students[2] = new Student("an",30,19.0);
         Arrays.sort(students, new Comparator<Student>() {
             @Override
             public int compare(Student o1, Student o2) {
                 //return o1.getAge()-o2.getAge();  //比较年龄
                 //return o1.getName().compareTo(o2.getName()); //比较名字
                 return (int)(o1.getScore()-o2.getScore()); //比较分数，需转为int类型
             }
         });
         System.out.println(Arrays.toString(students));
     }
 }

敲重点！！！

Comparable和Comparator的区别：

Comparable：类内部进行比较

Comparator：类外进行比较

接口与Cloneable接口、Comparator接口

接口的基本概念

接口的成员

接口的继承

接口的实现

接口和抽象类的区别

常用的接口

继续阅读

为什么要用接口，而不是直接用类实现

JAVA中的四种内部类的运用方法内部类（实际中很少用）

07 面向对象编程-结构、封装、继承、多态、接口Struct定义struct 方法工厂模式面向对象三大特性

IDEA使用YapiUpload插件自动生成Yaip接口文档一、下载安装二、配置三、文档生成规则

权限控制、多态、接口学习心得

php laravel中请求第三方接口数据

初见Java中的接口接口的概念

Python requests模块params与data的区别（转载）

vb使用字符串分隔字符串_为什么要使用字符串

设计模式之开闭原则（OCP) 详解

go语言笔记（结构体、方法、接口）go语言笔记（结构体、方法、接口）

【笔者亲测】jmeter跨线程组调用或jmeter跨线程组传值

开源接口管理平台 eoLinker AMS开源版 V3.2.1更新，Mock增加允许新请求头！

Request must contain an kbn-xsrf header 报错

Django项目后端实现注册功能---短信验证码(容联云)。

Charles打断点--修改response值（wind版）