【JAVA基础】接口-CSDN博客

本文链接：https://blog.csdn.net/weixin_51325964/article/details/141856473

文章目录

接口
Comparable、Comparator和Arrays.sort()的关系

接口

接口是对行为的定义或规范，接口中只能使用抽象方法
接口中只能使用抽象方法
默认也是public修饰符修饰的方法，不需要再写public和abstract关键字
接口类无法创建对象，只能使用多态
接口类可以被多继承，一个类可以继承多个接口（设计接口的目的之一就是实现java类的多继承）

定义一个Animals接口
```
public interface Animals {
    public abstract void run(); // 默认也是public修饰符修饰的方法，不需要再写public和abstract关键字
}
```
定义一个A接口
```
public interface A {
    void fly();
}
```
定义一个子类Cat
```
public class Cat implements Animals,A{

    @Override
    public void fly(){

    }

    @Override
    public void run(){

    }
}
```
子类Cat可以同时继承Animals接口与A接口，并且需要实现其中的抽象方法

设计抽象类的目的之一：更好的实现接口中所定义的方法

以Servlet项目为例子：

可以看到Servlet都会向上继承，最高的父类中定义了三个抽象方法，初始化，服务，销毁，这三个方法分别在下面的子类中被实现

编程练习：设计一个动物管理系统，包含以下几个部分：

**定义一个动物接口（Animal）：**包含所有动物共有的方法，如eat()和sleep()
**定义一个可飞行接口（Flyable）：**包含所有的飞行方法，这个接口将由能飞行的动物实现
**定义一个可以游泳的接口（Swimmable）：**包含游泳的方法swim()，这个接口有能够游泳的动物实现
**定义一个抽象类（AnimalBase）：**提供eat()和sleep()方法的具体实现，作为所有动物类的基类
**实现具体的动物类：**如Bird（鸟，实现Flyable接口并继承AnimalBase），Fish（鱼，实现Swimmable接口并继承AnimalBase），Dog（狗，仅继承AnimalBase）
**编写测试类：**在测试类中创建这些动物实例，并调用他们的方法，展示其行为

创建Animal接口，定义抽象方法eat()和sleep()

public interface Animal {
    void eat();
    void sleep();
}

创建Flyable()接口，定义抽象方法fly()

public interface Flyable {
    void fly(); //飞行动物
}

创建Swimmable()接口，定义抽象方法swim()

public interface Swimmable {
    void swim(); // 水下动物
}

创建抽象类AnimalBase，实现eat()和sleep()方法

public abstract class AnimalBase {

    public void eat(){
        System.out.println("动物需要进食");
    }

    public void sleep(){
        System.out.println("动物需要睡觉");
    }
}

创建子类，并继承对应接口：

public class Bird extends AnimalBase implements Flyable{

    @Override
    public void eat(){
        System.out.println("鸟需要进食");
    }

    @Override
    public void sleep(){
        System.out.println("鸟需要睡觉");
    }

    public void fly(){
        System.out.println("鸟可以飞");
    }
}

public class Fish extends AnimalBase implements Swimmable{
    public void swim(){
        System.out.println("鱼可以游泳");
    }

    @Override
    public void sleep(){
        System.out.println("鱼需要睡觉");
    }

    @Override
    public void eat(){
        System.out.println("鱼需要进食");
    }
}

public class Dog extends AnimalBase{
    @Override
    public void sleep(){
        System.out.println("狗需要睡觉");
    }

    @Override
    public void eat(){
        System.out.println("狗需要进食");
    }
}

对抽象方法的实现：

public class Test {
    public static void main(String[] args) {
        Bird bird = new Bird();
        Fish fish = new Fish();
        Dog dog = new Dog();

        bird.eat();
        bird.fly();
        bird.sleep();

        dog.eat();
        dog.sleep();

        fish.eat();
        fish.sleep();
        fish.swim();
    }
}

Comparable、Comparator和Arrays.sort()的关系

Comparable、Comparator介绍

**Comparable**是排序接口，只有一个方法 compareTo() ，如果 想让一个类可以通过Arrays.sort() 方法进行排序，则可以让这个类继承Comparable接口重写这个方法。
**Comparator **是比较接口，如果一个类本身不支持排序(即没有实现Comparable接口)，但你又不能改动这个类，就可以写一个类(这个类又叫“比较器”) 实现Comparator接口，然后重写Compare()方法。我们想要排序的时候，就可以把这类的实例化对象传入到Arrays.sort() 这个方法里。

什么时候使用？

Comparable：当我们自己写一个类的时候，可以用这个方法实现想要比较的规则
Comparator：当一个类没有比较器，或者我们原本的比较器中的规则不是我们想要的

`Arrays.sort`重载的四类方法

sort( T[] a ) 对指定T型数组按数字升序排序。
sort( T[] a , int formIndex , int toIndex ) 对指定T型数组的指定范围按数字升序排序。
sort( T[] a , Comparator<? supre T> c ) 根据指定比较器产生的顺序对指定对象数组进行排序。
sort( T[] a , int formIndex , int toIndex , Comparator<? super T> c) 根据指定比较器产生的顺序对指定对象数组的指定对象数组进行排序。

Comparable案例

public class Person implements Comparable<Person>{
    public int age;
    public int height;
    public Person(int age,int height){
        this.age = age;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", height=" + height +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        // 定义从小到大排序age - o.age
        // 定义从小到大排序o.age - age
        return age - o.age;
    }
}

public class Test {
    public static void main(String[] args) {
//        int[] arr = new int[]{1,3,5,4,6,7,2};
//        Arrays.sort(arr);
//        System.out.println(Arrays.toString(arr));

        Person p1 = new Person(18,180);
        Person p2 = new Person(20,177);
        Person p3 = new Person(10,190);
        Person p4 = new Person(27,185);

        Person[] person = new Person[]{p1,p2,p3,p4};
        Arrays.sort(person); //快排
        Arrays2.sort(person);
        System.out.println(Arrays.toString(person));
    }
}

Comparator案例

//我们写一个实现Comparator的类，然后重写compare方法
class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}
public class TestComparator {
    public static void main(String[] args) {
        Integer[] arr = {2, 3, 44, 11, 344, 11};
        MyComparator cmp = new MyComparator();
        Arrays.sort(arr, cmp);//arr是数组，cmp是传入这个类
        System.out.println(Arrays.toString(arr));
    }
}