Interface接口----一种行为规范

什么是接口？

抽象类和接口有些类似，通过对比抽象类，我们能更好的了解接口的特点。

抽象类VS接口

抽象类

1.抽象类有抽象方法，定义抽象方法是因为有些方法时不需要父类去实现的，只是需要子类根据自己的功能进行实现。

2.抽象类是对行为（方法）的一种抽象（只定义不实现），抽象类本身是用来提取一些共性的东西，将大家共有的东西抽象出来，相当于是一种模板设计，当子类都重写父类的同一个方法时，只需要在父类当中进行方法的定义。

3.抽象类当中可以使用抽象方法和普通方法

接口

1.而接口是一种行为规范（一种定义），接口当中只能使用抽象方法，所以不需要写abstract关键字，默认是abstract修饰的.,默认是public 访问修饰符修饰的。

2.接口类不能创建对象，只能使用多态

3.接口是可以多继承的，一个类可以实现多个接口（设计接口的目的之一，就是要实现java类的多继承），实现接口就可以实现接口当中的方法

4.接口只是对方法进行定义，并不实现某一个方法（只定义不实现）

示例

定义一个接口Animal

public interface Animal {
    public abstract void run();//接口当中只能使用抽象方法，默认为public abstract 所以不需要写abstract关键字，默认是public修饰的
}

定义一个接口A

package JieKou;

public interface A {
    public abstract void fly();
}

定义一个Cat类实现这两个接口

package JieKou;

public class Cat implements A,Animal{//接口是可以多继承的，一个类可以实现多个接口
    @Override
    public void fly() {

    }

    @Override
    public void run() {

    }
}

接口和抽象类的使用

在进行项目的代码是实现时，我们所创建的类通常需要继承HttpServlet，

只有继承HttpServlet，才可以使用doGet doPost方法，从而接受前端传来的数据

HttpServlet

HttpServlet是一个抽象类，并且继承GenericServlet

GenericServlet类

GenericServlet类也是一个抽象类

它实现了三个接口，Serialzable是序列化接口，ServletConfig是配置接口，我们进一步查看Servlet接口当中的内容

 Servlet接口

通过图表描述当前接口和抽象类的关系

查看Servlet接口

分析接口和抽象类之间的联系

• Servlet接口是定义生命周期的
• GenericServlet实现了Servlet接口除了service方法之外其他的关于生命周期的方法
• 实现接口，接口当中的方法必须去实现，如果不想实现，就将子类设置为抽象类
• HttpServlet实现了service方法
• 我们自定义的Servlet类通过继承的方式，使用到上述类和接口中定义或实现的所有方法。

结论

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

接口的应用-----对象的排序

1.数组的排序

通过sort方法进行数组数据从小到大排序

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

    }
}

执行结果：

2.对象的排序

直接按照数组的方式进行排序后，报错

分析原因：无法转换comparable接口，该接口是用来排序的，但是对象类型是无法进行排序的，无法调用方法进行排序

如果想让对象进行排序，我们需要让Person类实现Compare接口，并且实现接口定义compareTo方法

数值类型的数据才能进行排序，所以我们在实现compareTo方法时，要指定数值类型

Person类实现compareTo方法的代码

package work0829;

public class Person implements Comparable<Person>{
    private Integer age;
    private  Integer 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从小到大排序
        return age-o.age;
        //指定age从大到小排序：age-o.age
    }
}

结论

如果想对类中对象进行排序，只需要让类实现Compare接口，并且实现Compare当中的compareTo方法

我们再次运行Test测试类

然后我们查看Arrays.sort方法的实现

元素自然进行顺序进行升序排序必须数组中所有的元素必须实现comparable接口。Comparable接口如果是对象类型的话，是无法实现comparable接口的，需要手动去实现.

sort具体实现的排序方案

我们继续探索排序方案

利用快速排序重写sort方法

package work0829;

public class Arrays1 {
    public static void sort(Comparable[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        Comparable base =  arr[left];
        int i = left;
        int j = right;
        while (i != j) {
            while (arr[j].compareTo(base)>=0 && i < j) {
                j--;
            }
            while (arr[i].compareTo(base) <= 0 && i < j) {
                i++;
            }
            Comparable temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;


        }
        arr[left] = arr[i];
        arr[i] = base;
        sort(arr, 0, i - 1);
        sort(arr, i + 1, right);
    }
}

为什么定义Compare类型的数组

因为要进行对象的排序，必须要实现Compare接口，不管是什么类的对象，都可以利用多态向上转型，都可以统一用Compare类型的数组进行接收。

执行结果

利用冒泡排序重写sort方法

package work0829;

public class Arrays2 {
    public static void sort(Comparable[] arr){
        for (int j=0;j<arr.length;j++) {


            for(int i = 0;i+1<arr.length;i++){
                if (arr[i].compareTo(arr[i+1])>0){
                    Comparable temp = arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                }
            }
        }
    }
}

 执行结果

package work0829;

import JieKou.A;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        Person p1=new Person(21,182);//创建对象
        Person p2=new Person(20,188);
        Person p3=new Person(22,181);
        Person p4=new Person(22,185);
        Person[] persons=new Person[]{p1,p2,p3,p4};
        Arrays.sort(persons);
        Arrays1.sort(persons,0,persons.length-1);//快速排序
        //Arrays2.sort(persons);//冒泡排序
        System.out.println(Arrays.toString(persons));

    }
}

 最终，我们发现sort方法中的排序方案是冒泡排序

欢迎大家点赞，收藏，评论加关注呦！！！