**Java面向对象编程实践：类设计构造方法重载与图形计算**

面向对象编程是Java的核心特性，通过类的设计、构造方法重载和实际应用案例，可以深入理解Java的面向对象思想。本文将通过图形面积计算系统展示这些核心概念。

### 类的设计与封装基础

良好的类设计是面向对象编程的基础，封装保证了数据的安全性和代码的可维护性。

```java

// 图形基类 - 抽象概念

abstract class Shape {

    // 封装：私有字段 + 公共访问方法

    private String name;

    private String color;

    

    // 静态变量 - 所有图形共享

    private static int shapeCount = 0;

    

    // 构造方法

    public Shape(String name, String color) {

        this.name = name;

        this.color = color;

        shapeCount++;

        System.out.println("创建图形: " + name + "，总图形数: " + shapeCount);

    }

    

    // 获取器和设置器 - 封装的体现

    public String getName() {

        return name;

    }

    

    public void setName(String name) {

        if (name != null && !name.trim().isEmpty()) {

            this.name = name;

        }

    }

    

    public String getColor() {

        return color;

    }

    

    public void setColor(String color) {

        if (color != null && !color.trim().isEmpty()) {

            this.color = color<"UF.6370.HK">;

        }

    }

    

    public static int getShapeCount() {

        return shapeCount;

    }

    

    // 抽象方法 - 强制子类实现

    public abstract double calculateArea();

    public abstract double calculatePerimeter();

    

    // 具体方法 - 所有图形共享的实现

    public void displayInfo() {

        System.out.println("图形名称: " + name);

        System.out.println("图形颜色: " + color);

        System.out.println("图形面积: " + String.format("%.2f", calculateArea()));

        System.out.println("图形周长: " + String.format("%.2f", calculatePerimeter()));

    }

}

```

### 构造方法重载实战

构造方法重载提供了创建对象的不同方式，增强了类的灵活性。

```java

// 矩形类 - 展示构造方法重载

class Rectangle extends Shape {

    private double width;

    private double height;

    

    // 构造方法1：基本构造方法

    public Rectangle(double width, double height) {

        super("矩形", "蓝色");

        setDimensions(width, height);

    }

    

    // 构造方法2：带名称和颜色

    public Rectangle(String name, String color, double width, double height) {

        super(name, color);

        setDimensions(width, height);

    }

    

    // 构造方法3：正方形特化

    public Rectangle(double side) {

        super("正方形", "红色");

        this.width = side;

        this.height = side;

    }

    

    // 构造方法4：默认构造方法

    public Rectangle() {

        super("默认矩形", "黑色");

        this.width = 1.0;

        this.height = 1.0;

    }

    

    // 私有方法辅助构造方法

    private void setDimensions(double width, double height) {

        if (width > 0 && height > 0) {

            this.width = width;

            this.height = height;

        } else {

            throw new IllegalArgumentException("宽度和高度必须大于0");

        }

    }

    

    // 实现抽象方法

    @Override

    public double calculateArea() {

        return width * height;

    }

    

    @Override

    public double calculatePerimeter() {

        return 2 * (width + height);

    }

    

    // 特有方法

    public boolean isSquare() {

        return Math.abs(width - height) < 0.0001;

    }

    

    // 重写显示信息方法

    @Override

    public void displayInfo() {

        super.displayInfo();

        System.out.println("矩形宽度: " + width);

        System.out.println("矩形高度: " + height);

        System.out.println("是否为正方形: " + (isSquare() ? "是" : "否"));

        System.out.println("------------------------");

    }

    

    // 获取器和设置器

    public double getWidth() {

        return width;

    }

    

    public void setWidth(double width) {

        if (width > 0) <"GD.6370.HK">{

            this.width = width;

        }

    }

    

    public double getHeight() {

        return height;

    }

    

    public void setHeight(double height) {

        if (height > 0) {

            this.height = height;

        }

    }

}

```

### 圆形类的设计与实现

圆形类展示不同的几何图形实现方式。

```java

// 圆形类

class Circle extends Shape {

    private double radius;

    public static final double PI = 3.141592653589793;

    

    // 构造方法重载

    public Circle(double radius) {

        super("圆形", "绿色");

        setRadius(radius);

    }

    

    public Circle(String name, String color, double radius) {

        super(name, color);

        setRadius(radius);

    }

    

    public Circle() {

        super("默认圆形", "黄色");

        this.radius = 1.0;

    }

    

    private void setRadius(double radius) {

        if (radius > 0) {

            this.radius = radius;

        } else {

            throw new IllegalArgumentException("半径必须大于0");

        }

    }

    

    @Override

    public double calculateArea() {

        return PI * radius * radius;

    }

    

    @Override

    public double calculatePerimeter() {

        return 2 * PI * radius;

    }

    

    // 圆形特有方法

    public double calculateDiameter() {

        return 2 * radius;

    }

    

    @Override

    public void displayInfo() {

        super.displayInfo();

        System.out.println("圆形半径: " + radius);

        System.out.println("圆形直径: " + calculateDiameter());

        System.out.println("------------------------");

    }

    

    public double getRadius() {

        return radius;

    }

    

    public void setRadius(float radius) {

        if (radius > 0) {

            this.radius = radius;

        }

    }

}

```

### 三角形类的复杂设计

三角形类展示更复杂的几何计算和验证逻辑。

```java

// 三角形类

class Triangle extends Shape {

    private double sideA;

    private double sideB;

    private double sideC;

    

    // 构造方法1：三边构造

    public Triangle(double a, double b, double c) {

        super("三角形", "橙色")<"TU.6370.HK">;

        if (isValidTriangle(a, b, c)) {

            this.sideA = a;

            this.sideB = b;

            this.sideC = c;

        } else {

            throw new IllegalArgumentException("无效的三角形边长");

        }

    }

    

    // 构造方法2：等腰三角形

    public Triangle(double base, double equalSides) {

        super("等腰三角形", "紫色");

        if (isValidTriangle(base, equalSides, equalSides)) {

            this.sideA = base;

            this.sideB = equalSides;

            this.sideC = equalSides;

        } else {

            throw new IllegalArgumentException("无效的等腰三角形边长");

        }

    }

    

    // 构造方法3：等边三角形

    public Triangle(double side) {

        super("等边三角形", "粉色");

        if (side > 0) {

            this.sideA = side;

            this.sideB = side;

            this.sideC = side;

        } else {

            throw new IllegalArgumentException("边长必须大于0");

        }

    }

    

    // 验证三角形有效性

    private boolean isValidTriangle(double a, double b, double c) {

        return a > 0 && b > 0 && c > 0 &&

               a + b > c && a + c > b && b + c > a;

    }

    

    @Override

    public double calculateArea() {

        // 使用海伦公式计算面积

        double s = calculatePerimeter() / 2;

        return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC));

    }

    

    @Override

    public double calculatePerimeter() {

        return sideA + sideB + sideC;

    }

    

    // 三角形分类方法

    public String getTriangleType() {

        if (sideA == sideB && sideB == sideC) {

            return "等边三角形";

        } else if (sideA == sideB || sideA == sideC || sideB == sideC) {

            return "等腰三角形";

        } else {

            return "不等边三角形";

        }

    }

    

    // 判断是否为直角三角形

    public boolean isRightTriangle() {

        double[] sides = {sideA, sideB, sideC};

        java.util.Arrays.sort(sides);

        return Math.abs(sides[2] * sides[2] - (sides[0] * sides[0] + sides[1] * sides[1])) < 0.0001;

    }

    

    @Override

    public void displayInfo() {

        super.displayInfo();

        System.out.println("三角形边长: " + sideA + ", " + sideB + ", " + sideC);

        System.out.println("三角形类型: " + getTriangleType());

        System.out.println("是否为直角三角形: " + (isRightTriangle() ? "是" : "否"));

        System.out.println("------------------------");

    }

    

    // 获取器

    public double getSideA() {

        return sideA;

    }

    

    public double getSideB() {

        return sideB;

    }

    

    public double getSideC() {

        return sideC;

    }

}

```

### 图形管理系统实现

创建一个图形管理系统来管理各种图形对象。

```java

import java.util.ArrayList;

import java.util.List;

// 图形管理系统

class ShapeManager {

    private List<Shape> shapes;

    

    public ShapeManager() {

        shapes = new ArrayList<>();

    }

    

    // 添加图形

    public void addShape(Shape shape) {

        if (shape != null) <"KW.6370.HK">{

            shapes.add(shape);

            System.out.println("添加图形: " + shape.getName());

        }

    }

    

    // 显示所有图形信息

    public void displayAllShapes() {

        System.out.println("\n=== 所有图形信息 ===");

        if (shapes.isEmpty()) {

            System.out.println("没有图形数据");

            return;

        }

        

        for (int i = 0; i < shapes.size(); i++) {

            System.out.println("图形 #" + (i + 1) + ":");

            shapes.get(i).displayInfo();

        }

    }

    

    // 计算总面积

    public double calculateTotalArea() {

        double totalArea = 0;

        for (Shape shape : shapes) {

            totalArea += shape.calculateArea();

        }

        return totalArea;

    }

    

    // 计算总周长

    public double calculateTotalPerimeter() {

        double totalPerimeter = 0;

        for (Shape shape : shapes) {

            totalPerimeter += shape.calculatePerimeter();

        }

        return totalPerimeter;

    }

    

    // 按类型统计

    public void displayStatistics() {

        System.out.println("\n=== 图形统计信息 ===");

        System.out.println("总图形数量: " + shapes.size());

        System.out.println("系统总图形数: " + Shape.getShapeCount());

        System.out.println("总面积: " + String.format("%.2f", calculateTotalArea()));

        System.out.println("总周长: " + String.format("%.2f", calculateTotalPerimeter()));

        

        // 按类型统计

        int rectangles = 0, circles = 0, triangles = 0;

        for (Shape shape : shapes) {

            if (shape instanceof Rectangle) rectangles++;

            else if (shape instanceof Circle) circles++;

            else if (shape instanceof Triangle) triangles++;

        }

        

        System.out.println("矩形数量: " + rectangles);

        System.out.println("圆形数量: " + circles);

        System.out.println("三角形数量: " + triangles);

    }

    

    // 查找面积最大的图形

    public Shape findLargestShape() {

        if (shapes.isEmpty()) return null;

        

        Shape largest = shapes.get(0);

        for (Shape shape : shapes) {

            if (shape.calculateArea() > largest.calculateArea()) {

                largest = shape;

            }

        }

        return largest;

    }

    

    // 按名称搜索图形

    public List<Shape> findShapesByName(String name) {

        List<Shape> result = new ArrayList<>();

        for (Shape shape : shapes) {

            if (shape.getName().toLowerCase().contains(name.toLowerCase())) {

                result.add(shape);

            }

        }

        return result;

    }

}

```

### 综合实验演示

创建完整的演示程序展示所有功能。

```java

public class ShapeCalculationSystem {

    

    public static void main(String[] args) {

        System.out.println("Java面向对象实验：图形面积计算系统");

        System.out.println("================================\n");

        

        // 创建图形管理器

        ShapeManager manager = new ShapeManager();

        

        // 演示构造方法重载

        System.out.println("=== 构造方法重载演示 ===");

        

        // 矩形构造方法重载

        Rectangle rect1 = new Rectangle(5.0, 3.0);          // 基本构造

        Rectangle rect2 = new Rectangle("大矩形", "深蓝色", 8.0, 6.0); // 带名称颜色

        Rectangle square1 = new Rectangle(4.0);             // 正方形

        Rectangle defaultRect = new Rectangle();            // 默认构造

        

        // 圆形构造方法重载

        Circle circle1 = new Circle(3.0);                   // 基本构造

        Circle circle2 = new Circle("大圆形", "深绿色", 5.0); // 带名称颜色

        Circle defaultCircle = new Circle();                // 默认构造

        

        // 三角形构造方法重载

        Triangle triangle1 = new Triangle(3.0, 4.0, 5.0);  // 普通三角形

        Triangle isosceles = new Triangle(6.0, 5.0);       // 等腰三角形

        Triangle equilateral = new Triangle(4.0);          // 等边三角形

        

        // 添加所有图形到管理器

        manager.addShape(rect1);

        manager.addShape(rect2);

        manager.addShape(square1);

        manager.addShape(defaultRect);

        manager.addShape(circle1);

        manager.addShape(circle2);

        manager.addShape(defaultCircle);

        manager.addShape(triangle1);

        manager.addShape(isosceles);

        manager.addShape(equilateral);

        

        // 显示所有图形信息

        manager.displayAllShapes();

        

        // 显示统计信息

        manager.displayStatistics();

        

        // 查找最大图形

        Shape largest = manager.findLargestShape();

        if (largest != null) <"RZ.6370.HK">{

            System.out.println("\n=== 面积最大的图形 ===");

            largest.displayInfo();

        }

        

        // 搜索演示

        System.out.println("\n=== 图形搜索演示 ===");

        List<Shape> foundShapes = manager.findShapesByName("大");

        System.out.println("找到 " + foundShapes.size() + " 个包含'大'的图形:");

        for (Shape shape : foundShapes) {

            System.out.println("  - " + shape.getName());

        }

        

        // 演示图形特性

        demonstrateShapeFeatures();

        

        // 演示异常处理

        demonstrateExceptionHandling();

    }

    

    // 演示图形特有功能

    private static void demonstrateShapeFeatures() {

        System.out.println("\n=== 图形特有功能演示 ===");

        

        // 矩形正方形判断

        Rectangle rect = new Rectangle(5.0, 5.0);

        System.out.println("5x5矩形是否为正方形: " + rect.isSquare());

        

        // 三角形类型判断

        Triangle rightTriangle = new Triangle(3.0, 4.0, 5.0);

        System.out.println("3-4-5三角形类型: " + rightTriangle.getTriangleType());

        System.out.println("3-4-5三角形是否为直角三角形: " + rightTriangle.isRightTriangle());

        

        // 圆形直径计算

        Circle circle = new Circle(2.0);

        System.out.println("半径2的圆形直径: " + circle.calculateDiameter());

    }

    

    // 演示异常处理

    private static void demonstrateExceptionHandling() {

        System.out.println("\n=== 异常处理演示 ===");

        

        try {

            // 无效矩形

            Rectangle invalidRect = new Rectangle(-1.0, 5.0);

        } catch (IllegalArgumentException e) {

            System.out.println("捕获异常: " + e.getMessage());

        }

        

        try {

            // 无效三角形

            Triangle invalidTriangle = new Triangle(1.0, 2.0, 10.0);

        } catch (IllegalArgumentException e) {

            System.out.println("捕获异常: " + e.getMessage());

        }

        

        try {

            // 无效圆形

            Circle invalidCircle = new Circle(-2.0);

        } catch (IllegalArgumentException e) {

            System.out.println("捕获异常: " + e.getMessage());

        }

    }

}

```

### 高级特性扩展

```java

// 可比较接口实现

class ComparableRectangle extends Rectangle implements Comparable<ComparableRectangle> {

    

    public ComparableRectangle(double width, double height) {

        super(width, height);

    }

    

    @Override

    public int compareTo(ComparableRectangle other) {

        return Double.compare(this.calculateArea(), other.calculateArea());

    }

}

// 图形工厂类

class ShapeFactory {

    

    public static Shape createShape(String type, double... dimensions) {

        switch (type.toLowerCase()) {

            case "rectangle":

                if (dimensions.length == 2) {

                    return new Rectangle(dimensions[0], dimensions[1]);

                }

                break;

            case "circle":

                if (dimensions.length == 1) {

                    return new Circle(dimensions[0]);

                }

                break;

            case "triangle":

                if (dimensions.length == 3) {

                    return new Triangle(dimensions[0], dimensions[1], dimensions[2]);

                }

                break;

            case "square":

                if (dimensions.length == 1) {

                    return new Rectangle(dimensions[0]);

                }

                break;

        }

        throw new IllegalArgumentException("不支持的图形类型或参数");

    }

    

    public static void demonstrateFactory() {

        System.out.println<"MV.6370.HK">("\n=== 图形工厂演示 ===");

        

        Shape rect = ShapeFactory.createShape("rectangle", 4.0, 5.0);

        Shape circle = ShapeFactory.createShape("circle", 3.0);

        Shape triangle = ShapeFactory.createShape("triangle", 3.0, 4.0, 5.0);

        Shape square = ShapeFactory.createShape("square", 4.0);

        

        rect.displayInfo();

        circle.displayInfo();

        triangle.displayInfo();

        square.displayInfo();

    }

}

```

### 实验总结与最佳实践

通过这个图形面积计算系统，我们实践了以下面向对象核心概念：

1. **类的设计原则**：

   - 封装：私有字段和公共访问方法

   - 继承：抽象基类和具体子类

   - 多态：抽象方法和具体实现

2. **构造方法重载价值**：

   - 提供多种对象创建方式

   - 增强类的灵活性和易用性

   - 支持特殊情况的快速创建

3. **代码组织技巧**：

   - 使用管理器类组织相关对象

   - 工厂模式简化对象创建

   - 异常处理保证程序健壮性

4. **实际应用扩展**：

   - 可以添加更多图形类型（椭圆、梯形等）

   - 实现图形序列化保存和加载

   - 添加图形编辑和变换功能

这个实验系统展示了Java面向对象编程的强大能力，为开发更复杂的应用程序奠定了坚实基础。