Java基础——自学习使用(接口)

一、接口的定义

        抽象类是对行为的抽象，相当于是一种模板设计。接口是对行为的一种规范（定义）。

        Java的接口（Interface）是一种引用类型，它是方法声明的集合，这些方法都是抽象的，即只有声明没有实现。接口是一种形式上的契约，它规定了实现接口的类必须提供哪些方法，但不提供这些方法的实现细节。接口是Java实现多态性的一种重要手段，它允许我们定义一组方法规范，然后由不同的类去实现这套规范，从而实现了功能的多样性和扩展性。

二、接口的特点      

        1、接口当中只能使用抽象方法，所以也不需要写abstract关键字，默认也是public访问修饰符所修饰的。
        2、接口类不能创建对象，只能用多态。
        3、一个类可以继承（实现）多个接口，实现接口就意味着继承接口的所有方法。（设计接口的目的之一就是实现java类的多继承）

三、接口的使用

        

        servlet项目中，任何一个servlet都会继承HttpServlet。点进HttpServlet（抽象类）中发现其继承GenericServlet（抽象类）点进GenericServlet发现其实现了Servlet、ServletConfig、Serializable三个接口，进入到Servlet接口当中，发现有五个方法。

       

        其中创建、服务、销毁三个方法最重要（生命周期），servlet接口定义当前servlet的生命周期，从创建到销毁的整个流程。GenericServlet发现其实现除service的其他关于生命周期的方法。HttpServlet实现了service的方法。抽象类的设计目的之一就是更好的实现接口当中定义的方法。

四、接口常见面试题

（引用类型排序）

        如果让某一个对象进行排序可以自己实现Comparable接口，实现该接口的compareTo方法。该方法是用于排序的。

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

如果调用该方法对引用数据类型进行排序，实现Comparable接口，填写一个泛型Person(随便起)。实现该接口的compareTo方法（该方法是实现排序的核心方法）排序利用数值进行排序。

（重写sort方法）

①用冒泡排序实现，创建一个Arraya2类，编写一个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;
    }
}

五、习题

//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{
  public void eat(){
      System.out.println("喝饮料");
  }
    public void sleep(){
        System.out.println("睡觉");
    }
}

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

public class Dog extends AnimalBase{
}

public class Bird extends AnimalBase implements Flyable{
    @Override
    public void flay() {
        System.out.println("鸟会飞");
    }
}

//Test测试类
public class Test {
    public static void main(String[] args) {
        Bird bird =new Bird();
        Dog dog =new Dog();
        Fish fish=new Fish();
        bird.eat();
        bird.sleep();
        bird.flay();
        System.out.println("*************");
        dog.sleep();
        dog.eat();
        System.out.println("*************");
        fish.eat();
        fish.sleep();
        fish.swim();
    }
}