简介：本实验将深入探讨面向对象编程在Java中的应用，通过创建代表正方形和立方体的类来实现几何形状的计算方法。学生将学习如何定义基类、子类、属性和方法，以及实现继承和接口使用。实验要求设计并实现一个通用的Shape基类及其子类Square和Cube，包括计算面积、体积和表面积的方法。实验还包括使用Resizable接口来动态调整形状大小。通过这个实验，学生将加深对Java面向对象编程的理解，为解决实际问题打下坚实基础。 
1. 面向对象编程核心概念
面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它使用“对象”来设计软件。对象可以包含数据，以字段（通常称为属性或成员变量）的形式存在，以及代码，以方法的形式存在。这一章节，将深入浅出地探讨OOP的四个核心概念：封装、继承、多态和抽象。
1.1 封装
封装是OOP的基础，它允许将对象的状态（属性）和行为（方法）捆绑成一个单独的单元。通过封装，对象的内部状态可以被保护，不被外部直接访问，而是通过一系列预定义的接口与外界交互。封装不仅防止了外部代码对对象内部状态的非法访问，还增加了代码的可维护性。
public class Person {
private String name; // 封装了name属性
private int age; // 封装了age属性
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
在上述Java类示例中， name 和 age 属性被私有化（使用 private 关键字），只能通过公开的方法（例如 setName() 和 getName() ）访问和修改，这就是封装。
1.2 继承
继承是面向对象语言中一种创建新类的方式，新创建的类可以继承一个或多个已存在的类的特性。在继承关系中，被继承的类称为父类或超类，而新创建的类称为子类。继承使得子类具有父类的所有属性和方法，子类还可以添加自己特有的属性和方法或重写父类的方法。
class Animal {
void eat() {
System.out.println("This animal is eating");
}
}
class Dog extends Animal {
void bark() {
System.out.println("The dog is barking");
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // 继承自Animal类的方法
dog.bark(); // Dog类特有的方法
}
}
在上面的例子中， Dog 类继承了 Animal 类，因此可以使用 Animal 类中的 eat() 方法，并添加了自己的 bark() 方法。
1.3 多态
多态是指允许不同类的对象对同一消息做出响应。换言之，多态允许将子类的对象当作父类的对象来处理。多态性是通过继承和接口实现的。在Java中，多态性可以由方法重载和方法重写体现。
class Vehicle {
void run() {
System.out.println("Vehicle is running");
}
}
class Car extends Vehicle {
@Override
void run() {
System.out.println("Car is running safely");
}
}
public class Test {
public static void main(String[] args) {
Vehicle vehicle = new Car(); // 多态的体现
vehicle.run(); // 输出 "Car is running safely"
}
}
在这个例子中， Car 类重写了 Vehicle 类的 run() 方法。在 main 方法中，通过多态的特性，我们将 Car 类的对象赋值给 Vehicle 类的引用，然后调用 run() 方法，输出的是 Car 类重写后的方法内容。
面向对象编程的最后一个核心概念是抽象，将在后续章节中详细介绍。以上，我们介绍了封装、继承和多态这三个基础概念，它们是面向对象设计中不可或缺的一部分，能够帮助开发者编写出结构清晰、易于维护和扩展的代码。
2. Java类的设计与实现
2.1 Java类的基本结构
Java类是面向对象编程的基础，它允许开发者封装数据和操作数据的方法。在这一部分，我们会探讨Java类的组成，理解成员变量和构造方法的作用，以及如何初始化一个类。
2.1.1 类的定义与成员变量
一个简单的Java类定义如下所示：
public class Person {
// 成员变量定义
private String name;
private int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 成员方法
public void introduce() {
System.out.println("My name is " + name + " and I am " + age + " years old.");
}
}
在这个例子中， Person 类有两个成员变量： name 和 age 。这些变量定义了 Person 对象的状态。成员变量是类的一部分，它们可以在对象的整个生命周期内持有值，并且可以在类的任何方法中被访问或修改。
参数说明与代码解释
-
private String name：这是对类内成员变量的访问修饰符，private表示该变量只能在类的内部被访问。String是声明变量类型的关键字，name是变量名。 -
public Person(String name, int age)：这是一个构造方法，它与类同名。构造方法用于初始化新创建的对象。在这个例子中，构造方法接收一个String类型的name和一个int类型的age作为参数，并使用this关键字将这些值赋给对象的成员变量。 -
introduce()：这是一个成员方法，允许Person对象提供自我介绍。它被声明为public，意味着这个方法可以在类外部被调用。
2.1.2 构造方法与初始化
在Java中，每个类至少有一个构造方法。如果开发者没有显式地定义任何构造方法，Java编译器会提供一个默认的无参构造方法。当创建一个类的实例时，构造方法被用来初始化对象。
public class Main {
public static void main(String[] args) {
// 使用构造方法创建Person对象
Person person = new Person("Alice", 30);
// 调用成员方法
person.introduce();
}
}
在上面的代码中， Main 类的 main 方法演示了如何使用 Person 类的构造方法来创建一个对象实例，并通过调用 introduce 方法来输出这个人的介绍。
参数说明与代码逻辑分析
-
Person person = new Person("Alice", 30);：这行代码执行了三个操作： - 调用
Person类的构造方法创建了一个Person类型的对象。 -
new关键字负责在堆内存中分配内存给新对象。 - 将创建的对象引用赋值给局部变量
person。 -
person.introduce();：通过引用person，我们可以访问和调用Person对象的introduce方法。
2.2 类的方法设计
类的方法是类的动态行为的载体，方法定义了对象可以执行的操作。本节将探讨Java中方法的声明和调用、访问修饰符的作用域以及方法的重载与重写。
2.2.1 方法的声明与调用
方法是包含一系列语句的代码块，它们定义了对象能执行的操作。方法的声明包括访问修饰符、返回类型、方法名、括号内的参数列表和方法体。方法体由一系列的语句组成，可以返回一个值。
public class Calculator {
// 方法声明
public int add(int a, int b) {
return a + b; // 返回两个数的和
}
public void printResult(int result) {
System.out.println("The result is: " + result);
}
}
参数说明与代码逻辑分析
-
public int add(int a, int b)：这里声明了一个名为add的方法，它接受两个int类型的参数a和b，并返回这两个参数的和，即它们的类型是int。 -
System.out.println("The result is: " + result);：这个语句在printResult方法中使用，用于在控制台输出结果。
2.2.2 访问修饰符的作用域
访问修饰符在Java中用来控制类、方法或变量的访问级别。Java提供了四种访问级别： private 、 default （没有修饰符时的包内访问）、 protected 、和 public 。每种访问级别对类、构造器、方法和变量的可见性都有不同的影响。
class Utils {
private static final int SECRET_NUMBER = 42;
// default 访问级别，只能在同一个包内访问
void doSomething() {
// 方法体
}
protected void doProtected() {
// 可以在子类和同一个包内访问
}
public static void publicMethod() {
// 可以在任何地方访问
}
}
参数说明与逻辑分析
-
private static final int SECRET_NUMBER = 42;：private修饰符表示SECRET_NUMBER变量只能在Utils类内部访问。由于变量前面有static修饰符，这表示这是一个类级别的变量，而不是对象级别的变量。 -
void doSomething()：没有修饰符表示包访问级别，这个方法可以被同一个包内的其他类访问。 -
protected void doProtected()：protected访问级别允许类的成员被同一个包内的其他类以及所有子类访问。 -
public static void publicMethod()：public修饰符表示类成员可以被任何其他类访问。
2.2.3 方法重载与重写
方法重载（Overloading）和方法重写（Overriding）是Java中多态性的两种主要形式。方法重载允许一个类拥有多个同名方法，但这些方法必须有不同的参数列表。方法重写是子类提供特定实现版本的方法，用于替换从父类继承的方法。
class Animal {
public void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
// 方法重写
@Override
public void makeSound() {
System.out.println("Dog barks");
}
// 方法重载
public void makeSound(int times) {
for (int i = 0; i < times; i++) {
System.out.println("Dog barks " + (i + 1) + " times");
}
}
}
参数说明与代码逻辑分析
-
Dog extends Animal：Dog类继承自Animal类，它可以在继承的基础上进行扩展。 -
@Override：这是一个注解，它告诉编译器我们打算重写父类中的一个方法。 -
public void makeSound(int times)：这是makeSound方法的一个重载版本，它通过添加一个额外的int类型的参数来区分。 - 在调用
makeSound时，根据参数列表的不同，编译器会决定调用哪个版本的方法。
2.3 类的实例化与对象操作
类的实例化涉及创建类的对象，并通过这些对象进行操作。本节将介绍对象创建过程、成员访问与赋值，以及对象生命周期的管理。
2.3.1 创建对象的过程
对象的创建涉及内存分配和构造方法的调用。在Java中，使用 new 关键字来创建对象的实例。
Dog myDog = new Dog();
这行代码做了三件事：
- 在堆内存中分配了足够的空间给
Dog类的实例。 - 调用
Dog类的构造器初始化对象。 - 将对象的引用赋值给引用变量
myDog。
2.3.2 对象成员的访问与赋值
对象的成员变量可以通过对象引用来访问和修改。成员变量包含了状态信息，而方法则定义了行为。
public class Main {
public static void main(String[] args) {
Dog myDog = new Dog();
// 访问和修改成员变量
myDog.name = "Buddy"; // 假设Dog类有一个名为name的成员变量
myDog.setAge(4); // 假设Dog类有一个名为setAge的方法来设置年龄
// 调用方法
myDog.makeSound();
}
}
在这个例子中， name 和 setAge 分别是 Dog 类的成员变量和方法，我们通过 myDog 对象来访问和修改它们。
2.3.3 对象生命周期的管理
在Java中，对象的生命周期从创建开始，直到垃圾回收器回收其内存。当一个对象不再被任何引用变量引用时，它就可以被垃圾回收器回收。对象的创建和销毁都是自动进行的，但开发者可以使用 System.gc() 方法来建议进行垃圾回收。
public class Main {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog = null; // 解除引用
// 建议垃圾回收器回收Dog对象
System.gc();
}
}
参数说明与代码逻辑分析
-
myDog = null;：这行代码将myDog的引用设置为null，这表示我们不再需要这个对象。但是，对象是否被回收，取决于垃圾回收器的决定。 -
System.gc();：调用System.gc()方法建议虚拟机进行垃圾回收，但并不保证立即执行垃圾回收操作。
以上就是Java类设计与实现的第二章内容。通过本章的介绍，我们了解了Java类的基本结构、方法的设计，以及如何进行类的实例化和对象的操作。在下一章中，我们将深入探讨继承和方法覆盖的原理，以及多态性的应用。
3. 继承与方法覆盖
3.1 继承的原理与实现
继承是面向对象编程中的一项重要特性，它允许新创建的类（子类）继承另一个类（超类）的属性和方法。这种机制极大地提高了代码的复用性，同时也是面向对象编程中多态性的基础。
3.1.1 继承的基本语法
在Java中，继承是通过关键字 extends 来实现的。子类继承超类后，不仅可以使用超类中定义的成员变量和方法，还可以根据需要覆盖或扩展超类的功能。例如：
class SuperClass {
void display() {
System.out.println("SuperClass method.");
}
}
class SubClass extends SuperClass {
// 这里可以使用SuperClass的display方法，也可以覆盖它
void display() {
System.out.println("SubClass method.");
}
}
上述代码中， SubClass 通过 extends 关键字继承了 SuperClass ，因此 SubClass 对象可以调用 display() 方法，输出的是"SubClass method."，因为它覆盖了父类的方法。
3.1.2 超类与子类的关系
在继承关系中，超类也被称为父类，子类也被称为派生类。子类在继承超类的同时，可以添加自己的成员变量和方法，或者对继承的成员变量和方法进行扩展。同时，子类还可以定义自己的构造方法，但在构造方法中，必须先调用超类的构造方法，这可以通过 super 关键字实现。
class SuperClass {
SuperClass() {
System.out.println("SuperClass constructor.");
}
}
class SubClass extends SuperClass {
SubClass() {
super(); // 调用超类的构造方法
System.out.println("SubClass constructor.");
}
}
这段代码中，当创建 SubClass 对象时，首先会输出"SuperClass constructor."，这是因为 SubClass 的构造器通过 super() 调用了 SuperClass 的构造器。之后输出"SubClass constructor."。
3.2 方法覆盖机制
方法覆盖（Method Overriding）是指子类提供与超类中某个方法签名相同的实现。这是实现多态性的一种方式，允许子类改变或扩展超类的行为。
3.2.1 覆盖规则与要求
为了正确地覆盖方法，必须遵循以下规则： - 子类中的方法签名必须与超类中的相同。 - 子类方法不能缩小超类方法的访问权限。 - 子类方法的返回类型可以是超类方法返回类型的子类型。 - 子类方法不能抛出超过超类方法所声明的异常。
class Animal {
String name;
void eat() {
System.out.println("Animal is eating.");
}
}
class Dog extends Animal {
@Override
void eat() {
System.out.println("Dog is eating meat.");
}
}
在这个例子中， Dog 类覆盖了 Animal 类的 eat() 方法。需要注意的是， eat() 方法的签名在子类中与超类中保持一致。
3.2.2 super关键字的使用
super 关键字不仅可以用来调用超类的构造器，还可以用来引用超类的成员变量和方法。在子类方法覆盖的情况下，如果需要调用超类中被覆盖的方法，可以使用 super 关键字。
class Animal {
void eat() {
System.out.println("Animal is eating something.");
}
}
class Dog extends Animal {
void eat() {
super.eat(); // 调用超类的eat方法
System.out.println("Dog is eating meat.");
}
}
这段代码中， Dog 类的 eat() 方法通过 super.eat() 调用了 Animal 类的 eat() 方法，然后输出了子类特有的信息。
3.3 多态性的应用
多态性是面向对象编程的核心概念之一，它允许我们用父类类型的引用指向子类的对象，并通过该引用调用子类重写的方法。
3.3.1 多态的定义与实现
多态指的是允许不同类的对象对同一消息做出响应。多态可以分为编译时多态和运行时多态。编译时多态是通过方法重载实现的，而运行时多态则是通过方法覆盖实现的。
class Animal {
void eat() {
System.out.println("Animal is eating.");
}
}
class Dog extends Animal {
@Override
void eat() {
System.out.println("Dog is eating meat.");
}
}
class Cat extends Animal {
@Override
void eat() {
System.out.println("Cat is eating fish.");
}
}
public class TestPolymorphism {
public static void main(String[] args) {
Animal animal = new Animal();
animal.eat(); // 输出 Animal is eating.
animal = new Dog();
animal.eat(); // 输出 Dog is eating meat.
animal = new Cat();
animal.eat(); // 输出 Cat is eating fish.
}
}
在这个例子中， Animal 类的引用 animal 可以指向 Animal 、 Dog 和 Cat 的对象。当调用 eat() 方法时，实际执行的是引用所指向对象的方法，这就是运行时多态。
3.3.2 引用类型的向上转型与向下转型
向上转型是多态的一种表现形式，指的是子类对象可以自动地转换为父类类型的引用。向下转型则需要使用显式类型转换，用于将父类类型的引用转换为子类类型的对象。
Animal animal = new Dog(); // 向上转型
Dog dog = (Dog) animal; // 向下转型，需要强制类型转换
在进行向下转型时，必须确保引用的对象实际上是目标类的实例，否则会抛出 ClassCastException 。为了避免这种情况，可以使用 instanceof 关键字进行类型检查。
if (animal instanceof Dog) {
Dog dog = (Dog) animal; // 安全的向下转型
}
通过以上内容，我们可以看出继承和方法覆盖是实现面向对象编程中多态性的基石。通过正确地应用这些原则，可以设计出更加灵活和可扩展的软件系统。在下一章节中，我们将探索接口的使用与实现，进一步深入面向对象编程的高级特性。
4. 接口的使用与实现
接口是Java语言中最为重要的抽象概念之一，它定义了一组方法规范，供其他类实现。在本章节中，我们将深入了解接口的定义、实现，以及它们在设计模式中的应用。
4.1 接口的定义与特性
接口在Java中扮演着定义契约的角色，它声明了类必须实现的方法，而具体的实现则留给子类。与类不同的是，接口允许我们声明没有主体的方法。
4.1.1 接口的声明与实现
接口的声明使用关键字 interface ，并且在接口中声明的方法默认是 public 和 abstract 的，通常这两个修饰符可以省略。一个简单的接口声明示例如下：
public interface Drawable {
void draw();
}
任何实现这个接口的类都必须提供 draw 方法的具体实现：
public class Circle implements Drawable {
@Override
public void draw() {
System.out.println("Drawing a circle.");
}
}
4.1.2 接口与抽象类的区别
接口和抽象类都是抽象的，不能被实例化。它们之间的主要区别包括：
- 一个类可以实现多个接口，但只能继承一个抽象类。
- 接口中不能包含成员变量，而抽象类可以包含变量。
- 接口中的所有方法都默认是
public，而抽象类中的方法可以是public、protected、private。
4.2 接口的多继承特性
Java中的接口支持多继承，这意味着一个接口可以继承多个接口。
4.2.1 多个接口的实现
一个接口可以通过 extends 关键字继承多个接口。下面的例子中，接口 Colored 继承了 Drawable 并添加了新的方法规范：
public interface Colored extends Drawable {
void color();
}
任何实现 Colored 接口的类都需要同时实现 draw 和 color 方法。
4.2.2 接口中的默认方法和静态方法
从Java 8开始，接口可以包含默认方法（使用 default 关键字）和静态方法：
public interface ExampleInterface {
default void defaultMethod() {
System.out.println("Default implementation.");
}
static void staticMethod() {
System.out.println("Static implementation.");
}
}
默认方法允许我们在不破坏现有实现的情况下，向接口添加新的功能。
4.3 接口在设计模式中的应用
接口在面向对象设计中扮演着极其重要的角色，尤其是在实现设计模式时。
4.3.1 接口在工厂模式中的应用
工厂模式是创建对象的一种模式，它依赖于接口来创建对象，而具体的对象类型则由工厂决定。例如，我们可以定义一个 Shape 接口和具体实现它的几个类，如 Circle 、 Square 等，然后创建一个工厂类来根据请求生成具体的形状对象。
public interface Shape {
void draw();
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Circle.draw()");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Square.draw()");
}
}
public class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
} else if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}
}
4.3.2 接口在策略模式中的应用
策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换使用。接口在这里定义了算法家族，具体算法类实现了接口。
public interface Strategy {
void algorithmInterface();
}
public class ConcreteStrategyA implements Strategy {
@Override
public void algorithmInterface() {
System.out.println("Algorithm A");
}
}
public class ConcreteStrategyB implements Strategy {
@Override
public void algorithmInterface() {
System.out.println("Algorithm B");
}
}
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void contextInterface() {
strategy.algorithmInterface();
}
}
在策略模式中，客户端代码可以随意切换策略，而不影响调用策略的上下文代码。
代码块解析
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public void contextInterface() {
strategy.algorithmInterface();
}
}
在这段代码中， Context 类代表策略模式中的上下文。它持有一个 Strategy 类型的引用，并通过构造方法接收具体策略对象的实例。 contextInterface 方法委托给所持有的策略对象的 algorithmInterface 方法，以此来调用具体的算法行为。这使得客户端可以根据需要传递不同的策略对象给 Context ，从而改变 Context 的行为，实现了算法的动态切换。
总结
接口在Java编程中是实现多态和定义行为契约的关键工具。它们支持多继承，并提供了一种机制来定义一组方法规范，这些规范由实现接口的类来完成。通过本章的介绍，我们学习了接口的基础知识，理解了接口与抽象类之间的区别，并探讨了接口在设计模式中的多种应用。掌握接口的使用是成为一名高级Java开发者的重要里程碑。
5. 正方形与立方体的几何计算
5.1 正方形面积的计算方法
5.1.1 面积公式的推导
正方形是所有边长等长的特殊矩形，因此它的面积计算公式可以通过一个变量来表示所有边长。设正方形的边长为 a ，那么其面积 A 可以通过公式 A = a * a 计算得出。这个公式是几何学中非常基础的知识，源于矩形面积的计算方式，即长乘以宽。对于正方形来说，长和宽是相同的，因此计算公式简化为边长的平方。
5.1.2 Java方法实现面积计算
在Java中，我们可以创建一个类来表示正方形，并定义一个方法来计算它的面积。下面是一个简单的实现：
public class Square {
private double side;
public Square(double side) {
this.side = side;
}
public double calculateArea() {
return side * side;
}
public static void main(String[] args) {
Square square = new Square(5.0);
System.out.println("The area of the square is: " + square.calculateArea());
}
}
在上述代码中， Square 类有一个私有成员变量 side 来存储正方形的边长。构造函数 Square(double side) 用于创建具有指定边长的正方形对象。 calculateArea() 方法计算并返回正方形的面积。在 main 方法中，我们创建了一个边长为5.0的 Square 对象，并打印出它的面积。
5.2 立方体体积的计算方法
5.2.1 体积公式的推导
立方体是由六个相等的正方形面组成的几何体，因此它的体积计算可以通过计算一个正方形面的面积，再乘以立方体的高，即边长。设立方体的边长为 a ，那么其体积 V 可以通过公式 V = a * a * a 或者 V = a^3 计算得出。这个公式同样是基于几何学原理，立方体的体积是其底面积与高的乘积，而由于底面是正方形，因此高度等同于边长。
5.2.2 Java方法实现体积计算
类似地，我们可以为立方体定义一个类，并包含计算体积的方法：
public class Cube {
private double edge;
public Cube(double edge) {
this.edge = edge;
}
public double calculateVolume() {
return Math.pow(edge, 3);
}
public static void main(String[] args) {
Cube cube = new Cube(5.0);
System.out.println("The volume of the cube is: " + cube.calculateVolume());
}
}
Cube 类有一个私有成员变量 edge 来存储立方体的边长。构造函数 Cube(double edge) 用于创建具有指定边长的立方体对象。 calculateVolume() 方法使用 Math.pow 函数计算立方体体积，并返回结果。在 main 方法中，我们创建了一个边长为5.0的 Cube 对象，并打印出它的体积。
5.3 立方体表面积的计算方法
5.3.1 表面积公式的推导
立方体的表面积是指它六个面的面积之和。每个面都是一个正方形，因此每个面的面积是边长的平方。立方体有六个这样的面，所以表面积的计算公式是 6 * a^2 ，其中 a 是立方体的边长。
5.3.2 Java方法实现表面积计算
接下来，我们为立方体添加一个方法来计算其表面积：
public class Cube {
private double edge;
public Cube(double edge) {
this.edge = edge;
}
public double calculateVolume() {
return Math.pow(edge, 3);
}
public double calculateSurfaceArea() {
return 6 * Math.pow(edge, 2);
}
public static void main(String[] args) {
Cube cube = new Cube(5.0);
System.out.println("The volume of the cube is: " + cube.calculateVolume());
System.out.println("The surface area of the cube is: " + cube.calculateSurfaceArea());
}
}
在 Cube 类中，我们添加了 calculateSurfaceArea() 方法来计算表面积。这个方法也使用了 Math.pow 函数来计算边长的平方，然后乘以6得到表面积。在 main 方法中，我们同时打印出了立方体的体积和表面积。
通过对正方形和立方体的几何计算，我们可以看到面向对象编程在解决实际问题时的便捷性。每一个几何体都可以通过定义一个类来表示，该类封装了计算面积和体积的方法。对于具有相似属性和行为的对象，我们可以使用继承来重用代码，提高开发效率并保持代码的整洁性。
6. 形状的继承结构与动态调整
6.1 Shape基类的定义与继承
6.1.1 Shape类的设计与实现
在面向对象编程中，为了实现代码的复用和维护性，我们常常使用继承这一机制。继承允许我们创建一个通用的基类，然后派生出特定的子类来继承基类的属性和方法。在本节中，我们将创建一个Shape基类，并探讨如何通过继承来定义正方形（Square）和立方体（Cube）类。
首先，我们定义一个抽象的Shape类，它包含所有二维形状共有的属性和方法。对于本例，我们至少需要一个用于表示形状大小的属性（比如边长），以及一个计算面积的方法。代码如下：
public abstract class Shape {
// 边长属性，对于不同形状，大小的含义可能不同
protected double size;
// 构造方法，用于初始化形状的大小
public Shape(double size) {
this.size = size;
}
// 抽象方法，用于计算面积，子类必须实现
public abstract double calculateArea();
}
6.1.2 Square和Cube类的继承实现
基于Shape类，我们可以定义正方形和立方体的类。这两个类将会继承Shape类，并实现 calculateArea 方法。
正方形类（Square）的实现如下：
public class Square extends Shape {
public Square(double size) {
super(size);
}
// 实现计算面积的方法
@Override
public double calculateArea() {
return size * size;
}
}
立方体类（Cube）的实现如下：
public class Cube extends Shape {
public Cube(double size) {
super(size);
}
// 立方体有两个“面积”，一个是体积，一个是表面积
@Override
public double calculateArea() {
// 简单起见，这里只计算表面积
return 6 * size * size;
}
}
6.2 动态调整形状大小的Resizable接口
6.2.1 Resizable接口的设计
在一些场景中，我们可能需要动态地调整对象的大小，因此，我们可以定义一个Resizable接口，用于声明调整大小的操作。
public interface Resizable {
void resize(double newSize);
}
6.2.2 接口在形状类中的应用
现在，我们让Shape类实现Resizable接口，以提供大小调整的功能。需要注意的是，所有的子类也将继承这个接口和相应的实现。
public abstract class Shape implements Resizable {
// ... 之前的代码
@Override
public void resize(double newSize) {
this.size = newSize;
}
}
6.3 面向对象设计的高级实践
6.3.1 设计模式在形状类中的应用
设计模式是面向对象设计中的一个高级主题，它提供了一种通用的设计问题解决方案。在本例中，我们可以考虑工厂模式和策略模式的应用：
- 工厂模式 : 可以创建一个工厂类，用于生成不同的形状对象。
- 策略模式 : 如果需要对形状进行不同的计算，可以使用策略模式动态地改变行为。
6.3.2 程序的可扩展性与灵活性分析
通过使用抽象类、接口和继承，我们设计出的形状程序具有很好的可扩展性和灵活性。新增一种形状仅需要创建一个新的类，继承自Shape，并实现相应的方法。如果需要改变计算方式，可以通过策略模式替换实现策略，而不需要修改现有的代码。这样的设计符合开闭原则，即对扩展开放，对修改关闭。
简介：本实验将深入探讨面向对象编程在Java中的应用，通过创建代表正方形和立方体的类来实现几何形状的计算方法。学生将学习如何定义基类、子类、属性和方法，以及实现继承和接口使用。实验要求设计并实现一个通用的Shape基类及其子类Square和Cube，包括计算面积、体积和表面积的方法。实验还包括使用Resizable接口来动态调整形状大小。通过这个实验，学生将加深对Java面向对象编程的理解，为解决实际问题打下坚实基础。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
