work/ShapeConversionSystem.java

package challenge;

import basic.Shape;
import java.util.ArrayList;
import java.util.List;

/**
 * 图形转换系统，用于管理和执行图形转换
 */
public class ShapeConversionSystem {
    private List<ShapeConverter> converters;
    
    /**
     * 构造方法
     */
    public ShapeConversionSystem() {
        this.converters = new ArrayList<>();
    }
    
    /**
     * 添加图形转换器
     * @param converter 要添加的转换器
     */
    public void addConverter(ShapeConverter converter) {
        if (converter != null && !converters.contains(converter)) {
            converters.add(converter);
        }
    }
    
    /**
     * 移除图形转换器
     * @param converter 要移除的转换器
     * @return 如果移除成功则返回true，否则返回false
     */
    public boolean removeConverter(ShapeConverter converter) {
        return converters.remove(converter);
    }
    
    /**
     * 查找可以转换指定图形的转换器
     * @param sourceShape 源图形
     * @return 可以转换该图形的转换器列表
     */
    public List<ShapeConverter> findSuitableConverters(Shape sourceShape) {
        List<ShapeConverter> suitableConverters = new ArrayList<>();
        for (ShapeConverter converter : converters) {
            if (converter.canConvert(sourceShape)) {
                suitableConverters.add(converter);
            }
        }
        return suitableConverters;
    }
    
    /**
     * 使用指定的转换器转换图形
     * @param converter 要使用的转换器
     * @param sourceShape 源图形
     * @return 转换后的图形，如果转换失败则返回null
     */
    public Shape convert(ShapeConverter converter, Shape sourceShape) {
        if (converter != null && converter.canConvert(sourceShape)) {
            return converter.convert(sourceShape);
        }
        return null;
    }
    
    /**
     * 使用第一个合适的转换器转换图形
     * @param sourceShape 源图形
     * @return 转换后的图形，如果没有合适的转换器则返回null
     */
    public Shape convert(Shape sourceShape) {
        List<ShapeConverter> suitableConverters = findSuitableConverters(sourceShape);
        if (!suitableConverters.isEmpty()) {
            return suitableConverters.get(0).convert(sourceShape);
        }
        return null;
    }
    
    /**
     * 获取所有可用的转换器
     * @return 转换器列表
     */
    public List<ShapeConverter> getAllConverters() {
        return new ArrayList<>(converters);
    }
    
    /**
     * 显示所有可用的转换器信息
     */
    public void displayAvailableConverters() {
        System.out.println("===== 可用的图形转换器 =====");
        if (converters.isEmpty()) {
            System.out.println("暂无可用的转换器");
        } else {
            for (int i = 0; i < converters.size(); i++) {
                System.out.println((i + 1) + ". " + converters.get(i).getConversionDescription());
            }
        }
        System.out.println("=============================");
    }
    
    /**
     * 清空所有转换器
     */
    public void clearConverters() {
        converters.clear();
    }
}