【Java 基础】10 抽象类和接口
面向对象的两大利器抽象类和接口，接下来就逐一举例说明一下。
1. 抽象类
抽象类是一种特殊的类，它不能被实例化，只能被用作其他类的基类。
抽象类的主要作用是为子类提供一个通用的模板，并规定子类必须实现的抽象方法。
// 抽象类
abstract class Shape {
// 普通方法
public void display() {
System.out.println("This is a shape.");
}
// 抽象方法，子类必须实现
abstract double area();
}
在上述例子中，Shape 是一个抽象类，它包含了一个普通方法 display() 和一个抽象方法 area()。抽象方法没有具体的实现，而是由子类来实现。
继承抽象类：
子类继承抽象类时，必须实现抽象类中的所有抽象方法，否则子类也必须声明为抽象类。
// 子类继承抽象类
class Circle extends Shape {
private double radius;
// 构造方法
public Circle(double r) {
radius = r;
}
// 实现抽象方法
@Override
double area() {
return Math.PI * radius * radius;
}
}
使用抽象类的实例：
虽然抽象类不能被实例化，但可以通过子类的实例进行引用。
public class Main {
public static void main(String[] args) {
Circle circle = new Circle(5.0);
circle.display(); // 调用抽象类中的普通方法
double area = circle.area(); // 调用抽象类中的抽象方法
System.out.println("Area of the circle: " + area);
}
}
在这个例子中，我们通过 Circle 类的实例来调用抽象类 Shape 中的方法。
抽象类的主要作用是定义一种通用的模板，让子类去实现具体的细节。它是面向对象编程中重要的概念，用于建立类之间的层次结构。
2. 接口
接口（Interface）是一种抽象类型，它定义了一组抽象方法，但是不包含具体的实现。
接口可以被类实现，使得类能够遵循接口定义的契约，实现接口的类必须提供接口中定义的所有方法。
创建接口：
使用 interface 关键字可以定义一个接口。接口中可以包含抽象方法、常量和默认方法。
// 定义一个接口
interface Shape {
// 抽象方法
double area();
// 常量
double PI = 3.14;
// 默认方法
default void display() {
System.out.println("This is a shape.");
}
}
在上述例子中，Shape 是一个接口，定义了一个抽象方法 area()、一个常量 PI 和一个默认方法 display()。
实现接口：
类通过关键字 implements 实现接口，并提供接口中定义的所有方法的具体实现。
// 实现接口
class Circle implements Shape {
private double radius;
// 构造方法
public Circle(double r) {
radius = r;
}
// 实现抽象方法
@Override
public double area() {
return PI * radius * radius;
}
}
在上述例子中，Circle 类通过 implements 实现了 Shape 接口，并提供了 area() 方法的具体实现。
使用接口：
可以通过接口类型引用实现该接口的对象。
public class Main {
public static void main(String[] args) {
Circle circle = new Circle(5.0);
circle.display(); // 调用接口中的默认方法
double area = circle.area(); // 调用接口中的抽象方法
System.out.println("Area of the circle: " + area);
}
}
在这个例子中，我们通过 Shape 接口类型引用了 Circle 类的对象。
接口的特性：
- 一个类可以实现多个接口。
- 接口可以继承（extends）其他接口。
- 接口中的方法默认是公有的（public），不需要使用
public修饰符。 - 接口中的字段默认是常量，必须使用
public static final修饰符。
接口在Java中是一种非常重要的工具，它提供了一种机制，使得不同的类可以实现共同的行为。这种灵活性使得代码更容易维护和扩展。