<think>我们讨论
Java中的接口（Interface）和
抽象类（Abstract Class），以及它们如何实现
多态（Polymorphism）。
首先，接口和
抽象类都是
Java中实现抽象和
多态的重要机制。它们都不能被实例化，主要用于定义规范或者行为约定。
一、接口（Interface）：
1. 定义：接口是一种完全抽象的类，它允许我们定义抽象方法（在
Java 8之后，接口也可以有默认方法和静态方法）。接口中的变量默认为public static
final，方法默认为public abstract（在
Java 8之前，只能是抽象方法）。
2. 目的：接口主要用于定义一组行为规范，让不同的类来实现这些行为，从而实现
多态。
二、
抽象类（Abstract Class）：
1. 定义：
抽象类是一种不能被实例化的类，它用abstract关键字修饰。
抽象类中可以包含抽象方法（没有实现的方法）和非抽象方法（有具体实现的方法）。
抽象类也可以包含成员变量。
2. 目的：
抽象类用于部分实现一个类，而将一些方法留给子类来实现。它常用于有多个类具有共同特征和行为的场景。
三、接口与
抽象类的区别：
1. 一个类可以实现多个接口，但只能继承一个
抽象类（
Java单继承）。
2. 接口中只能定义常量（public static
final）和抽象方法（在
Java 8之前），而
抽象类可以有普通成员变量和具体方法。
3. 接口中的方法默认是public，而
抽象类中的方法可以是任意访问修饰符。
4. 从设计角度看：接口强调功能（行为）的契约，而
抽象类强调代码的复用和扩展。
四、
多态（Polymorphism）：
多态是指同一个行为具有多个不同表现形式或形态的能力。在
Java中，
多态主要通过以下两种方式实现：
1. 方法重载（编译时
多态）：同一个类中，方法名相同，参数列表不同（个数、类型、顺序）。
2. 方法重写（运行时
多态）：子类重写父类的方法，通过父类引用指向子类对象来实现。
接口和
抽象类都是实现运行时
多态的重要方式。我们可以通过声明接口或
抽象类的引用变量，指向具体实现类的对象，从而在运行时调用具体实现类的方法。
下面通过代码示例说明：
1. 接口示例：
interface Animal {
void makeSound(); // 抽象方法
}
class Dog implements Animal {
public void makeSound() {
System.out.println("Bark");
}
}
class Cat implements Animal {
public void makeSound() {
System.out.println("Meow");
}
}
public class Test {
public static void main(String[] args) {
Animal myDog = new Dog(); //
多态：Animal引用指向Dog对象
Animal myCat = new Cat(); //
多态：Animal引用指向Cat对象
myDog.makeSound(); // 输出 Bark
myCat.makeSound(); // 输出 Meow
}
}
2.
抽象类示例：
abstract class Shape {
abstract double area(); // 抽象方法
void display() {
System.out.println("This is a shape.");
}
}
class Circle extends Shape {
double radius;
Circle(double r) { radius = r; }
double area() {
return Math.PI * radius * radius;
}
}
class Rectangle extends Shape {
double length, width;
Rectangle(double l, double w) {
length = l;
width = w;
}
double area() {
return length * width;
}
}
public class Test {
public static void main(String[] args) {
Shape s1 = new Circle(2.0);
Shape s2 = new Rectangle(3.0, 4.0);
s1.display(); // 输出：This is a shape.
System.out.println(s1.area()); // 计算并输出圆的面积
s2.display();
System.out.println(s2.area()); // 计算并输出矩形的面积
}
}
五、总结：
接口和
抽象类都是实现
多态的方式。接口更注重行为的抽象，而
抽象类则提供了部分实现，允许子类继承和扩展。在实际编程中，我们应该根据需求选择使用接口还是
抽象类。
§§相关问题§§:
1.
Java 8中接口的默认方法和静态方法是什么？
2.
抽象类可以有构造函数吗？如果可以，有什么作用？
3. 在什么情况下应该使用接口？在什么情况下应该使用
抽象类？
4. 接口和
抽象类在实现
多态时有什么异同点？
</think>### 接口、
抽象类与
多态
#### 1. **接口（Interface）**
**定义与特点**：
- 完全抽象的契约，仅包含方法签名（
Java 8+ 支持默认方法/静态方法）
- 变量默认为 `public static
final`
- 类通过 `implements` 实现接口，**可多实现**
```
java
interface Flyable {
void fly(); // 隐式 public abstract
default void land() { // 默认方法
System.out.println("Landing...");
}
}
```
#### 2. **
抽象类（Abstract Class）**
**定义与特点**：
- 用 `abstract` 声明，可包含抽象方法和具体方法
- 可定义成员变量、构造器、静态方法
- 类通过 `extends` 继承，**单继承**
```
java
abstract class Animal {
protected String name;
public Animal(String name) { this.name = name; }
abstract void sound(); // 抽象方法
void sleep() { // 具体方法
System.out.println(name + " is sleeping");
}
}
```
#### 3. **
多态（Polymorphism）**
**核心机制**：
- **编译时类型** vs **运行时类型**：父类/接口引用指向子类对象
- 通过方法重写（Override）实现动态绑定
```
java
// 示例：接口
多态
Flyable bird = new Bird();
bird.fly(); // 运行时调用 Bird 的 fly()
// 示例：
抽象类多态
Animal dog = new Dog("Rex");
dog.sound(); // 运行时调用 Dog 的 sound()
```
---
### 关键区别
| **特性** | **接口** | **
抽象类** |
|------------------------|------------------------------|--------------------------|
| 实例化 | ❌ 不能实例化 | ❌ 不能实例化 |
| 方法实现 | 默认方法（
Java 8+） | 可含具体方法 |
| 变量 | 只能是常量 | 任意成员变量 |
| 构造器 | ❌ 无构造器 | ✅ 可定义构造器 |
| 继承机制 | 多实现（`implements A, B`） | 单继承（`extends`） |
| 设计目的 | 定义行为契约 | 代码复用 + 部分实现 |
---
### 典型应用场景
1. **接口**
- 需要多继承行为（如 `class Duck implements Flyable, Swimmable`）
- 定义跨类别的通用能力（如 `Serializable`）
2. **
抽象类**
- 共享基础代码（如游戏中的 `AbstractCharacter` 封装公共移动逻辑）
- 控制子类扩展方式（模板方法模式）
3. **
多态**
- 统一处理不同子类：`List<Animal> zoo = Arrays.asList(new Dog(), new Cat())`
- 降低耦合：模块依赖接口而非具体实现
---
### 完整代码示例
```
java
// 接口定义
interface Flyable {
void fly();
}
//
抽象类定义
abstract class Animal {
protected String name;
public Animal(String name) { this.name = name; }
abstract void makeSound();
}
// 具体实现类
class Bird extends Animal implements Flyable {
public Bird() { super("Sparrow"); }
@Override
public void fly() {
System.out.println(name + " flapping wings");
}
@Override
void makeSound() {
System.out.println("Chirp!");
}
}
// 测试
多态
public class PolymorphismDemo {
public static void main(String[] args) {
// 接口
多态
Flyable flyingObj = new Bird();
flyingObj.fly(); // 输出: Sparrow flapping wings
//
抽象类多态
Animal animal = new Bird();
animal.makeSound(); // 输出: Chirp!
}
}
```
扫一扫
1160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
