java基础---接口-CSDN博客

public interface A {
    public void run();
}

public interface Animal {
    public  void fly();
}

public class Cat implements A,Animal{
    @Override
    public void fly(){

    }

    @Override
    public void run() {

    }
}

以上代码定义了A和Animal两个接口，Cat类实现这两个接口以及其中的方法。

servlet

Servlet 是 Java 提供的一种技术，用于在服务器端处理客户端请求并生成响应。Servlet 的接口和生命周期的定义主要依赖于 Java EE 提供的规范。

Servlet 接口与生命周期

Servlet 接口定义了一个 Servlet 的生命周期，包括以下五个主要方法：

init(ServletConfig config): 初始化方法，在 Servlet 被创建时调用一次，用于初始化资源或执行一些启动任务。ServletConfig 对象用于提供配置参数。
service(ServletRequest req, ServletResponse res): 处理请求的方法，每次请求都会调用该方法。service() 方法的作用是根据客户端的请求类型（如 GET、POST 等），分发请求到相应的 doGet()、doPost() 方法。
destroy(): 销毁方法，当 Servlet 被卸载或服务器关闭时调用一次，用于释放资源。
getServletConfig(): 获取 Servlet 的配置对象 ServletConfig，该对象包含 Servlet 的初始化参数和 ServletContext。
getServletInfo(): 返回一个描述 Servlet 的信息（如版本号、作者等）的字符串。

GenericServlet 类

GenericServlet 是一个抽象类，部分实现了 Servlet 接口。GenericServlet 提供了一个通用的实现，通常作为自定义 Servlet 类的父类。

GenericServlet 实现了 init() 和 destroy() 方法，提供了 Servlet 的通用操作。
它还定义了一个抽象方法 service(ServletRequest req, ServletResponse res)，要求子类必须实现该方法。

HttpServlet 类

HttpServlet 是 GenericServlet 的子类，专门为处理 HTTP 请求而设计。HttpServlet 提供了以下常用的方法来处理不同类型的 HTTP 请求：

doGet(HttpServletRequest req, HttpServletResponse res): 处理 HTTP GET 请求。
doPost(HttpServletRequest req, HttpServletResponse res): 处理 HTTP POST 请求。
doPut(HttpServletRequest req, HttpServletResponse res): 处理 HTTP PUT 请求。
doDelete(HttpServletRequest req, HttpServletResponse res): 处理 HTTP DELETE 请求。
doHead(HttpServletRequest req, HttpServletResponse res): 处理 HTTP HEAD 请求。

HttpServlet 实现了 service() 方法，负责将请求分发到相应的 doXXX() 方法（如 doGet()、doPost() 等）。

抽象类设计的目的

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

抽象类（如 GenericServlet 和 HttpServlet）的设计目的是为了简化和优化接口的实现。具体而言：

简化接口实现: 抽象类可以部分实现接口中的方法，使子类无需实现所有方法，只需关注核心功能的实现。
提供默认行为: 抽象类可以提供接口的默认实现，方便子类继承和复用。
增强扩展性: 抽象类为子类提供了扩展的基础，可以通过继承和重写来实现更复杂的功能。

实例

public interface Animal {
    void eat();
    void sleep();
}

public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

public abstract class AnimalBase implements Animal {
    @Override
    public void eat() {
        System.out.println("This animal is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

public class Bird extends AnimalBase implements Flyable {
    @Override
    public void fly() {
        System.out.println("The bird is flying.");
    }
}

public class Fish extends AnimalBase implements Swimmable {
    @Override
    public void swim() {
        System.out.println("The fish is swimming.");
    }
}


public class Dog extends AnimalBase {
    
}


public class AnimalTest {
    public static void main(String[] args) {
        Bird bird = new Bird();
        Fish fish = new Fish();
        Dog dog = new Dog();

        // 测试鸟类
        System.out.println("Testing Bird:");
        bird.eat();
        bird.sleep();
        bird.fly();

        // 测试鱼类
        System.out.println("\nTesting Fish:");
        fish.eat();
        fish.sleep();
        fish.swim();

        // 测试狗类
        System.out.println("\nTesting Dog:");
        dog.eat();
        dog.sleep();
    }
}

输出结果：

Arrays.sort()

public class TestSort {
    public static void main(String[] args) {
        int[] arr = new int[]{9,2,5,1,8,3,7,4,6,0};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

基本数据类型可以用Arrays.sort()进行排序，但是引用数据类型呢？

实例

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
        return age - o.age;
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(22, 180);
        Person p2 = new Person(30, 170);
        Person p3 = new Person(17, 160);
        Person p4 = new Person(23, 181);
        Person[] persons = new Person[]{p1, p2, p3, p4};

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

输出结果：

[Person{age=17, height=160}, Person{age=22, height=180}, Person{age=23, height=181}, Person{age=30, height=170}]

如果想要对类中的对象进行排序，只需要实现Comparable接口，然后实现compareTo()方法。

利用快速排序实现sort()

public class QuickSort {
    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++;
            }


            if (i < j) {
                Comparable temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        arr[left] = arr[i];
        arr[i] = base;

        sort(arr, left, i - 1);

        sort(arr, i + 1, right);
    }

    public static void sort(Comparable[] arr) {
        sort(arr, 0, arr.length - 1);
    }
}

利用冒泡排序实现sort()

public class Bubble {
    //不管什么类型的对象，都可以向上转型成其父类的类型（多态的典型应用）
    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;
                }
            }
        }
    }
}