实验名称 实验三 抽象类与接口
实验目的
1. 深刻理解抽象类、接口的意义。
2. 熟练掌握抽象类和接口的定义、继承抽象类以及实现接口的方法。
3. 理解和掌握多态。
实验内容
（一）抽象类实验：项目源码中新建一个ahpu.shape的包，以下类放在这个包内
1. 定义一个抽象类Shape，包括：
（1）属性：颜色color（可用字符串类型用于输出模拟）
（2）方法：绘制图形的抽象方法draw()；对color操作的set方法和get方法。
2. 继承Shape类，设计抽象类RingShape，RingShape无需定义属性与方法。
3. 继承RingShape类，设计Circle类，实现具体的draw方法：可以用print方法模拟绘图，如
System.out.println("Draw a circle with color: " + this.getColor() );
4. 继承RingShape类，设计Ellipse类，实现具体的draw方法：可以用print方法模拟绘图。
5. 继承Shape类，设计Triangle类，实现具体的draw方法：可以用print方法模拟绘图。
6. 设计用于演示的类Demo，对Circle、Ellipse的draw方法进行功能测试。（或者使用JUnit进行测试
7. 定义一个用于求面积的接口IGeometry，求面积的方法为getArea()。
8. 继承Shape类，实现IGeometry接口，设计一个矩形类Rectangle。Rectangle有length、width两个属性。实现具体的draw方法，实现具体的求面积getArea方法。
9. 在Demo类中，或者使用JUnit测试Rectangle类的功能。
// ahpu.shape 包
package ahpu.shape;
// 抽象类 Shape
public abstract class Shape {
private String color;
public Shape(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public abstract void draw();
}
// 抽象类 RingShape
public abstract class RingShape extends Shape {
public RingShape(String color) {
super(color);
}
}
// 类 Circle
public class Circle extends RingShape {
public Circle(String color) {
super(color);
}
@Override
public void draw() {
System.out.println("Draw a circle with color: " + getColor());
}
}
// 类 Ellipse
public class Ellipse extends RingShape {
public Ellipse(String color) {
super(color);
}
@Override
public void draw() {
System.out.println("Draw an ellipse with color: " + getColor());
}
}
// 类 Triangle
public class Triangle extends Shape {
public Triangle(String color) {
super(color);
}
@Override
public void draw() {
System.out.println("Draw a triangle with color: " + getColor());
}
}
// 接口 IGeometry
public interface IGeometry {
double getArea();
}
// 类 Rectangle
public class Rectangle extends Shape implements IGeometry {
private double length;
private double width;
public Rectangle(String color, double length, double width) {
super(color);
this.length = length;
this.width = width;
}
@Override
public void draw() {
System.out.println("Draw a rectangle with color: " + getColor());
}
@Override
public double getArea() {
return length * width;
}
}
// 类 Demo
public class Demo {
public static void main(String[] args) {
Circle circle = new Circle("Red");
Ellipse ellipse = new Ellipse("Blue");
circle.draw();
ellipse.draw();
Rectangle rectangle = new Rectangle("Green", 4, 5);
System.out.println("Rectangle Area: " + rectangle.getArea());
}
}
（二）多态演示实验：项目源码中新建一个ahpu.vehicle的包，以下类放在这个包内
1. 设计抽象类Vehicle，类中定义了一个抽象方法transport( )表示运输。
2. 继承抽象类Vehicle，设计普通Java类Bus，Bus类中实现了transport( )，可以用print输出来模拟功能，如：
System.out.println("A bus is driving......");
3. 类似2，继承抽象类Vehicle，设计普通Java类Aircraft，Aircraft类中实现了transport( )，可以用print输出来模拟功能。
4. 设计驾驶员类Driver，
（1）类中有一个Vehicle类对象成员vehicle，并有set和get方法；
（2）类中有一个方法drive( )，调用了vehicle对象的transport方法，如：
public void drive() {
vehicle.transport();
}
5. 设计功能演示类Demo，对于Driver类对象driver，分别设置不同的交通工具类对象bus（Bus类对象）和aircraft（Aircraft类对象），演示不同交通工具对象的不同运输功能（transport方法的多态）。
// ahpu.vehicle 包
package ahpu.vehicle;
// 抽象类 Vehicle
public abstract class Vehicle {
public abstract void transport();
}
// 类 Bus
public class Bus extends Vehicle {
@Override
public void transport() {
System.out.println("A bus is driving......");
}
}
// 类 Aircraft
public class Aircraft extends Vehicle {
@Override
public void transport() {
System.out.println("An aircraft is flying......");
}
}
// 类 Driver
public class Driver {
private Vehicle vehicle;
public Vehicle getVehicle() {
return vehicle;
}
public void setVehicle(Vehicle vehicle) {
this.vehicle = vehicle;
}
public void drive() {
vehicle.transport();
}
}
// 类 Demo
public class Demo {
public static void main(String[] args) {
Driver driver = new Driver();
Vehicle bus = new Bus();
Vehicle aircraft = new Aircraft();
driver.setVehicle(bus);
driver.drive();
driver.setVehicle(aircraft);
driver.drive();
}
}
（三）接口及匿名内部类实验：项目源码中新建一个ahpu.innerclass的包，以下类放在这个包内
1. 设计接口（interface）Car，Car接口中定义三个方法：start()，accelerate()，brake()。
2. 设计智能机器人（即Car的驾驶员）类SmartRobot，类中定义
（1）属性：Car接口的对象car，以及相应的set方法和get方法；
（2）方法：drive()，模拟智能机器人的驾驶功能，具体代码可参考：
public void drive() {
car.start();
car.accelerate();
car.brake();
}
3. 设计功能演示类Demo，对于SmartRobot类对象robot，设置一个基于接口Car的匿名内部类对象，内部类中覆盖实现start()，accelerate()，brake()三个方法。
4. 演示robot对象的drive方法。
// ahpu.innerclass 包
package ahpu.innerclass;
// 接口 Car
public interface Car {
void start();
void accelerate();
void brake();
}
// 类 SmartRobot
public class SmartRobot {
private Car car;
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
public void drive() {
car.start();
car.accelerate();
car.brake();
}
}
// 类 Demo
public class Demo {
public static void main(String[] args) {
SmartRobot robot = new SmartRobot();
Car car = new Car() {
@Override
public void start() {
System.out.println("Car is starting...");
}
@Override
public void accelerate() {
System.out.println("Car is accelerating...");
}
@Override
public void brake() {
System.out.println("Car is braking...");
}
};
robot.setCar(car);
robot.drive();
}
}
实验程序及结果（附录）
思考
如何理解编译时多态与运行时多态？分别举一个例子。
关于编译时多态和运行时多态的理解：
编译时多态（也称为静态多态）是指在编译阶段确定使用哪个方法或类。它与静态类型有关，即编译器使用的类型信息。例如，通过编译时多态，编译器可以确定方法的签名，但无法确定实际调用的方法的具体实现。
Shape shape = new Circle("Red"); // 编译时多态，shape的静态类型是Shape
shape.draw(); // 在编译时确定使用Shape的draw方法
运行时多态（也称为动态多态）是指在程序运行时确定使用哪个方法或类。它与实际对象的类型有关，而不是静态类型。在运行时，Java会动态查找方法的实际实现。
Shape shape = new Circle("Red"); // 运行时多态，shape的实际类型是Circle
shape.draw(); // 在运行时确定使用Circle的draw方法
编译时多态主要涉及编译器的类型检查和方法签名确定，而运行时多态允许根据对象的实际类型调用相应的方法。