Java基础，接口

一、什么是接口

1、接口的定义

接口（Interface）是Java中的一种引用类型，它可以看作是一个规范，规定了实现它的类必须实现的一组方法。接口中的方法默认是抽象的，即没有方法体。此外，接口也可以包含常量。

一个类可以实现（implements）多个接口，设计接口的目的之一就是要实现java类的多继承

// 一个简单的接口示例
public interface Animal {
    void eat();
    void sleep();
}

在上面的代码中，Animal接口定义了两个方法eat()和sleep()，任何实现该接口的类都必须提供这些方法的实现。

2、接口的特性

• 多实现：一个类可以实现多个接口，这提供了更强大的设计灵活性。
• 抽象性：接口中的方法默认是抽象的，不包含方法体。
• 默认方法：从Java 8开始，接口可以包含带有方法体的默认方法。
• 静态方法：接口还可以包含静态方法，这些方法属于接口本身。

public interface Animal {
    void eat();
    void sleep();
    
    // Java 8 的默认方法
    default void run() {
        System.out.println("Running");
    }
    
    // Java 8 的静态方法
    static void breathe() {
        System.out.println("Breathing");
    }
}

二、Servlet接口与生命周期

Servlet是Java EE（现为Jakarta EE）中用于处理客户端请求并生成动态响应的组件。Servlet接口定义了实现Servlet的基本方法和规范。它们主要用于在Web应用程序中处理HTTP请求和响应。

1、Servlet接口

Servlet接口是所有Servlet必须实现的接口，定义了Servlet生命周期的五个核心方法：

• init(ServletConfig config): 初始化Servlet，执行一次。
• service(ServletRequest req, ServletResponse res): 处理请求和生成响应，执行多次。
• destroy(): 销毁Servlet，执行一次。
• getServletConfig(): 返回Servlet的配置对象。
• getServletInfo(): 返回Servlet的信息。

public class MyServlet implements Servlet {

    public void init(ServletConfig config) throws ServletException {
        // 初始化代码
        System.out.println("Servlet 初始化");
    }

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        // 处理请求和响应的代码
        System.out.println("Servlet 处理请求");
    }

    public void destroy() {
        // 销毁代码
        System.out.println("Servlet 销毁");
    }

    public ServletConfig getServletConfig() {
        return null; // 返回 ServletConfig 对象
    }

    public String getServletInfo() {
        return "MyServlet"; // 返回 Servlet 的信息
    }
}

2、Servlet生命周期

Servlet的生命周期由三部分组成：初始化、服务和销毁。

（1）、初始化阶段（init）：当Servlet第一次被加载时，init()方法会被调用。这通常是在应用服务器启动或第一次接收到客户端请求时发生的。init()方法用于执行Servlet的初始化工作，例如加载资源或建立数据库连接。

（2）、服务阶段（service）：每当客户端发送请求时，service()方法都会被调用。这个方法根据请求类型（GET、POST等）分派到具体的处理方法。对于HTTPServlet，通常是doGet()、doPost()等方法。

（3）、销毁阶段（destroy）：当应用服务器关闭或Servlet被卸载时，destroy()方法会被调用，用于清理资源，例如关闭数据库连接。

三、GenericServlet类

GenericServlet类是Servlet接口的实现类，它提供了一些默认的实现。GenericServlet是一个抽象类，开发者可以继承它并重写service()方法来处理请求，而不必实现其他不常用的方法。

import javax.servlet.*;
import java.io.IOException;

public abstract class GenericServletExample extends GenericServlet {

    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        // 处理请求和响应的代码
        res.getWriter().write("Hello from GenericServlet");
    }
}

GenericServlet类通常用于开发非HTTP协议的Servlet。如果你正在开发HTTP协议的Servlet，通常会选择HttpServlet类。

四、HttpServlet类

HttpServlet是GenericServlet的子类，专门用于处理HTTP协议的请求和响应。HttpServlet为每种HTTP方法（如GET、POST等）提供了对应的方法。

1、HttpServlet中的常用方法

（1）、doGet(HttpServletRequest req, HttpServletResponse res): 处理GET请求。

（2）、doPost(HttpServletRequest req, HttpServletResponse res): 处理POST请求。

（3）、doPut(HttpServletRequest req, HttpServletResponse res): 处理PUT请求。

（4）、doDelete(HttpServletRequest req, HttpServletResponse res): 处理DELETE请求。

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.IOException;

public class MyHttpServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        res.getWriter().write("Hello from HttpServlet");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        // 处理POST请求的代码
    }
}

2、抽象类设计的目的

GenericServlet和HttpServlet都是抽象类，这样设计的目的是为开发者提供一个可以扩展的基础实现，同时隐藏了复杂的细节。通过继承这些抽象类，开发者可以专注于处理具体的业务逻辑，而不用关心Servlet接口中每个方法的实现。

抽象类提供了一种模板模式，定义了通用的行为，让子类实现特定的细节。以HttpServlet为例，子类只需实现doGet()、doPost()等方法即可完成HTTP请求的处理，而init()、destroy()等方法的实现已经由HttpServlet完成了。

五、实例--经典题

1、定义一个动物接口 (Animal)

首先，我们定义一个Animal接口，该接口包含所有动物类共有的方法，如eat()和sleep()。

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

2、定义一个飞行的接口 (Flyable)

接着，定义一个Flyable接口，包含飞行的方法fly()。这个接口将由能够飞行的动物实现。

public interface Flyable {
    void fly();
}

3、 定义一个可游泳的接口 (Swimmable)

然后，定义一个Swimmable接口，包含游泳的方法swim()。这个接口将由能够游泳的动物实现。

public interface Swimmable {
    void swim();
}

4、定义一个抽象类 (AnimalBase)

接下来，定义一个抽象类AnimalBase，它实现了Animal接口并提供了eat()和sleep()方法的具体实现。

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.");
    }
}

5、实现具体的动物类

根据题目要求，实现具体的动物类，如Bird、Fish和Dog。每个类根据需要实现对应的接口。

// 实现 Flyable 接口并继承 AnimalBase 抽象类的 Bird 类
public class Bird extends AnimalBase implements Flyable {
    @Override
    public void fly() {
        System.out.println("The bird is flying.");
    }
}

// 实现 Swimmable 接口并继承 AnimalBase 抽象类的 Fish 类
public class Fish extends AnimalBase implements Swimmable {
    @Override
    public void swim() {
        System.out.println("The fish is swimming.");
    }
}

// 继承 AnimalBase 抽象类的 Dog 类
public class Dog extends AnimalBase {
    // Dog 类无需额外的方法实现，因为它既不飞也不游泳
}

 6、编写测试类

最后，编写一个测试类AnimalTest，在该类中创建这些动物的实例，并调用它们的方法展示行为。

public class AnimalTest {
    public static void main(String[] args) {
        // 创建Bird对象并调用方法
        Bird bird = new Bird();
        bird.eat();
        bird.sleep();
        bird.fly();

        // 创建Fish对象并调用方法
        Fish fish = new Fish();
        fish.eat();
        fish.sleep();
        fish.swim();

        // 创建Dog对象并调用方法
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
    }
}

7、运行结果

This animal is eating.
This animal is sleeping.
The bird is flying.
This animal is eating.
This animal is sleeping.
The fish is swimming.
This animal is eating.
This animal is sleeping.

这个动物管理系统包含了接口、多态、抽象类的使用，并通过测试类展示了各个动物类的行为。这种设计方式让代码更具扩展性和维护性，非常适合面向对象编程的思想。