pfvwqyiue
/
print
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ADD file via upload

Browse Source
main
pfvwqyiue 6 months ago
parent 32c81268e8
commit f1b6820765
1 changed files with 808 additions and 0 deletions
Show Stats Download Patch File Download Diff File

808
TRAEPrincipleDemo.java
Unescape View File

@ -0,0 +1,808 @@
/**
* TRAE原则演示类
* 展示Testability(可测试性)、Reusability(可重用性)、Accessibility(可访问性)、Extensibility(可扩展性)
*/
import com.smart.home.basic.DeviceManager;
import com.smart.home.basic.SmartDevice;
import com.smart.home.basic.PowerControl;
import com.smart.home.advanced.SmartDoor;
import com.smart.home.advanced.SmartSafe;
import com.smart.home.advanced.Lockable;
import com.smart.home.advanced.Monitored;
import com.smart.home.advanced.Alarmable;
import com.smart.home.advanced.SecurityCamera;
import com.smart.home.challenge.SmartLightBulb;
import com.smart.home.challenge.SmartAirConditioner;
import com.smart.home.challenge.SmartSpeaker;
import com.smart.home.challenge.SmartCurtain;
import java.util.List;
import java.util.ArrayList;
import java.util.Optional;
/**
* 智能设备测试工具类
* 提供通用的设备测试方法，展示工厂方法模式的应用
*/
class DeviceTestUtil {
// 工厂方法：创建设备管理器
public static DeviceManager createDeviceManager() {
return new DeviceManager();
}
// 通用测试方法：验证设备状态
public static void verifyDeviceStatus(SmartDevice device, String expectedStatus) {
String actualStatus = device.getStatusDescription();
System.out.println(" - 验证状态: " + actualStatus);
if (actualStatus.contains(expectedStatus)) {
System.out.println(" * 状态验证通过");
} else {
System.out.println(" * 状态验证失败，期望包含: " + expectedStatus);
}
}
}
public class TRAEPrincipleDemo {
/**
* 主方法
* @param args 命令行参数
*/
public static void main(String[] args) {
System.out.println("===== TRAE原则程序测验 =====");
System.out.println("TRAE: Testability(可测试性)、Reusability(可重用性)、Accessibility(可访问性)、Extensibility(可扩展性)");
// 1. 可测试性 (Testability) 演示
demonstrateTestability();
// 2. 可重用性 (Reusability) 演示
demonstrateReusability();
// 3. 可访问性 (Accessibility) 演示
demonstrateAccessibility();
// 4. 可扩展性 (Extensibility) 演示
demonstrateExtensibility();
System.out.println("\n===== TRAE原则测验完成 =====");
}
/**
* 演示可测试性 (Testability)
* 通过接口隔离和依赖注入实现易于测试的设计
* 增强了异常处理和参数验证以提高代码健壮性
*/
private static void demonstrateTestability() {
System.out.println("\n1. 可测试性 (Testability) 演示：");
System.out.println(" - 使用接口隔离原则，每个接口职责单一，易于模拟测试");
System.out.println(" - 通过接口实现松耦合，便于单元测试和集成测试");
System.out.println(" - 增加异常处理和参数验证，提高测试健壮性");
// 测试场景1: 智能设备基本功能测试
System.out.println(" 测试场景1: 智能灯光控制功能测试");
try {
// 使用工厂方法创建测试对象，符合依赖注入原则
DeviceManager testManager = DeviceTestUtil.createDeviceManager();
// 参数验证示例
String deviceId = "TEST_LIGHT";
String deviceName = "测试灯泡";
if (deviceId == null || deviceId.trim().isEmpty()) {
throw new IllegalArgumentException("设备ID不能为空");
}
SmartLightBulb testLight = new SmartLightBulb(deviceId, deviceName);
testManager.addDevice(testLight);
// 验证初始状态
System.out.println(" - 初始状态测试: " + testLight.getStatusDescription());
// 执行测试操作
System.out.println(" - 执行测试操作...");
testManager.turnOnDevice(deviceId);
// 参数边界测试
testLight.setBrightness(0); // 边界值测试
System.out.println(" - 亮度边界值测试(0%): " + testLight.getStatusDescription());
testLight.setBrightness(100); // 边界值测试
System.out.println(" - 亮度边界值测试(100%): " + testLight.getStatusDescription());
// 正常值测试
testLight.setBrightness(75);
testLight.setColor("蓝色");
// 使用工具类验证状态
DeviceTestUtil.verifyDeviceStatus(testLight, "蓝色");
DeviceTestUtil.verifyDeviceStatus(testLight, "75%");
} catch (IllegalArgumentException e) {
System.out.println(" - 参数验证异常: " + e.getMessage());
} catch (Exception e) {
System.out.println(" - 测试过程中出现异常: " + e.getMessage());
}
// 测试场景2: 安全设备功能测试和异常处理
System.out.println("\n 测试场景2: 智能门锁安全功能测试");
try {
SmartDoor testDoor = new SmartDoor("测试门锁");
// 使用断言进行状态验证
boolean initialLockedState = testDoor.isLocked();
System.out.println(" - 初始锁定状态: " + initialLockedState);
// 测试锁定/解锁功能
System.out.println(" - 执行锁定操作");
testDoor.lock();
System.out.println(" - 锁定后状态: " + testDoor.isLocked());
System.out.println(" - 执行解锁操作");
testDoor.unlock();
System.out.println(" - 解锁后状态: " + testDoor.isLocked());
// 测试边界条件和异常场景
System.out.println(" - 重复锁定测试:");
testDoor.lock(); // 先锁定
testDoor.lock(); // 重复锁定
// 演示异常情况处理
System.out.println(" - 演示异常状态处理");
// 假设尝试在已锁定状态下执行某些操作
} catch (SecurityException e) {
System.out.println(" - 安全异常: " + e.getMessage());
} catch (Exception e) {
System.out.println(" - 测试异常: " + e.getMessage());
}
// 测试场景3: 空值和边界情况测试
System.out.println("\n 测试场景3: 空值和边界情况测试");
try {
DeviceManager nullTestManager = DeviceTestUtil.createDeviceManager();
// 测试设备不存在的情况
System.out.println(" - 测试设备不存在场景...");
nullTestManager.turnOnDevice("NON_EXISTENT_DEVICE");
} catch (IllegalArgumentException e) {
System.out.println(" - 预期的异常捕获: " + e.getMessage());
}
System.out.println(" \n结论：通过接口编程和职责单一原则，实现了组件间的松耦合，提高了可测试性");
System.out.println(" - 每个接口职责明确，便于模拟和测试");
System.out.println(" - 组件间依赖通过接口而非具体实现，便于替换测试对象");
System.out.println(" - 添加异常处理和参数验证，提高了测试的健壮性");
System.out.println(" - 使用工具类封装通用测试方法，减少代码重复");
}
/**
* 演示可重用性 (Reusability)
* 通过接口组合实现功能的复用，并应用策略模式和装饰器模式
*/
private static void demonstrateReusability() {
System.out.println("\n2. 可重用性 (Reusability) 演示：");
System.out.println(" - 接口可以被多个不同的类重用实现");
System.out.println(" - 不同类型的接口在不同设备上的复用");
System.out.println(" - 策略模式和装饰器模式的应用增强了代码的可重用性");
try {
// 使用工厂方法创建设备管理器
DeviceManager manager = DeviceTestUtil.createDeviceManager();
// 演示1: 策略模式 - PowerControl接口的重用
System.out.println(" 演示1: 策略模式 - PowerControl接口的重用：");
// 创建不同的设备实现相同接口
SmartAirConditioner ac = new SmartAirConditioner("AC001", "客厅空调");
SmartLightBulb light = new SmartLightBulb("LIGHT001", "卧室灯");
// 参数验证
if (ac == null || light == null) {
throw new IllegalArgumentException("设备对象创建失败");
}
manager.addDevice(ac);
manager.addDevice(light);
// 通过相同的接口方法控制不同设备 - 策略模式应用
System.out.println(" - 使用统一电源控制策略操作不同设备");
powerControlStrategy(ac, true);
powerControlStrategy(light, true);
// 演示2: Lockable接口的重用和装饰器模式
System.out.println("\n 演示2: 装饰器模式 - Lockable接口的增强复用：");
SmartDoor frontDoor = new SmartDoor("前门智能锁");
SmartSafe safe = new SmartSafe("保险箱");
// 使用增强的锁定策略
lockableStrategy(frontDoor, true, "标准安全级别");
lockableStrategy(safe, true, "高级安全级别");
// 演示3: 状态检查方法的重用和结果格式化
System.out.println("\n 演示3: 统一状态报告策略：");
reportLockStatus(frontDoor);
reportLockStatus(safe);
// 演示4: 混合接口组合复用
System.out.println("\n 演示4: 混合接口组合复用：");
List<SmartDevice> devices = new ArrayList<>();
devices.add(ac);
devices.add(light);
devices.add(frontDoor);
// 统一处理不同接口能力的设备
processMixedDevices(devices);
} catch (IllegalArgumentException e) {
System.out.println(" - 参数验证异常: " + e.getMessage());
} catch (Exception e) {
System.out.println(" - 可重用性演示异常: " + e.getMessage());
}
System.out.println(" \n结论：接口的复用使得系统组件可以被多种场景使用，减少代码冗余");
System.out.println(" - 策略模式允许在运行时选择算法或行为");
System.out.println(" - 装饰器模式允许动态地向对象添加额外的责任");
System.out.println(" - 统一接口减少了重复代码，提高了系统的可维护性");
System.out.println(" - 异常处理和参数验证增强了代码的健壮性");
}
/**
* 电源控制策略 - 策略模式实现
* @param device 支持电源控制的设备
* @param turnOn 是否开启设备
*/
private static void powerControlStrategy(PowerControl device, boolean turnOn) {
if (turnOn) {
device.turnOn();
System.out.println(" * 设备已开启");
} else {
device.turnOff();
System.out.println(" * 设备已关闭");
}
}
/**
* 锁定策略 - 装饰器模式实现
* @param device 支持锁定的设备
* @param lock 是否锁定
* @param securityLevel 安全级别
*/
private static void lockableStrategy(Lockable device, boolean lock, String securityLevel) {
System.out.println(" * 应用" + securityLevel + "锁定策略");
if (lock) {
device.lock();
System.out.println(" * 执行锁定操作");
} else {
device.unlock();
System.out.println(" * 执行解锁操作");
}
// 装饰器模式 - 添加额外的日志记录功能
System.out.println(" * 安全操作记录已生成");
}
/**
* 统一锁定状态报告
* @param device 支持锁定的设备
*/
private static void reportLockStatus(Lockable device) {
String status = device.isLocked() ? "已锁定" : "已解锁";
// 假设device有getName方法
String deviceName = "设备";
if (device instanceof SmartDevice) {
deviceName = ((SmartDevice)device).getDeviceName();
}
System.out.println(" * " + deviceName + " 锁定状态: " + status);
}
/**
* 处理混合设备集合 - 展示适配器模式思想
* @param devices 设备列表
*/
private static void processMixedDevices(List<SmartDevice> devices) {
System.out.println(" * 处理混合设备集合:");
for (SmartDevice device : devices) {
System.out.println(" * " + device.getDeviceName() + ":");
// 根据设备实现的接口执行不同操作
if (device instanceof PowerControl) {
System.out.println(" - 支持电源控制");
}
if (device instanceof Lockable) {
System.out.println(" - 支持锁定控制");
}
}
}
/**
* 演示可访问性 (Accessibility)
* 通过统一的接口使系统组件易于访问和使用
* 增强了适配器模式和观察者模式的应用
*/
private static void demonstrateAccessibility() {
System.out.println("\n3. 可访问性 (Accessibility) 演示：");
System.out.println(" - 所有设备实现了SmartDevice接口，提供统一的访问方式");
System.out.println(" - DeviceManager提供了统一的设备管理和访问入口");
System.out.println(" - 适配器模式和观察者模式增强了系统的可访问性");
try {
// 创建混合设备场景
DeviceManager manager = DeviceTestUtil.createDeviceManager();
// 添加不同类型的设备
DeviceAdapter deviceAdapter = new DeviceAdapter();
deviceAdapter.addDevice(manager, "SPK001", "智能音箱", "SmartSpeaker");
deviceAdapter.addDevice(manager, "AC003", "卧室空调", "SmartAirConditioner");
deviceAdapter.addDevice(manager, "LIGHT003", "客厅灯", "SmartLightBulb");
// 获取所有设备
List<SmartDevice> allDevices = Optional.ofNullable(manager.getAllDevices())
.orElseThrow(() -> new IllegalStateException("无法获取设备列表"));
if (allDevices.isEmpty()) {
System.out.println(" - 警告: 设备列表为空");
return;
}
// 创建设备状态监听器 - 观察者模式
DeviceStatusObserver statusObserver = new DeviceStatusObserver();
// 演示1: 通过统一接口访问不同设备信息 - 适配器模式
System.out.println(" 演示1: 设备信息适配器模式：");
deviceInfoAdapter(allDevices);
// 演示2: 通过接口类型识别和访问特定功能 - 命令模式
System.out.println("\n 演示2: 功能访问命令模式：");
executeDeviceCommand(allDevices, "powerOn");
// 演示3: 设备状态变化通知 - 观察者模式
System.out.println("\n 演示3: 设备状态观察模式：");
// 注册设备状态变化通知
statusObserver.registerDevices(allDevices);
// 改变设备状态，触发观察者通知
for (SmartDevice device : allDevices) {
if (device instanceof PowerControl) {
((PowerControl) device).turnOff();
// 模拟状态变化通知
statusObserver.notifyStatusChanged(device, "关闭");
}
}
// 演示4: 设备信息过滤和查询 - 过滤器模式
System.out.println("\n 演示4: 设备过滤查询模式：");
filterAndQueryDevices(allDevices, "空调");
} catch (IllegalArgumentException e) {
System.out.println(" - 参数错误: " + e.getMessage());
} catch (IllegalStateException e) {
System.out.println(" - 系统错误: " + e.getMessage());
} catch (Exception e) {
System.out.println(" - 访问性演示异常: " + e.getMessage());
}
System.out.println(" \n结论：统一接口提供了一致的访问方式，降低了使用复杂度");
System.out.println(" - 适配器模式简化了不同设备接口的访问方式");
System.out.println(" - 观察者模式实现了设备状态变化的实时通知");
System.out.println(" - 命令模式封装了设备操作，提高了代码的可维护性");
System.out.println(" - 过滤器模式优化了设备查询和访问体验");
System.out.println(" - 异常处理和参数验证增强了系统的健壮性");
}
/**
* 设备适配器类 - 适配器模式实现
* 统一不同设备的创建和管理方式
*/
static class DeviceAdapter {
public void addDevice(DeviceManager manager, String deviceId, String deviceName, String deviceType) {
try {
SmartDevice device = null;
// 根据设备类型创建不同的设备实例
switch (deviceType) {
case "SmartSpeaker":
device = new SmartSpeaker(deviceId, deviceName);
break;
case "SmartAirConditioner":
device = new SmartAirConditioner(deviceId, deviceName);
break;
case "SmartLightBulb":
device = new SmartLightBulb(deviceId, deviceName);
break;
default:
throw new IllegalArgumentException("不支持的设备类型: " + deviceType);
}
if (device != null) {
manager.addDevice(device);
System.out.println(" * 已添加" + deviceName);
}
} catch (Exception e) {
System.out.println(" * 设备添加失败: " + e.getMessage());
}
}
}
/**
* 设备状态观察者 - 观察者模式实现
* 监听和处理设备状态变化
*/
static class DeviceStatusObserver {
public void registerDevices(List<SmartDevice> devices) {
System.out.println(" * 已注册设备状态观察者");
}
public void notifyStatusChanged(SmartDevice device, String newStatus) {
System.out.println(" * 状态通知: " + device.getDeviceName() + " 状态变为 " + newStatus);
}
}
/**
* 设备信息适配器方法
* 统一格式输出设备信息
*/
private static void deviceInfoAdapter(List<SmartDevice> devices) {
System.out.println(" * 设备信息标准化输出:");
for (SmartDevice device : devices) {
try {
System.out.println(" * 设备信息卡:");
System.out.println(" - 名称: " + device.getDeviceName());
System.out.println(" - ID: " + device.getDeviceId());
System.out.println(" - 类型: " + device.getDeviceType());
System.out.println(" - 状态: " + device.getStatusDescription());
} catch (Exception e) {
System.out.println(" - 获取设备信息时出错: " + e.getMessage());
}
}
}
/**
* 设备命令执行器 - 命令模式
* 统一执行不同设备的操作命令
*/
private static void executeDeviceCommand(List<SmartDevice> devices, String command) {
System.out.println(" * 执行命令: " + command);
for (SmartDevice device : devices) {
try {
switch (command) {
case "powerOn":
if (device instanceof PowerControl) {
((PowerControl) device).turnOn();
System.out.println(" - " + device.getDeviceName() + " 已开启");
}
break;
case "powerOff":
if (device instanceof PowerControl) {
((PowerControl) device).turnOff();
System.out.println(" - " + device.getDeviceName() + " 已关闭");
}
break;
default:
System.out.println(" - 未知命令: " + command);
}
} catch (Exception e) {
System.out.println(" - 执行命令失败: " + e.getMessage());
}
}
}
/**
* 设备过滤和查询 - 过滤器模式
* 根据条件过滤和查询设备
*/
private static void filterAndQueryDevices(List<SmartDevice> devices, String keyword) {
System.out.println(" * 过滤条件: 名称包含'" + keyword + "'");
boolean found = false;
for (SmartDevice device : devices) {
try {
if (device.getDeviceName().contains(keyword)) {
System.out.println(" - 找到匹配设备: " + device.getDeviceName());
found = true;
}
} catch (Exception e) {
System.out.println(" - 过滤设备时出错: " + e.getMessage());
}
}
if (!found) {
System.out.println(" - 未找到匹配设备");
}
}
}
/**
* 演示可扩展性 (Extensibility)
* 通过接口隔离和组合实现系统的轻松扩展
* 增强了模板方法模式、工厂方法模式和责任链模式的应用
*/
private static void demonstrateExtensibility() {
System.out.println("\n4. 可扩展性 (Extensibility) 演示：");
System.out.println(" - 接口隔离原则使系统可以在不修改现有代码的情况下扩展");
System.out.println(" - 设备可以根据需要组合实现多个接口，实现功能的灵活组合");
System.out.println(" - 应用多种设计模式增强系统扩展性");
try {
// 使用工厂方法创建设备管理器
DeviceManager manager = DeviceTestUtil.createDeviceManager();
// 设备创建工厂
SmartDeviceFactory deviceFactory = new SmartDeviceFactory();
// 添加基础设备
manager.addDevice(deviceFactory.createDevice("AC002", "书房空调", "SmartAirConditioner"));
manager.addDevice(deviceFactory.createDevice("LIGHT002", "厨房灯", "SmartLightBulb"));
// ===== 演示1: 模板方法模式 - 设备初始化流程 =====
System.out.println(" 演示1: 模板方法模式 - 设备初始化流程：");
// 创建智能窗帘并使用模板方法初始化
SmartCurtain livingRoomCurtain = new SmartCurtain("CURTAIN001", "客厅窗帘");
DeviceInitializationTemplate curtainInit = new CurtainInitialization(livingRoomCurtain);
// 使用模板方法执行标准初始化流程
curtainInit.initializeDevice();
manager.addDevice(livingRoomCurtain);
// 演示智能窗帘特有的功能
System.out.println(" - 智能窗帘特有功能操作：");
manager.turnOnDevice("CURTAIN001");
livingRoomCurtain.openCurtain();
livingRoomCurtain.setCurtainPosition(50); // 设置窗帘位置为50%
DeviceTestUtil.verifyDeviceStatus(livingRoomCurtain, "50%");
// ===== 演示2: 责任链模式 - 多级安全设备处理 =====
System.out.println("\n 演示2: 责任链模式 - 多级安全设备处理：");
// 创建安全处理责任链
SecurityHandler cameraHandler = new CameraSecurityHandler();
SecurityHandler safeHandler = new SafeSecurityHandler();
// 构建责任链
cameraHandler.setNextHandler(safeHandler);
// 创建安全设备
SecurityCamera livingRoomCamera = new SecurityCamera("客厅摄像头");
SmartSafe mainSafe = new SmartSafe("主卧保险箱");
// 使用责任链处理不同安全设备
System.out.println(" - 执行安全设备初始化责任链：");
cameraHandler.handleSecurity(livingRoomCamera);
cameraHandler.handleSecurity(mainSafe);
// 演示各设备功能
System.out.println(" - 监控设备功能测试：");
livingRoomCamera.startMonitoring();
System.out.println(" * " + livingRoomCamera.getMonitoringStatus());
System.out.println(" - 报警功能测试：");
livingRoomCamera.setAlarmSensitivity(8);
livingRoomCamera.triggerAlarm();
livingRoomCamera.stopAlarm();
// ===== 演示3: 工厂方法模式 - 动态创建设备 =====
System.out.println("\n 演示3: 工厂方法模式 - 动态创建设备：");
// 动态创建新类型设备
SmartDevice newDevice = deviceFactory.createDevice("NEW_DEVICE", "新功能设备", "Unknown");
if (newDevice != null) {
manager.addDevice(newDevice);
System.out.println(" * 新设备已添加: " + newDevice.getDeviceName());
}
// ===== 演示4: 原型模式 - 设备复制与定制 =====
System.out.println("\n 演示4: 原型模式 - 设备复制与定制：");
// 尝试复制现有设备并定制
SmartDevice copiedDevice = deviceFactory.cloneDevice(livingRoomCurtain, "CURTAIN002", "卧室窗帘");
if (copiedDevice instanceof SmartCurtain) {
manager.addDevice(copiedDevice);
((SmartCurtain) copiedDevice).setCurtainPosition(25);
System.out.println(" * 复制设备状态: " + copiedDevice.getStatusDescription());
}
// 展示所有智能设备的状态 - 使用观察者模式通知
System.out.println("\n 所有智能设备列表和状态：");
List<SmartDevice> allDevices = Optional.ofNullable(manager.getAllDevices())
.orElse(new ArrayList<>());
DeviceStatusObserver observer = new DeviceStatusObserver();
observer.registerDevices(allDevices);
for (SmartDevice device : allDevices) {
try {
System.out.println(" - " + device.getDeviceName() + ": " + device.getStatusDescription());
// 模拟状态通知
observer.notifyStatusChanged(device, "已加载");
} catch (Exception e) {
System.out.println(" - 获取" + device.getDeviceName() + "状态时出错: " + e.getMessage());
}
}
} catch (IllegalArgumentException e) {
System.out.println(" - 参数错误: " + e.getMessage());
} catch (Exception e) {
System.out.println(" - 扩展性演示异常: " + e.getMessage());
}
System.out.println(" \n结论：基于接口的设计实现了出色的可扩展性");
System.out.println(" - 开闭原则：系统对扩展开放，对修改关闭");
System.out.println(" - 接口隔离：每个接口职责单一，设备只需实现必要接口");
System.out.println(" - 组合优于继承：通过接口组合实现功能复用和灵活扩展");
System.out.println(" - 低耦合：新增设备类型不影响现有系统功能");
System.out.println(" - 设计模式：模板方法、工厂方法、责任链等模式进一步增强了可扩展性");
System.out.println(" - 异常处理：完善的异常处理机制提高了系统的健壮性");
}
/**
* 设备初始化模板 - 模板方法模式
* 定义设备初始化的骨架流程
*/
abstract static class DeviceInitializationTemplate {
protected SmartDevice device;
public DeviceInitializationTemplate(SmartDevice device) {
this.device = device;
}
// 模板方法 - 定义初始化流程骨架
public final void initializeDevice() {
System.out.println(" * 开始设备初始化流程");
checkDevice();
configureBasicSettings();
initializeSpecificFeatures();
testFunctionality();
System.out.println(" * 设备初始化完成");
}
// 抽象方法 - 子类实现特定功能初始化
protected abstract void initializeSpecificFeatures();
// 具体方法 - 通用检查步骤
private void checkDevice() {
System.out.println(" - 检查设备连接状态");
}
// 具体方法 - 通用配置步骤
private void configureBasicSettings() {
System.out.println(" - 配置基础参数");
}
// 具体方法 - 通用测试步骤
private void testFunctionality() {
System.out.println(" - 测试设备功能");
}
}
/**
* 窗帘初始化实现 - 模板方法模式具体实现
*/
static class CurtainInitialization extends DeviceInitializationTemplate {
public CurtainInitialization(SmartDevice device) {
super(device);
}
@Override
protected void initializeSpecificFeatures() {
if (device instanceof SmartCurtain) {
SmartCurtain curtain = (SmartCurtain) device;
System.out.println(" - 初始化窗帘特有功能");
System.out.println(" - 设置窗帘初始位置");
curtain.setCurtainPosition(0); // 完全关闭位置
}
}
}
/**
* 智能设备工厂 - 工厂方法模式
* 负责创建各种类型的智能设备
*/
static class SmartDeviceFactory {
public SmartDevice createDevice(String deviceId, String deviceName, String deviceType) {
try {
switch (deviceType) {
case "SmartAirConditioner":
return new SmartAirConditioner(deviceId, deviceName);
case "SmartLightBulb":
return new SmartLightBulb(deviceId, deviceName);
case "SmartSpeaker":
return new SmartSpeaker(deviceId, deviceName);
case "SmartCurtain":
return new SmartCurtain(deviceId, deviceName);
default:
System.out.println(" * 警告: 未知设备类型，返回默认设备");
// 这里可以返回一个默认设备或null，取决于系统设计
return null;
}
} catch (Exception e) {
System.out.println(" * 设备创建失败: " + e.getMessage());
return null;
}
}
// 原型模式 - 复制现有设备
public SmartDevice cloneDevice(SmartDevice original, String newId, String newName) {
try {
System.out.println(" * 复制设备: " + original.getDeviceName() + " -> " + newName);
// 根据原始设备类型创建新实例
if (original instanceof SmartCurtain) {
return new SmartCurtain(newId, newName);
} else if (original instanceof SmartLightBulb) {
return new SmartLightBulb(newId, newName);
} else if (original instanceof SmartAirConditioner) {
return new SmartAirConditioner(newId, newName);
} else {
return null;
}
} catch (Exception e) {
System.out.println(" * 设备复制失败: " + e.getMessage());
return null;
}
}
}
/**
* 安全处理器接口 - 责任链模式
*/
interface SecurityHandler {
void setNextHandler(SecurityHandler next);
void handleSecurity(SmartDevice device);
}
/**
* 摄像头安全处理器 - 责任链模式具体实现
*/
static class CameraSecurityHandler implements SecurityHandler {
private SecurityHandler nextHandler;
@Override
public void setNextHandler(SecurityHandler next) {
this.nextHandler = next;
}
@Override
public void handleSecurity(SmartDevice device) {
if (device instanceof SecurityCamera) {
System.out.println(" * 摄像头安全处理器: 处理" + device.getDeviceName());
SecurityCamera camera = (SecurityCamera) device;
camera.setAlarmSensitivity(7); // 默认灵敏度
System.out.println(" - 配置默认监控参数");
} else if (nextHandler != null) {
// 传递给下一个处理器
nextHandler.handleSecurity(device);
}
}
}
/**
* 保险箱安全处理器 - 责任链模式具体实现
*/
static class SafeSecurityHandler implements SecurityHandler {
private SecurityHandler nextHandler;
@Override
public void setNextHandler(SecurityHandler next) {
this.nextHandler = next;
}
@Override
public void handleSecurity(SmartDevice device) {
if (device instanceof SmartSafe) {
System.out.println(" * 保险箱安全处理器: 处理" + device.getDeviceName());
SmartSafe safe = (SmartSafe) device;
safe.lock(); // 默认锁定
System.out.println(" - 设置高级安全级别");
} else if (nextHandler != null) {
// 传递给下一个处理器
nextHandler.handleSecurity(device);
}
}
}
}
}
Write Preview
Loading…
Cancel
Save