Java基础--接口

目录

一、为什么要有接口

二、接口的定义和特点

        定义：

        特点：

三、接口与抽象类的比较

四、接口实例一（Servlet）

五、接口实例二（comparable接口）

        1、引用类型排序

2、sort方法分析（其实是快排）

（1）冒泡排序

（2）快速排序

---

一、为什么要有接口

        有时候必须从几个类当中派生出一个子类，继承他们所有的属性和方法，但是java不支持多重继承于是就有了接口。

二、接口的定义和特点

        定义：

        接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

        特点：

        1.接口用interface实现

public interface Aniaml {
    public void run();
}

public interface A {
    public void flay();
}

public class Cat implements A,Aniaml{
    @Override
    public void flay() {
        
    }

    @Override
    public void run() {

    }
}

        2.接口中所有的成员变量都是由public static final修饰的

        3.接口中的所有方法默认都是public abstract修饰的

        4.接口没有构造方法，构造方法用于创建对象（接口没办法new对象），但是可以使用多态

        5.实现接口的类中，必须实现接口中的所有方法，如果不实现接口中所有的方法，那么该类是抽象类

        6.接口和接口之间可以互相继承

        7.与继承关系类似，接口与实现类之间存在多态性

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

三、接口与抽象类的比较

抽象类是对类的抽象，是一种模板设计；接口是行为的抽象，是一种行为的规范。

四、接口实例一（Servlet）

        Servlet接口中有init()初始化方法、service()服务方法、destroy()销毁方法，这三个方法定义了servlet生命周期 。除此之外还有getServletConfig()方法获取servlet的配置、getServletInfo()方法获取servlet信息。

        GenericServlet是一个抽象类，只是实现了Servlet接口中的部分方法（与生命周期相关）。

        HttpServlet实现了service()方法。

        所以自己使用Servlet时可以继承上面的基本方法，更加方便。

五、接口实例二（comparable接口）

        1、引用类型排序

        对于基本数据类型，我们可以使用Arrays.sort()进行排序。但是当我们将引用类型数据排序却会报错。

 那么如何进行排序呢？我们需要实现Comparable接口。

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从小到大进行排序age - o.age
        //制定age从大到小进行排序o.age - age
        return age - o.age;
    }
}

测试类

public class Test {
    public static void main(String[] args) {


        Person p1 = new Person(22,180);
        Person p2 = new Person(20,190);
        Person p3 = new Person(18,170);
        Person p4 = new Person(23,181);
        Person[] persons =new Person[]{p1,p2,p3,p4};
        Arrays.sort(persons);
        System.out.println(Arrays.toString(persons));
    }
}

结果：

 

2、sort方法分析（其实是快排）

我们可以自己写一个sort方法

（1）冒泡排序

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从小到大进行排序age - o.age
        //制定age从大到小进行排序o.age - age
        return age - o.age;
    }
}

public class Arrays2 {

    // 冒泡排序
    public static void sort(Comparable[] arr){
        for(int j = 0;j<arr.length;j++){
            for (int i = 0;i<arr.length-1;i++){
                if(arr[i].compareTo(arr[i+1]) >0){  // 5 -  7
                    Comparable temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
    }

}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(22,180);
        Person p2 = new Person(20,190);
        Person p3 = new Person(18,170);
        Person p4 = new Person(23,181);
        Person[] persons =new Person[]{p1,p2,p3,p4};
        Arrays2.sort(persons);
        System.out.println(Arrays.toString(persons));
    }
}

运行结果为

（2）快速排序

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从小到大进行排序age - o.age
        //制定age从大到小进行排序o.age - age
        return age - o.age;
    }
}

public class Arrays3 {
//快速排序
    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;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(22,180);
        Person p2 = new Person(20,190);
        Person p3 = new Person(18,170);
        Person p4 = new Person(23,181);
        Person[] persons =new Person[]{p1,p2,p3,p4};
        Arrays3.sort(persons,0,persons.length-1);
        System.out.println(Arrays.toString(persons));
    }
}

运行结果为