Java基础——接口

一、定义：

        在Java中，接口（interface）是一种引用类型，类似于类，但只能包含常量、方法的声明和默认方法的实现。接口定义了一组方法，这些方法可以被实现接口的类提供具体的实现。接口的主要作用是定义类的行为规范（抽象类是对行为的抽象，模板），而不关心具体的实现细节。

二、特点：  

1. 抽象类是对行为的抽象，而接口是一种行为规范

   public interface Animal {
       public void run();//接口方法，没有方法体
   }

2. 接口当中只能使用抽象方法，所以也不用去写abstract关键字，默认也是public访问修饰符修饰的
3. 接口类只能用多态，不能创建对象
4. 一个类可以继承多个接口，但是必须写

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

三、设计接口的目的： 

1.     实现Java类的多继承
2. 更好的去实现接口当中所定义的方法。

四、接口和抽象类的使用：

 自定义的servlet类，让它继承于,HttpServlet继承于GenericServlet，GenericServlet实现Servlet接口。

功能体现：

1. Servlet接口：定义servlet的生命周期定义
2. GenericServlet：实现了当前除了service方法以外的方法，其他任何一个方法都是在这里边进行实现的
3. HttpServlet：实现了service方法
4. 自定义的servlet类：需要去继承的HttpServlet话，就可以使用到上边这一系列的东西

五、Comparable 接口：

1.定义：

  Comparable 接口是 Java 中用于对象自然排序的接口。它允许对象进行比较，以便可以对这些对象进行排序。Comparable 接口定义了一个方法 compareTo(To)，该方法用于比较当前对象与指定对象的顺序。 

2.实例：

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(20,180);
        Person p2 = new Person(23,185);
        Person p3 = new Person(21,174);

        Person[] persons = new Person[]{p1,p2,p3};
        Arrays.sort(persons);
        System.out.println(Arrays.toString(persons));
    }
}

import java.util.Comparator;

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) {
        //从小到大 return age - o.age;
        //从大到小 return o.age - age;
        return o.age - 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){
                    Comparable temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }

    }
}

六、抽象方法和接口方法的实现规则：

抽象类中的抽象方法

• 抽象方法：在抽象类中定义的抽象方法没有方法体。抽象类可以有普通方法（即有方法体的方法），但它至少需要有一个抽象方法才能被声明为抽象类。
• 实现要求：任何非抽象的子类（即具体的类）必须实现抽象类中定义的所有抽象方法。如果一个类继承了一个抽象类但没有实现所有的抽象方法，那么这个子类也必须声明为抽象类。

  abstract class Animal {
      abstract void makeSound(); // 抽象方法，没有方法体
  
      void sleep() { // 普通方法
          System.out.println("Sleeping...");
      }
  }
  
  class Dog extends Animal {
      @Override
      void makeSound() {
          System.out.println("Woof!");
      }
  }
  

  接口中的方法

• 接口中的抽象方法：接口中的所有方法默认都是抽象的（直到Java 8），不允许有方法体。实现接口的类必须提供接口中所有抽象方法的实现。
• 默认方法和静态方法：从Java 8开始，接口可以包含默认方法和静态方法，这些方法可以有方法体。实现接口的类不需要重写这些默认方法，但可以选择重写它们。

  interface Animal {
      void makeSound(); // 抽象方法，没有方法体
  
      default void sleep() { // 默认方法，有方法体
          System.out.println("Sleeping...");
      }
  }
  
  class Dog implements Animal {
      @Override
      public void makeSound() {
          System.out.println("Woof!");
      }
  
      // 可以选择重写默认方法
      @Override
      public void sleep() {
          System.out.println("Dog is sleeping...");
      }
  }