Java中的接口

接口

在Java编程中，接口和抽象类是用于定义类行为的两种不同机制。接口是一种行为规范，用来规定类应该遵循的行为和方法，而抽象类则是对行为的抽象，相当于一种模板设计。在本文中，我们将深入探讨接口的特点、使用场景以及在实际编程中的应用。

什么是接口

接口（Interface）在Java中是一种抽象类型，是对行为的一种规范。它定义了类可以做什么事情，但不提供这些事情的具体实现。换句话说，接口只包含方法的声明，不包含方法的具体实现。接口的设计使得Java可以实现多重继承的效果，即一个类可以实现多个接口。

接口的特点

只能包含抽象方法

在接口中，只能定义抽象方法，所以不需要使用abstract关键字。同时，接口中的方法默认是public访问修饰符。

不能创建对象

接口本身不能实例化，即不能直接创建接口类型的对象。接口通常用于定义类的行为，由实现类去完成具体的行为。

实现多继承

一个类可以实现多个接口，这意味着它可以继承多个接口中的所有方法。接口的这一特性是Java中实现类多继承的一种方式。

常用的接口与抽象类的使用（以HttpServlet为例）

以HttpServlet为例，在一个Servlet项目中，任何一个Servlet都会继承HttpServlet类。HttpServlet是一个抽象类，它继承了另一个抽象类GenericServlet，而GenericServlet又实现了Servlet、ServletConfig和Serializable三个接口。进入Servlet接口后，可以看到它定义了五个方法

这些方法用于管理Servlet的生命周期，包括创建、服务和销毁。GenericServlet抽象类提供了对Servlet接口中除了service方法以外的其他生命周期方法的实现。而HttpServlet则进一步实现了service方法。

通过这种设计，Java语言提供了一种灵活的机制，使得开发者可以专注于实现具体的业务逻辑，而不必重复实现常见的生命周期管理逻辑。将上述内容，用流程图的方式表示。

接口练习题

实现代码如下：

//Animal接口

public interface Animal {

     void eat();

     void sleep();

}

//Swimmable接口

public interface Swimmable {

    void swim();

}

//Flyable接口

public interface Flyable {

  public void flay();

}


public abstract class AnimalBase implements Animal{

    @Override

    public abstract void eat();



    @Override

    public abstract void sleep();

}

public class Fish extends AnimalBase implements Swimmable{

    public void eat() {

        System.out.println("鱼可以吃饭");

    }



    @Override

    public void sleep() {

        System.out.println("鱼可以睡觉");

    }

    @Override

    public void swim() {

        System.out.println("鱼可以游泳");

    }

}

public class Dog extends AnimalBase{

    public void eat() {

        System.out.println("狗可以吃饭");

    }



    @Override

    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("鸟可以睡觉");

    }



    @Override

    public void fly() {

        System.out.println("鸟可以飞");

    }

}


//Test测试类

public class Test {

    public static void main(String[] args) {

        Bird bird =new Bird();

        Fish fish =new Fish();

        Dog dog =new Dog();

        bird.sleep();

        bird.eat();

        bird.fly();

        fish.sleep();

        fish.eat();

        fish.swim();

        dog.sleep();

        dog.eat();

    }

}

运行结果

接口常见面试题（关于Arrays.sort方法）

一个常见的面试问题是关于Java中的Arrays.sort()方法的使用。Arrays.sort()方法用于排序数组中的元素，如果元素是基本数据类型，那么排序是直接进行的；如果是引用类型，则需要实现Comparable接口。

上述方法排序的是基本数据类型数据，如果排序的是引用类型数据，直接调用该方法则会发生报错，无法转化Comparable接口（该接口是用于排序的）

如果必须调用该方法对引用数据类型进行排序，可以自己实现Comparable接口，填写一个泛型Person。实现该接口的compareTo方法（该方法是实现排序的核心方法）排序利用数值进行排序。

（2）重写sort方法

另外一个常见的面试问题是重写sort方法，例如用冒泡排序算法实现一个自定义的Arrays2.sort()方法，传入一个Comparable类型的数组进行排序：

public class Arrays2 {



    // 5 7 4 2 0 3 1 6

    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 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;

    }

}


import java.util.Arrays;



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);

        Arrays2.sort(persons);

        System.out.println(Arrays.toString(persons));

    }

}

也可以使用快速排序的方法进行重写

package 排序;



public class Arrays2{

    public static void sort(Comparable[] arr) {

        if (arr == null || arr.length <= 1) {

            return;

        }

        quickSort(arr, 0, arr.length - 1);

    }

    private static void quickSort(Comparable[] arr, int low, int high) {

        if (low < high) {

            int pi = partition(arr, low, high);

            quickSort(arr, low, pi - 1);

            quickSort(arr, pi + 1, high);

        }

    }

    private static int partition(Comparable[] arr, int low, int high) {

        Comparable pivot = arr[high];

        int i = (low - 1);

        for (int j = low; j < high; j++) {

            if (arr[j].compareTo(pivot) <= 0) {

                i++;

                Comparable temp = arr[i];

                arr[i] = arr[j];

                arr[j] = temp;

            }

        }

        Comparable temp = arr[i + 1];

        arr[i + 1] = arr[high];

        arr[high] = temp;

        return i + 1;

    }

}

运行结果

通过本文的学习，我们了解到接口在Java中是如何用于定义类的行为规范的。接口使得Java类可以实现多重继承，并提供了一种更灵活的设计模式。通过合理使用接口和抽象类，开发者可以编写出更具扩展性和可维护性的代码。希望通过这些例子，能帮助你更好地理解接口的使用和设计