19 changed files with 0 additions and 962 deletions
--- a/AuthMiddleware.java
+++ b/AuthMiddleware.java
@ -1,27 +0,0 @@
 package middleware;
 /**
 * 认证中间件装饰器
 * 具体装饰器类，用于验证请求的认证信息
 */
 public class AuthMiddleware extends MiddlewareDecorator {
    public AuthMiddleware(HttpRequestHandler decoratedHandler) {
        super(decoratedHandler);
    }
    @Override
    public HttpResponse handle(HttpRequest request) {
        // 简单的认证检查逻辑
        String authHeader = request.getHeaders();
        if (authHeader != null && authHeader.contains("Authorization: Bearer token123")) {
            System.out.println("Authentication successful");
            return super.handle(request);
        } else {
            HttpResponse response = new HttpResponse();
            response.setStatusCode(401);
            response.setBody("Unauthorized");
            return response;
        }
    }
 }
--- a/BasicHttpRequestHandler.java
+++ b/BasicHttpRequestHandler.java
@ -1,15 +0,0 @@
 package middleware;
 /**
 * 基本的HTTP请求处理器实现
 * 装饰器模式中的具体组件类
 */
 public class BasicHttpRequestHandler implements HttpRequestHandler {
    @Override
    public HttpResponse handle(HttpRequest request) {
        HttpResponse response = new HttpResponse();
        response.setBody("Hello from Basic Handler: " + request.getPath());
        response.setHeaders("Content-Type: text/plain");
        return response;
    }
 }
--- a/CORSMiddleware.java
+++ b/CORSMiddleware.java
@ -1,23 +0,0 @@
 package middleware;
 /**
 * CORS中间件装饰器
 * 具体装饰器类，用于处理跨域资源共享请求
 */
 public class CORSMiddleware extends MiddlewareDecorator {
    public CORSMiddleware(HttpRequestHandler decoratedHandler) {
        super(decoratedHandler);
    }
    @Override
    public HttpResponse handle(HttpRequest request) {
        HttpResponse response = super.handle(request);
        // 添加CORS头信息
        String existingHeaders = response.getHeaders() != null ? response.getHeaders() + "\n" : "";
        response.setHeaders(existingHeaders + "Access-Control-Allow-Origin: *\nAccess-Control-Allow-Methods: GET, POST, PUT, DELETE\nAccess-Control-Allow-Headers: *");
        return response;
    }
 }
--- a/Circle.java
+++ b/Circle.java
@ -1,80 +0,0 @@
 package challenge;
 import basic.Shape;
 import advanced.Resizable;
 /**
 * 圆形类，实现Shape接口和Resizable接口
 */
 public class Circle implements Shape, Resizable {
    private String color;
    private double radius;
    /**
     * 构造方法
     * @param color 圆形的颜色
     * @param radius 圆形的半径
     */
    public Circle(String color, double radius) {
        this.color = color;
        this.radius = radius;
    }
    @Override
    public String getColor() {
        return color;
    }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    @Override
    public void display() {
        System.out.println("Circle [color=" + color + ", radius=" + radius + ", area=" + getArea() + "]");
    }
    @Override
    public void enlarge(double factor) {
        if (factor > 0) {
            this.radius *= factor;
        }
    }
    @Override
    public void shrink(double factor) {
        if (factor > 0 && factor < 1) {
            this.radius *= factor;
        }
    }
    @Override
    public String getSizeInfo() {
        return "Circle with radius: " + radius + ", area: " + getArea();
    }
    /**
     * 获取半径
     * @return 半径
     */
    public double getRadius() {
        return radius;
    }
    /**
     * 设置半径
     * @param radius 新的半径
     */
    public void setRadius(double radius) {
        this.radius = radius;
    }
    /**
     * 设置颜色
     * @param color 新的颜色
     */
    public void setColor(String color) {
        this.color = color;
    }
 }
--- a/CircleToEllipseConverter.java
+++ b/CircleToEllipseConverter.java
@ -1,60 +0,0 @@
 package challenge;
 import basic.Shape;
 /**
 * 圆形到椭圆形的转换器，实现ShapeConverter接口
 */
 public class CircleToEllipseConverter implements ShapeConverter {
    private double stretchFactor; // 拉伸因子，用于确定椭圆的长半轴
    /**
     * 构造方法
     * @param stretchFactor 拉伸因子，大于1时会将圆形拉伸成椭圆形
     */
    public CircleToEllipseConverter(double stretchFactor) {
        this.stretchFactor = Math.max(stretchFactor, 1.0); // 确保拉伸因子至少为1
    }
    @Override
    public Shape convert(Shape sourceShape) {
        if (!canConvert(sourceShape)) {
            return null;
        }
        Circle circle = (Circle) sourceShape;
        double radius = circle.getRadius();
        // 将圆形转换为椭圆形：保持颜色不变，半径作为短半轴，拉伸后的半径作为长半轴
        double semiMinorAxis = radius;
        double semiMajorAxis = radius * stretchFactor;
        return new Ellipse(circle.getColor(), semiMajorAxis, semiMinorAxis);
    }
    @Override
    public boolean canConvert(Shape sourceShape) {
        return sourceShape instanceof Circle;
    }
    @Override
    public String getConversionDescription() {
        return "将圆形转换为椭圆形，拉伸因子为：" + stretchFactor;
    }
    /**
     * 获取拉伸因子
     * @return 拉伸因子
     */
    public double getStretchFactor() {
        return stretchFactor;
    }
    /**
     * 设置拉伸因子
     * @param stretchFactor 新的拉伸因子
     */
    public void setStretchFactor(double stretchFactor) {
        this.stretchFactor = Math.max(stretchFactor, 1.0);
    }
 }
--- a/ClassRoom.java
+++ b/ClassRoom.java
@ -1,39 +0,0 @@
 package advanced;
 public class ClassRoom {
    private String id;
    private String name;
    private Teacher teacher;
    public ClassRoom() {
    }
    public ClassRoom(String id, String name) {
        this.id = id;
        this.name = name;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Teacher getTeacher() {
        return teacher;
    }
 }
--- a/CompositeShape.java
+++ b/CompositeShape.java
@ -1,143 +0,0 @@
 package challenge;
 import basic.Shape;
 import advanced.Resizable;
 import java.util.ArrayList;
 import java.util.List;
 /**
 * 复合图形类，实现Shape接口和Resizable接口，用于组合多个图形
 */
 public class CompositeShape implements Shape, Resizable {
    private String color;
    private String name;
    private List<Shape> shapes;
    /**
     * 构造方法
     * @param name 复合图形的名称
     * @param color 复合图形的颜色
     */
    public CompositeShape(String name, String color) {
        this.name = name;
        this.color = color;
        this.shapes = new ArrayList<>();
    }
    /**
     * 添加子图形
     * @param shape 要添加的图形
     */
    public void addShape(Shape shape) {
        if (shape != null) {
            shapes.add(shape);
        }
    }
    /**
     * 移除子图形
     * @param shape 要移除的图形
     * @return 如果移除成功则返回true，否则返回false
     */
    public boolean removeShape(Shape shape) {
        return shapes.remove(shape);
    }
    /**
     * 移除所有子图形
     */
    public void clearShapes() {
        shapes.clear();
    }
    /**
     * 获取子图形列表
     * @return 子图形列表
     */
    public List<Shape> getShapes() {
        return new ArrayList<>(shapes); // 返回副本，防止外部修改
    }
    @Override
    public String getColor() {
        return color;
    }
    @Override
    public double getArea() {
        double totalArea = 0.0;
        for (Shape shape : shapes) {
            totalArea += shape.getArea();
        }
        return totalArea;
    }
    @Override
    public void display() {
        System.out.println("CompositeShape [name=" + name + ", color=" + color + ", totalShapes=" + shapes.size() + ", totalArea=" + getArea() + "]");
        System.out.println("  子图形列表:");
        for (int i = 0; i < shapes.size(); i++) {
            System.out.print("  " + (i + 1) + ". ");
            shapes.get(i).display();
        }
    }
    @Override
    public void enlarge(double factor) {
        if (factor > 0) {
            for (Shape shape : shapes) {
                if (shape instanceof Resizable) {
                    ((Resizable) shape).enlarge(factor);
                }
            }
        }
    }
    @Override
    public void shrink(double factor) {
        if (factor > 0 && factor < 1) {
            for (Shape shape : shapes) {
                if (shape instanceof Resizable) {
                    ((Resizable) shape).shrink(factor);
                }
            }
        }
    }
    @Override
    public String getSizeInfo() {
        return "CompositeShape '" + name + "' with " + shapes.size() + " shapes, total area: " + getArea();
    }
    /**
     * 获取复合图形的名称
     * @return 名称
     */
    public String getName() {
        return name;
    }
    /**
     * 设置复合图形的名称
     * @param name 新的名称
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * 设置颜色
     * @param color 新的颜色
     */
    public void setColor(String color) {
        this.color = color;
    }
    /**
     * 获取子图形的数量
     * @return 子图形数量
     */
    public int getShapeCount() {
        return shapes.size();
    }
 }
--- a/Course.java
+++ b/Course.java
@ -1,59 +0,0 @@
 package advanced;
 public class AdvancedCourse {
    private int id;
    private String name;
    private int credit;
    private java.util.List<AdvancedCourse> prerequisiteCourses;
    public AdvancedCourse() {
        this.prerequisiteCourses = new java.util.ArrayList<>();
    }
    public AdvancedCourse(int id, String name, int credit) {
        this.id = id;
        this.name = name;
        this.credit = credit;
        this.prerequisiteCourses = new java.util.ArrayList<>();
    }
    public void addPrerequisiteCourse(AdvancedCourse course) {
        prerequisiteCourses.add(course);
    }
    public void removePrerequisiteCourse(AdvancedCourse course) {
        prerequisiteCourses.remove(course);
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getCredit() {
        return credit;
    }
    public void setCredit(int credit) {
        this.credit = credit;
    }
    public java.util.List<AdvancedCourse> getPrerequisiteCourses() {
        return prerequisiteCourses;
    }
    public void setPrerequisiteCourses(java.util.List<AdvancedCourse> prerequisiteCourses) {
        this.prerequisiteCourses = prerequisiteCourses;
    }
 }
--- a/Ellipse.java
+++ b/Ellipse.java
@ -1,101 +0,0 @@
 package challenge;
 import basic.Shape;
 import advanced.Resizable;
 /**
 * 椭圆形类，实现Shape接口和Resizable接口
 */
 public class Ellipse implements Shape, Resizable {
    private String color;
    private double semiMajorAxis; // 长半轴
    private double semiMinorAxis; // 短半轴
    /**
     * 构造方法
     * @param color 椭圆形的颜色
     * @param semiMajorAxis 长半轴
     * @param semiMinorAxis 短半轴
     */
    public Ellipse(String color, double semiMajorAxis, double semiMinorAxis) {
        this.color = color;
        this.semiMajorAxis = Math.max(semiMajorAxis, semiMinorAxis); // 确保长半轴不小于短半轴
        this.semiMinorAxis = Math.min(semiMajorAxis, semiMinorAxis);
    }
    @Override
    public String getColor() {
        return color;
    }
    @Override
    public double getArea() {
        return Math.PI * semiMajorAxis * semiMinorAxis;
    }
    @Override
    public void display() {
        System.out.println("Ellipse [color=" + color + ", semiMajorAxis=" + semiMajorAxis + ", semiMinorAxis=" + semiMinorAxis + ", area=" + getArea() + "]");
    }
    @Override
    public void enlarge(double factor) {
        if (factor > 0) {
            this.semiMajorAxis *= factor;
            this.semiMinorAxis *= factor;
        }
    }
    @Override
    public void shrink(double factor) {
        if (factor > 0 && factor < 1) {
            this.semiMajorAxis *= factor;
            this.semiMinorAxis *= factor;
        }
    }
    @Override
    public String getSizeInfo() {
        return "Ellipse with semi-major axis: " + semiMajorAxis + ", semi-minor axis: " + semiMinorAxis + ", area: " + getArea();
    }
    /**
     * 获取长半轴
     * @return 长半轴
     */
    public double getSemiMajorAxis() {
        return semiMajorAxis;
    }
    /**
     * 设置长半轴
     * @param semiMajorAxis 新的长半轴
     */
    public void setSemiMajorAxis(double semiMajorAxis) {
        this.semiMajorAxis = semiMajorAxis;
    }
    /**
     * 获取短半轴
     * @return 短半轴
     */
    public double getSemiMinorAxis() {
        return semiMinorAxis;
    }
    /**
     * 设置短半轴
     * @param semiMinorAxis 新的短半轴
     */
    public void setSemiMinorAxis(double semiMinorAxis) {
        this.semiMinorAxis = semiMinorAxis;
    }
    /**
     * 设置颜色
     * @param color 新的颜色
     */
    public void setColor(String color) {
        this.color = color;
    }
 }
--- a/HttpRequest.java
+++ b/HttpRequest.java
@ -1,40 +0,0 @@
 package middleware;
 /**
 * HTTP请求对象
 */
 public class HttpRequest {
    private String path;
    private String method;
    private String headers;
    private String body;
    public HttpRequest(String path, String method) {
        this.path = path;
        this.method = method;
    }
    public String getPath() {
        return path;
    }
    public String getMethod() {
        return method;
    }
    public void setHeaders(String headers) {
        this.headers = headers;
    }
    public String getHeaders() {
        return headers;
    }
    public void setBody(String body) {
        this.body = body;
    }
    public String getBody() {
        return body;
    }
 }
--- a/HttpRequestHandler.java
+++ b/HttpRequestHandler.java
@ -1,14 +0,0 @@
 package middleware;
 /**
 * HTTP请求处理器接口
 * 装饰器模式的核心组件，定义了处理HTTP请求的方法
 */
 public interface HttpRequestHandler {
    /**
     * 处理HTTP请求并返回响应
     * @param request HTTP请求对象
     * @return HTTP响应对象
     */
    HttpResponse handle(HttpRequest request);
 }
--- a/HttpResponse.java
+++ b/HttpResponse.java
@ -1,38 +0,0 @@
 package middleware;
 /**
 * HTTP响应对象
 */
 public class HttpResponse {
    private int statusCode;
    private String headers;
    private String body;
    public HttpResponse() {
        this.statusCode = 200;
    }
    public int getStatusCode() {
        return statusCode;
    }
    public void setStatusCode(int statusCode) {
        this.statusCode = statusCode;
    }
    public void setHeaders(String headers) {
        this.headers = headers;
    }
    public String getHeaders() {
        return headers;
    }
    public void setBody(String body) {
        this.body = body;
    }
    public String getBody() {
        return body;
    }
 }
--- a/LoggingMiddleware.java
+++ b/LoggingMiddleware.java
@ -1,20 +0,0 @@
 package middleware;
 /**
 * 日志中间件装饰器
 * 具体装饰器类，用于记录请求信息
 */
 public class LoggingMiddleware extends MiddlewareDecorator {
    public LoggingMiddleware(HttpRequestHandler decoratedHandler) {
        super(decoratedHandler);
    }
    @Override
    public HttpResponse handle(HttpRequest request) {
        System.out.println("Logging request: " + request.getMethod() + " " + request.getPath());
        HttpResponse response = super.handle(request);
        System.out.println("Logging response status: " + response.getStatusCode());
        return response;
    }
 }
--- a/MiddlewareDecorator.java
+++ b/MiddlewareDecorator.java
@ -1,18 +0,0 @@
 package middleware;
 /**
 * 中间件装饰器抽象类
 * 装饰器模式中的装饰器类，实现了HttpRequestHandler接口并持有一个HttpRequestHandler引用
 */
 public abstract class MiddlewareDecorator implements HttpRequestHandler {
    protected HttpRequestHandler decoratedHandler;
    public MiddlewareDecorator(HttpRequestHandler decoratedHandler) {
        this.decoratedHandler = decoratedHandler;
    }
    @Override
    public HttpResponse handle(HttpRequest request) {
        return decoratedHandler.handle(request);
    }
 }
--- a/Parent.java
+++ b/Parent.java
@ -1,49 +0,0 @@
 package advanced;
 public class Parent {
    private String id;
    private String name;
    private java.util.List<basic.Student> children;
    public Parent() {
        this.children = new java.util.ArrayList<>();
    }
    public Parent(String id, String name) {
        this.id = id;
        this.name = name;
        this.children = new java.util.ArrayList<>();
    }
    public void addChild(basic.Student student) {
        children.add(student);
    }
    public void removeChild(basic.Student student) {
        children.remove(student);
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public java.util.List<basic.Student> getChildren() {
        return children;
    }
    public void setChildren(java.util.List<basic.Student> children) {
        this.children = children;
    }
 }
--- a/ShapeConversionSystem.java
+++ b/ShapeConversionSystem.java
@ -1,109 +0,0 @@
 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();
    }
 }
--- a/ShapeConverter.java
+++ b/ShapeConverter.java
@ -1,28 +0,0 @@
 package challenge;
 import basic.Shape;
 /**
 * 图形转换接口，定义图形之间的转换行为
 */
 public interface ShapeConverter {
    /**
     * 将源图形转换为目标图形
     * @param sourceShape 源图形
     * @return 转换后的目标图形，如果转换不支持则返回null
     */
    Shape convert(Shape sourceShape);
    /**
     * 检查是否支持从源图形类型转换到目标图形类型
     * @param sourceShape 源图形
     * @return 如果支持转换则返回true，否则返回false
     */
    boolean canConvert(Shape sourceShape);
    /**
     * 获取转换的描述信息
     * @return 转换描述
     */
    String getConversionDescription();
 }
--- a/Student.java
+++ b/Student.java
@ -1,50 +0,0 @@
 package advanced;
 public class AdvancedStudent {
    private int id;
    private String name;
    private Parent parent;
    private java.util.List<basic.Grade> grades;
    public AdvancedStudent() {
        this.grades = new java.util.ArrayList<>();
    }
    public AdvancedStudent(int id, String name) {
        this.id = id;
        this.name = name;
        this.grades = new java.util.ArrayList<>();
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Parent getParent() {
        return parent;
    }
    public void setParent(Parent parent) {
        this.parent = parent;
    }
    public java.util.List<basic.Grade> getGrades() {
        return grades;
    }
    public void setGrades(java.util.List<basic.Grade> grades) {
        this.grades = grades;
    }
 }
--- a/Teacher.java
+++ b/Teacher.java
@ -1,49 +0,0 @@
 package advanced;
 public class Teacher {
    private String id;
    private String name;
    private java.util.List<ClassRoom> classes;
    public Teacher() {
        this.classes = new java.util.ArrayList<>();
    }
    public Teacher(String id, String name) {
        this.id = id;
        this.name = name;
        this.classes = new java.util.ArrayList<>();
    }
    public void addClass(ClassRoom classRoom) {
        classes.add(classRoom);
    }
    public void removeClass(ClassRoom classRoom) {
        classes.remove(classRoom);
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public java.util.List<ClassRoom> getClasses() {
        return classes;
    }
    public void setClasses(java.util.List<ClassRoom> classes) {
        this.classes = classes;
    }
 }