Java中的接口以及抽象类与接口的关系

上一篇已经讲了抽象类的基本概念和应用，这次来说一下抽象类与接口，在此之前先简单介绍一下接口。 

# Java中的接口（构建灵活的代码架构）

## 一、接口的概念
在Java中，接口是一种特殊的抽象类型，它只包含方法签名（方法名、参数类型和返回类型）和常量定义，而不包含方法体。接口使用`interface`关键字来定义，它定义了一组相关方法的规范，规定了实现该接口的类必须要做什么，但不关心具体怎么做。

## 二、接口的特性

### （一）方法都是抽象方法（Java 8之前）
1. **抽象方法定义**
   - 在Java 8之前，接口中的方法默认都是抽象方法，不需要使用`abstract`关键字来显式声明。例如：
   ```java
   public interface Drawable {
       void draw();
   }
   ```
   - 这里的`draw`方法没有方法体，任何实现`Drawable`接口的类都必须提供`draw`方法的具体实现。

### （二）可以包含常量
1. **常量定义**
   - 接口中的变量默认都是`public static final`的常量。例如：
   ```java
   public interface Constants {
       int MAX_VALUE = 100;
   }
   ```
   - 在接口中定义的常量可以被实现该接口的类直接访问，就像访问类的静态常量一样。

### （三）多实现
1. **与类的单继承对比**
   - 一个类只能继承一个父类，但可以实现多个接口。这使得Java中的接口成为实现多继承效果的一种方式。例如：
   ```java
   public interface Flyable {
       void fly();
   }

   public interface Swimmable {
       void swim();
   }

   public class Duck implements Flyable, Swimmable {
       @Override
       public void fly() {
           System.out.println("Duck is flying");
       }

       @Override
       public void swim() {
           System.out.println("Duck is swimming");
       }
   }
   ```
   - 这里的`Duck`类实现了`Flyable`和`Swimmable`两个接口，从而具备了飞行和游泳的能力。

### （四）接口的继承
1. **接口之间的继承关系**
   - 接口可以继承其他接口，这有助于构建接口的层次结构。例如：
   ```java
   public interface Animal {
       void eat();
   }

   public interface Mammal extends Animal {
       void giveBirth();
   }
   ```
   - 在这个例子中，`Mammal`接口继承了`Animal`接口，这意味着实现`Mammal`接口的类不仅要实现`giveBirth`方法，还要实现`eat`方法。

## 三、接口的示例

### （一）图形绘制接口
1. **接口定义**
   - 假设我们有一个`Drawable`接口，用于定义可绘制对象的行为：
   ```java
   public interface Drawable {
       void draw();
   }
   ```
2. **实现类示例**
   - 我们可以有`Circle`类实现这个接口：
   ```java
   public class Circle implements Drawable {
       @Override
       public void draw() {
           System.out.println("Drawing a circle");
       }
   }
   ```
   - 同样，`Rectangle`类也可以实现这个接口：
   ```java
   public class Rectangle implements Drawable {
       @Override
       public void draw() {
           System.out.println("Drawing a rectangle");
       }
   }
   ```

### （二）车辆接口
1. **接口定义**
   - 定义一个`Vehicle`接口，包含车辆的一些通用行为：
   ```java
   public interface Vehicle {
       void start();
       void stop();
       int getSpeed();
   }
   ```
2. **实现类示例**
   - 对于`Car`类：
   ```java
   public class Car implements Vehicle {
       private int speed;

       @Override
       public void start() {
           System.out.println("Car is starting");
       }

       @Override
       public void stop() {
           System.out.println("Car is stopping");
       }

       @Override
       public int getSpeed() {
           return speed;
       }
   }
   ```
   - 对于`Bike`类：
   ```java
   public class Bike implements Vehicle {
       private int speed;

       @Override
       public void start() {
           System.out.println("Bike is starting");
       }

       @Override
       public void stop() {
           System.out.println("Bike is stopping");
       }

       @Override
       public int getSpeed() {
           return speed;
       }
   }
   ```

接口在Java中是一种非常重要的概念，它提供了一种灵活的方式来定义行为规范，促进了代码的模块化、可维护性和可扩展性。通过接口，我们可以轻松地实现多态性，并且能够更好地组织和设计复杂的软件系统。

我们在此已经了解了接口以及抽象类了，接下来简单整理一下并讲一下抽象类与接口的关系。

# Java中的抽象类与接口

## 一、引言
在Java编程中，抽象类和接口是两个重要的概念，它们都为实现多态性、代码复用和模块化设计提供了有效的手段。然而，它们在语法、语义和使用场景上存在着一些区别。本文将详细介绍Java中的抽象类和接口，并通过具体的例子来帮助读者更好地理解。

## 二、抽象类

### （一）定义与特性
1. **定义**
   - 抽象类是使用`abstract`关键字声明的类。它不能被直接实例化，只能被继承。例如：
   ```java
   public abstract class Shape {
       // 类的成员变量和方法定义
   }
   ```
2. **包含抽象方法**
   - 抽象类可以包含抽象方法，抽象方法是没有方法体的方法，同样需要使用`abstract`关键字声明。例如：
   ```java
   public abstract class Animal {
       public abstract void makeSound();
   }
   ```
   - 子类必须实现抽象类中的抽象方法，除非子类也是抽象类。
3. **可包含非抽象方法和成员变量**
   - 抽象类除了抽象方法外，还可以包含普通的非抽象方法和成员变量。例如：
   ```java
   public abstract class Shape {
       protected String color;

       public Shape(String color) {
           this.color = color;
       }

       public String getColor() {
           return color;
       }

       public abstract double getArea();
   }
   ```
   - 在这个`Shape`抽象类中，`color`是成员变量，`getColor`是普通的非抽象方法，`getArea`是抽象方法。

### （二）示例
1. **图形类示例**
   - 我们定义一个`Shape`抽象类来表示各种图形：
   ```java
   public abstract class Shape {
       private String color;

       public Shape(String color) {
           this.color = color;
       }

       public String getColor() {
           return color;
       }

       public abstract double getArea();
   }
   ```
   - 然后定义`Circle`类作为`Shape`的子类：
   ```java
   public class Circle extends Shape {
       private double radius;

       public Circle(String color, double radius) {
           super(color);
           this.radius = radius;
       }

       @Override
       public double getArea() {
           return Math.PI * radius * radius;
       }
   }
   ```
   - 再定义`Rectangle`类：
   ```java
   public class Rectangle extends Shape {
       private double length;
       private double width;

       public Rectangle(String color, double length, double width) {
           super(color);
           this.length = length;
           this.width = width;
       }

       @Override
       public double getArea() {
           return length * width;
       }
   }
   ```

## 三、接口

### （一）定义与特性
1. **定义**
   - 接口是使用`interface`关键字定义的一种特殊类型。它只包含方法签名（方法名、参数类型和返回类型）和常量（默认是`public static final`），所有方法默认都是抽象方法（在Java 8之前）。例如：
   ```java
   public interface Drawable {
       void draw();
   }
   ```
2. **多实现特性**
   - 一个类可以实现多个接口，这与类的单继承形成对比。例如：
   ```java
   public interface Flyable {
       void fly();
   }

   public interface Swimmable {
       void swim();
   }

   public class Duck implements Flyable, Swimmable {
       @Override
       public void fly() {
           System.out.println("Duck is flying");
       }

       @Override
       public void swim() {
           System.out.println("Duck is swimming");
       }
   }
   ```
3. **接口继承**
   - 接口可以继承其他接口，从而构建接口的层次结构。例如：
   ```java
   public interface Animal {
       void eat();
   }

   public interface Mammal extends Animal {
       void giveBirth();
   }
   ```

### （二）示例
1. **图形绘制接口示例**
   - 定义`Drawable`接口：
   ```java
   public interface Drawable {
       void draw();
   }
   ```
   - 实现`Drawable`接口的`Circle`类：
   ```java
   public class Circle implements Drawable {
       @Override
       public void draw() {
           System.out.println("Drawing a circle");
       }
   }
   ```
   - 实现`Drawable`接口的`Rectangle`类：
   ```java
   public class Rectangle implements Drawable {
       @Override
       public void draw() {
           System.out.println("Drawing a rectangle");
       }
   }
   ```

## 四、抽象类与接口的区别与使用场景

### （一）区别
1. **语法**
   - 抽象类使用`abstract`关键字声明，接口使用`interface`关键字声明。
   - 抽象类可以有构造函数，接口不能有构造函数。
   - 抽象类中的方法可以有方法体（非抽象方法），接口中的方法在Java 8之前都是抽象方法。
   - 抽象类中的成员变量可以是各种访问修饰符，接口中的成员变量默认是`public static final`。
2. **语义**
   - 抽象类更多地体现了一种“is - a”的关系，是一种对事物的抽象。例如，`Circle`是一种`Shape`，所以`Circle`可以继承`Shape`抽象类。
   - 接口更多地体现了一种“has - a”的关系，是一种行为规范。例如，`Duck`具有飞行和游泳的能力，所以`Duck`实现`Flyable`和`Swimmable`接口。

### （二）使用场景
1. **抽象类使用场景**
   - 当存在一些通用的属性和行为，并且希望子类继承这些属性和行为时，适合使用抽象类。例如，在图形的例子中，`Shape`抽象类中的`color`属性和`getColor`方法可以被所有图形子类继承。
   - 当需要在类层次结构中提供一些默认的行为实现，但又希望子类可以重写这些行为时，抽象类是一个好的选择。
2. **接口使用场景**
   - 当需要定义一组行为规范，并且希望多个不相关的类都能实现这些行为时，使用接口。例如，`Drawable`接口可以被各种图形类、图像类等实现，只要它们具有可绘制的行为。
   - 当需要实现多继承效果时，使用接口。因为Java类只能单继承，但可以实现多个接口。

抽象类和接口在Java编程中都有着重要的地位，正确理解和运用它们可以使代码更加模块化、可维护和可扩展。