Composition在Java中的實際應用案例有哪些

在Java中，組合（Composition）是一種常用的設計模式，它通過將一個類的對象作為另一個類的成員變量來實現代碼重用和模塊化設計。以下是一些Composition在Java中的實際應用案例：

1. 圖形繪制軟件示例

假設我們正在設計一個簡單的圖形繪制軟件，其中包含各種形狀的繪制功能，如矩形、圓形和三角形。我們可以使用組合復用原則來設計這個軟件。

class Shape {
    public void draw() {
        // 繪制形狀的共享代碼
    }
}

class Rectangle {
    private Shape shape;

    public Rectangle() {
        shape = new Shape();
    }

    public void drawRectangle() {
        shape.draw(); // 繪制矩形的特定代碼
    }
}

class Circle {
    private Shape shape;

    public Circle() {
        shape = new Shape();
    }

    public void drawCircle() {
        shape.draw(); // 繪制圓形的特定代碼
    }
}

class Triangle {
    private Shape shape;

    public Triangle() {
        shape = new Shape();
    }

    public void drawTriangle() {
        shape.draw(); // 繪制三角形的特定代碼
    }
}

public class DrawingApp {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.drawRectangle();
        Circle circle = new Circle();
        circle.drawCircle();
        Triangle triangle = new Triangle();
        triangle.drawTriangle();
    }
}

2. 公司組織架構管理系統示例

假設我們需要實現一個公司組織架構管理系統，其中有兩類對象：普通員工（葉子節點）和部門（容器節點）。通過組合模式，我們可以統一處理單個員工和整個部門。

public interface Employee {
    void showDetails();
}

class Developer implements Employee {
    private String name;
    private String position;

    public Developer(String name, String position) {
        this.name = name;
        this.position = position;
    }

    @Override
    public void showDetails() {
        System.out.println(name + " - " + position);
    }
}

class Manager implements Employee {
    private String name;
    private String position;

    public Manager(String name, String position) {
        this.name = name;
        this.position = position;
    }

    @Override
    public void showDetails() {
        System.out.println(name + " - " + position);
    }
}

class Department implements Employee {
    private String name;
    private List<Employee> employees = new ArrayList<>();

    public Department(String name) {
        this.name = name;
    }

    public void addEmployee(Employee employee) {
        employees.add(employee);
    }

    public void removeEmployee(Employee employee) {
        employees.remove(employee);
    }

    @Override
    public void showDetails() {
        System.out.println("Department: " + name);
        for (Employee employee : employees) {
            employee.showDetails();
        }
    }
}

public class CompositePatternDemo {
    public static void main(String[] args) {
        Employee developer1 = new Developer("Alice", "Frontend Developer");
        Employee developer2 = new Developer("Bob", "Backend Developer");
        Employee manager1 = new Manager("Charlie", "Project Manager");
        Department engineering = new Department("Engineering");
        engineering.addEmployee(developer1);
        engineering.addEmployee(developer2);
        engineering.addEmployee(manager1);
        // ... 其他部門和員工
    }
}

3. 文件系統示例

組合模式也常用于實現文件系統，其中文件和目錄可以被視為樹形結構中的節點。

4. 函數式編程中的Compose函數示例

在Java 8及以后的版本中，Compose函數可以用于將多個函數組合在一起，創建一個新的函數。

List<String> strings = Arrays.asList("apple", "banana", "orange");

Function<String, String> toUpper = str -> str.toUpperCase();
Function<String, String> sort = str -> {
    char[] chars = str.toCharArray();
    Arrays.sort(chars);
    return new String(chars);
};

Function<String, String> composed = toUpper.compose(sort);

List<String> result = strings.stream()
    .map(composed)
    .collect(Collectors.toList());

5. 大數據處理示例

在大數據處理框架如Apache Hadoop中，也廣泛使用了組合模式來組織和處理數據。

通過這些案例可以看出，組合在Java中的應用非常廣泛，它不僅提高了代碼的可維護性和可擴展性，還使得系統更加靈活和易于擴展。