★ FEATURED ARTICLE 1. 面向对象编程高级特性全景解读面向对象编程(OOP)的高级特性是每个开发者从入门到精进的必经之路。当你能熟练运用封装、继承和多态三大基础特性后就该深入理解这些更强大的工具了。我在实际工程中发现很多看似复杂的架构问题其实都能用这些高级特性优雅解决。最近在技术社区看到有人讨论R是面向对象编程吗这类问题其实反映了很多开发者对OOP本质的理解还不够深入。真正的面向对象不在于语言标签而在于如何运用这些特性构建灵活、可维护的系统。下面我就结合十多年实战经验带你系统掌握这些能真正提升代码质量的高级技巧。2. 类与对象的深层机制2.1 类加载与初始化过程类加载器的工作原理就像建筑工地的材料配送系统。当JVM需要用一个类时加载阶段把.class文件二进制数据读入方法区验证阶段检查文件格式、元数据等就像质检员检查建材准备阶段为静态变量分配内存并设默认值解析阶段将符号引用转为直接引用初始化阶段执行静态代码块和静态变量赋值关键经验静态代码块的执行顺序会影响程序行为。我曾遇到过一个bug就是因为静态变量初始化依赖了尚未初始化的另一个类。2.2 对象内存布局详解一个普通对象在HotSpot VM中的内存布局对象头8-12字节包含Mark Word和类型指针实例数据所有字段按声明顺序排列对齐填充保证对象大小是8字节的倍数通过JOL工具可以查看实际内存布局// 添加JOL依赖后 System.out.println(ClassLayout.parseInstance(obj).toPrintable());3. 继承体系的进阶用法3.1 多继承的替代方案Java虽然不支持多继承但通过接口默认方法可以实现类似效果。比如要开发一个能飞、能游泳的超级英雄public interface Flyable { default void fly() { System.out.println(Flying with default method); } } public interface Swimmable { default void swim() { System.out.println(Swimming with default method); } } public class SuperHero implements Flyable, Swimmable { // 同时获得两种能力 }3.2 继承与组合的抉择在我参与的一个电商项目中初期过度使用继承导致类层次过深。后来改用组合模式重构// 不好的继承设计 class DiscountOrder extends Order { // 折扣相关逻辑 } // 更好的组合设计 class Order { private DiscountStrategy strategy; public void applyDiscount() { strategy.apply(this); } }经验法则当出现is-a关系时用继承出现has-a关系时用组合。4. 多态的高级应用场景4.1 动态分派与静态分派方法重写是动态分派的典型例子class Animal { void speak() { System.out.println(...); } } class Dog extends Animal { Override void speak() { System.out.println(Woof!); } } // 运行时根据实际类型决定调用哪个方法 Animal a new Dog(); a.speak(); // 输出Woof!而方法重载是静态分派void foo(String s) {} void foo(Integer i) {} // 编译时根据参数静态类型决定 foo(hello); // 调用String版本4.2 策略模式实战在支付系统开发中我们使用策略模式实现多支付方式interface PaymentStrategy { void pay(int amount); } class AlipayStrategy implements PaymentStrategy { public void pay(int amount) { // 支付宝支付逻辑 } } class PaymentContext { private PaymentStrategy strategy; public void executePay(int amount) { strategy.pay(amount); } }5. 异常处理最佳实践5.1 自定义异常体系设计良好的异常体系应该继承自合适的父类RuntimeException或Exception提供有意义的错误信息包含必要的上下文数据public class PaymentException extends RuntimeException { private String orderId; private BigDecimal amount; public PaymentException(String message, String orderId, BigDecimal amount) { super(message); this.orderId orderId; this.amount amount; } }5.2 异常处理反模式常见错误用法包括捕获异常后不做任何处理过度使用throws声明把异常用于正常流程控制我曾见过最糟糕的代码try { // 业务逻辑 } catch (Exception e) { // 空catch块 }6. 泛型与类型系统6.1 泛型擦除的应对策略由于类型擦除运行时无法获取泛型类型参数。但可以通过以下方式绕过限制class GenericTypeT { private final ClassT type; public GenericType(ClassT type) { this.type type; } public T createInstance() throws Exception { return type.getDeclaredConstructor().newInstance(); } }6.2 泛型边界的高级用法// 多重边界 T extends Serializable ComparableT // 通配符捕获 public static void swap(List? list, int i, int j) { swapHelper(list, i, j); } private static E void swapHelper(ListE list, int i, int j) { E tmp list.get(i); list.set(i, list.get(j)); list.set(j, tmp); }7. 反射与动态代理7.1 反射性能优化反射调用比直接调用慢50-100倍。优化方案缓存Method/Field对象使用MethodHandleJDK7考虑字节码生成如CGLIB// 不好的做法每次获取Method method obj.getClass().getMethod(foo); // 好的做法缓存Method private static final Method FOO_METHOD; static { try { FOO_METHOD TargetClass.class.getMethod(foo); } catch (Exception e) { throw new RuntimeException(e); } }7.2 动态代理实战实现InvocationHandler的典型模式public class LoggingProxy implements InvocationHandler { private final Object target; public static Object createProxy(Object target) { return Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), new LoggingProxy(target)); } Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(Before method.getName()); Object result method.invoke(target, args); System.out.println(After method.getName()); return result; } }8. 设计模式深度应用8.1 模板方法模式变体传统模板方法使用继承但可以用函数式接口改进public class Processor { public void process(ConsumerContext preStep, FunctionContext, Result mainStep, ConsumerResult postStep) { Context ctx new Context(); preStep.accept(ctx); Result result mainStep.apply(ctx); postStep.accept(result); } }8.2 观察者模式现代化实现不再需要自定义观察者接口直接使用Java 9的Flow APIpublic class NewsPublisher implements Flow.PublisherString { private final SubmissionPublisherString publisher new SubmissionPublisher(); public void subscribe(Flow.Subscriber? super String subscriber) { publisher.subscribe(subscriber); } public void publish(String news) { publisher.submit(news); } }9. 并发编程中的OOP原则9.1 不可变对象设计构建线程安全类的最佳实践所有字段设为final不提供setter方法返回防御性副本public final class ImmutablePoint { private final int x; private final int y; public ImmutablePoint(int x, int y) { this.x x; this.y y; } public int getX() { return x; } public int getY() { return y; } public ImmutablePoint withX(int newX) { return new ImmutablePoint(newX, this.y); } }9.2 线程局部存储技巧ThreadLocal的典型使用场景private static final ThreadLocalSimpleDateFormat dateFormat ThreadLocal.withInitial(() - new SimpleDateFormat(yyyy-MM-dd)); // 每个线程有自己的SimpleDateFormat实例 String date dateFormat.get().format(new Date());重要提示ThreadLocal使用后必须remove否则可能导致内存泄漏特别是在线程池场景。10. 元编程与注解处理10.1 自定义注解实战定义一个用于自动记录方法耗时的注解Retention(RetentionPolicy.RUNTIME) Target(ElementType.METHOD) public interface TimeLog { String value() default ; }通过AOP或动态代理实现处理逻辑TimeLog(重要操作) public void criticalOperation() { // 业务逻辑 }10.2 编译时注解处理器实现AbstractProcessor的基本结构SupportedAnnotationTypes(com.example.MyAnnotation) SupportedSourceVersion(SourceVersion.RELEASE_11) public class MyProcessor extends AbstractProcessor { Override public boolean process(Set? extends TypeElement annotations, RoundEnvironment roundEnv) { // 处理注解逻辑 return true; } }在Maven中配置注解处理器plugin groupIdorg.apache.maven.plugins/groupId artifactIdmaven-compiler-plugin/artifactId configuration annotationProcessors annotationProcessorcom.example.MyProcessor/annotationProcessor /annotationProcessors /configuration /plugin11. 函数式编程与OOP融合11.1 Lambda表达式的本质每个lambda表达式都是某个函数式接口的实例FunctionString, Integer lengthFunc s - s.length(); // 等价于 FunctionString, Integer lengthFunc new Function() { public Integer apply(String s) { return s.length(); } };11.2 方法引用分类四种方法引用形式静态方法引用ClassName::staticMethod实例方法引用instance::method任意对象方法引用ClassName::method构造器引用ClassName::new在集合操作中的典型应用list.stream() .map(String::toUpperCase) .filter(s - s.length() 5) .forEach(System.out::println);12. 性能优化专项技巧12.1 对象池模式实现避免频繁创建销毁对象的开销public class ObjectPoolT { private final SupplierT creator; private final QueueT pool new ConcurrentLinkedQueue(); public ObjectPool(SupplierT creator) { this.creator creator; } public T borrow() { T obj pool.poll(); return obj ! null ? obj : creator.get(); } public void release(T obj) { pool.offer(obj); } }12.2 内存布局优化通过字段重排序减少对象大小class Optimized { byte b; // 1字节 int i; // 4字节 boolean flag; // 1字节 long l; // 8字节 } // 原始布局可能产生7字节填充 // 调整后 class Optimized { long l; // 8字节 int i; // 4字节 byte b; // 1字节 boolean flag; // 1字节 } // 仅产生2字节填充13. 设计原则深度实践13.1 SOLID原则的权衡在实际项目中有时需要权衡这些原则。比如在开发一个快速原型时可以暂时违反开闭原则直接修改现有类但必须确保不违反单一职责原则接口隔离原则可以适当放宽经验分享我曾在一个紧急项目中过度追求SOLID结果导致开发速度严重下降。后来学会根据项目阶段灵活调整。13.2 迪米特法则的现代解读传统的迪米特法则要求 只与直接朋友通信现代OO设计中可以通过以下方式平衡适当使用DTO传递数据采用CQRS模式分离读写模型使用事件总线降低耦合// 传统方式 order.getCustomer().getAddress().getCity(); // 更好的方式 orderService.getOrderCity(orderId);14. 架构设计中的OOP思维14.1 模块化设计模式Java 9的模块系统(JPMS)与OOP结合module com.example.myapp { requires java.base; requires transitive com.example.utils; exports com.example.myapp.api; }配合接口设计// 在api模块 public interface Service { void execute(); } // 在impl模块 public class ServiceImpl implements Service { public void execute() { // 实现细节 } }14.2 防腐层设计在微服务架构中保护领域模型public class AntiCorruptionLayer { private final ExternalServiceAdapter adapter; public DomainObject convert(ExternalDTO external) { // 转换逻辑防止外部模型污染核心领域 return new DomainObject( adapter.convertValue(external.getValue()), adapter.convertType(external.getType()) ); } }15. 测试驱动开发与OOP15.1 可测试性设计提高可测试性的关键方法依赖注入取代硬编码依赖接口隔离原则避免静态方法和单例// 难以测试的代码 public class OrderProcessor { public void process(Order order) { Database.save(order); // 静态调用 EmailSender.sendConfirmation(); // 隐藏依赖 } } // 可测试的改进 public class OrderProcessor { private final OrderRepository repo; private final NotificationService notifier; public void process(Order order) { repo.save(order); notifier.sendConfirmation(); } }15.2 Mock对象的高级用法使用Mockito进行行为验证Test public void testOrderProcessing() { OrderRepository mockRepo mock(OrderRepository.class); NotificationService mockNotifier mock(NotificationService.class); OrderProcessor processor new OrderProcessor(mockRepo, mockNotifier); Order testOrder new Order(test123); processor.process(testOrder); verify(mockRepo).save(testOrder); verify(mockNotifier).sendConfirmation(); }16. 代码异味与重构技巧16.1 长方法分解模式重构前的代码public void processOrder(Order order) { // 验证逻辑...20行 // 计算折扣...15行 // 库存检查...25行 // 支付处理...30行 // 物流安排...20行 }重构步骤提取验证逻辑到validateOrder方法提取折扣计算到calculateDiscount以此类推每个逻辑块提取为独立方法最终主方法变为方法调用组合16.2 过度继承重构发现继承层次过深时识别可以改为组合的关系使用提取接口技术用策略模式替换条件逻辑// 重构前 class ReportGenerator { void generatePDF() {...} void generateHTML() {...} } // 重构后 interface ReportFormat { void generate(ReportData data); } class PDFGenerator implements ReportFormat {...} class HTMLGenerator implements ReportFormat {...} class ReportGenerator { private ReportFormat format; void generate() { format.generate(data); } }17. 领域驱动设计精要17.1 聚合根设计原则设计聚合根的要点通过唯一标识引用其他聚合保证聚合内的强一致性聚合间最终一致性public class Order { // 聚合根 private OrderId id; private ListOrderItem items; private CustomerId customerId; // 引用客户聚合 public void addItem(ProductId productId, int quantity) { // 维护聚合内部一致性 if (items.stream().anyMatch(i - i.getProductId().equals(productId))) { throw new IllegalStateException(Product already in order); } items.add(new OrderItem(productId, quantity)); } }17.2 值对象模式实现值对象的要点不可变性基于值的相等性完整的领域行为public final class Money { private final BigDecimal amount; private final Currency currency; public Money add(Money other) { if (!currency.equals(other.currency)) { throw new IllegalArgumentException(Currency mismatch); } return new Money(amount.add(other.amount), currency); } Override public boolean equals(Object o) { if (this o) return true; if (!(o instanceof Money)) return false; Money money (Money) o; return amount.compareTo(money.amount) 0 currency.equals(money.currency); } }18. 现代Java特性与OOP18.1 Record类的设计哲学Record是纯粹的数据载体public record Point(int x, int y) { // 自动生成 // - final字段 // - 构造器 // - equals/hashCode // - toString } // 使用方式 Point p new Point(10, 20); System.out.println(p.x()); // 访问器方法18.2 Sealed类的最佳实践控制继承层次的新方式public sealed class Shape permits Circle, Rectangle, Triangle { public abstract double area(); } public final class Circle extends Shape { private final double radius; Override public double area() { return Math.PI * radius * radius; } }19. 对象关系映射进阶19.1 延迟加载陷阱N1查询问题的解决方案使用JOIN FETCHQuery(SELECT o FROM Order o JOIN FETCH o.items WHERE o.id :id) Order findByIdWithItems(Param(id) Long id);配置批量加载spring.jpa.properties.hibernate.default_batch_fetch_size2019.2 继承映射策略每个具体类一张表的策略Entity Inheritance(strategy InheritanceType.TABLE_PER_CLASS) public abstract class Payment { Id private Long id; private BigDecimal amount; } Entity public class CreditCardPayment extends Payment { private String cardNumber; } Entity public class BankTransferPayment extends Payment { private String accountNumber; }20. 微服务中的对象设计20.1 领域事件模式实现领域事件的典型方式public class OrderShippedEvent { private final OrderId orderId; private final LocalDateTime shippedDate; // 构造函数、getter等 } public class Order { private final ListDomainEvent events new ArrayList(); public void ship() { this.status Status.SHIPPED; events.add(new OrderShippedEvent(this.id, LocalDateTime.now())); } public ListDomainEvent getEvents() { return Collections.unmodifiableList(events); } }20.2 服务间DTO设计设计良好的DTO应该保持扁平结构仅包含必要字段使用不可变设计public record OrderDTO( String orderId, String customerName, ListOrderItemDTO items, BigDecimal totalAmount ) {} public record OrderItemDTO( String productId, String productName, int quantity, BigDecimal unitPrice ) {}21. 响应式编程与OOP21.1 响应式对象设计将传统对象转换为响应式public class ReactiveUserService { private final ReactiveUserRepository repository; public MonoUser getUser(String id) { return repository.findById(id) .timeout(Duration.ofSeconds(1)) .onErrorResume(e - Mono.empty()); } }21.2 背压处理策略常见的背压策略实现Flux.range(1, 100) .onBackpressureBuffer(10) // 缓冲10个元素 .subscribe( data - process(data), err - handleError(err), () - complete(), subscription - subscription.request(5) // 初始请求5个 );22. 云原生中的对象设计22.1 配置对象设计Spring Cloud Config的配置类示例ConfigurationProperties(app.mail) public class MailProperties { private String host; private int port; private String username; private String password; // getters和setters }22.2 健康检查对象自定义健康检查实现Component public class DatabaseHealthIndicator implements HealthIndicator { private final DataSource dataSource; Override public Health health() { try (Connection conn dataSource.getConnection()) { if (conn.isValid(1000)) { return Health.up().build(); } } catch (SQLException e) { return Health.down(e).build(); } return Health.unknown().build(); } }23. 安全领域的对象设计23.1 权限对象模型基于角色的访问控制实现public class User { private String username; private SetRole roles; public boolean hasPermission(String permission) { return roles.stream() .flatMap(r - r.getPermissions().stream()) .anyMatch(p - p.equals(permission)); } } public record Role(String name, SetString permissions) {}23.2 加密对象设计封装加密逻辑的良好实践public interface Encryptor { String encrypt(String plaintext); String decrypt(String ciphertext); } public class AesEncryptor implements Encryptor { private final SecretKey key; private final IvParameterSpec iv; Override public String encrypt(String plaintext) { Cipher cipher Cipher.getInstance(AES/CBC/PKCS5Padding); cipher.init(Cipher.ENCRYPT_MODE, key, iv); byte[] encrypted cipher.doFinal(plaintext.getBytes()); return Base64.getEncoder().encodeToString(encrypted); } }24. 性能监控对象设计24.1 度量指标对象Micrometer指标收集示例public class OrderMetrics { private final Counter orderCounter; private final Timer orderProcessingTimer; public OrderMetrics(MeterRegistry registry) { orderCounter registry.counter(orders.count); orderProcessingTimer registry.timer(orders.processing.time); } public void recordOrder(Order order) { orderCounter.increment(); // 记录订单金额分布 registry.summary(orders.amount) .record(order.getAmount().doubleValue()); } }24.2 追踪上下文设计分布式追踪的上下文传递public class TracingContext { private static final ThreadLocalString traceId new ThreadLocal(); public static void startTrace() { traceId.set(generateId()); } public static String currentTraceId() { return traceId.get(); } public static void endTrace() { traceId.remove(); } }25. 前沿技术中的OOP演进25.1 模式匹配新特性Java 17中的模式匹配实例// instanceof模式匹配 if (obj instanceof String s) { System.out.println(s.length()); } // switch模式匹配 return switch (shape) { case Circle c - Math.PI * c.radius() * c.radius(); case Rectangle r - r.width() * r.height(); default - throw new IllegalArgumentException(); };25.2 虚拟线程与对象设计适应虚拟线程的对象设计原则避免使用synchronized减少线程局部存储使用并发集合public class VirtualThreadOrderProcessor { private final ConcurrentMapOrderId, Order orders new ConcurrentHashMap(); public CompletableFutureVoid processAsync(Order order) { return CompletableFuture.runAsync(() - { orders.put(order.id(), order); // 处理逻辑 }, VirtualThreadExecutor.getInstance()); } }26. 跨语言对象设计26.1 JSON序列化设计Jackson多态类型处理JsonTypeInfo( use JsonTypeInfo.Id.NAME, include JsonTypeInfo.As.PROPERTY, property type ) JsonSubTypes({ JsonSubTypes.Type(value CreditCardPayment.class, name cc), JsonSubTypes.Type(value BankTransferPayment.class, name bt) }) public abstract class Payment { private BigDecimal amount; }26.2 Protocol Buffers集成定义protobuf消息message Person { string name 1; int32 id 2; repeated string emails 3; }生成Java类后使用Person person Person.newBuilder() .setName(John Doe) .setId(1234) .addEmails(johnexample.com) .build();27. 遗留系统改造策略27.1 绞杀者模式实践逐步替换旧系统的步骤在新功能中使用新架构通过门面模式桥接新旧系统逐步迁移旧功能最终关闭旧系统public class LegacyFacade { private final OldSystem oldSystem; private final NewSystem newSystem; public void processRequest(Request req) { if (req.isNewFeature()) { newSystem.handle(req); } else { oldSystem.handle(req); } } }27.2 防腐层实现细节完整防腐层实现示例public class LegacyAdapter { public ModernOrder convert(LegacyOrder legacy) { return new ModernOrder( legacy.getOrderNumber(), convertItems(legacy.getItems()), convertCustomer(legacy.getCustomer()) ); } private ListOrderItem convertItems(ListLegacyItem legacyItems) { return legacyItems.stream() .map(i - new OrderItem( i.getProductCode(), i.getQuantity(), new Money(i.getPrice(), Currency.USD) )) .collect(Collectors.toList()); } }28. 工具与框架设计思想28.1 插件系统设计基于SPI的插件架构public interface ProcessorPlugin { String getName(); void process(Document doc); } // META-INF/services/com.example.ProcessorPlugin public class PluginManager { public ListProcessorPlugin loadPlugins() { return ServiceLoader.load(ProcessorPlugin.class) .stream() .map(ServiceLoader.Provider::get) .collect(Collectors.toList()); } }28.2 领域特定语言设计内部DSL设计模式public class QueryBuilder { public static QueryBuilder select(String... fields) { return new QueryBuilder().fields(fields); } public QueryBuilder from(String table) { this.table table; return this; } public String build() { return SELECT String.join(, , fields) FROM table; } } // 使用方式 String sql QueryBuilder.select(id, name) .from(users) .build();29. 代码生成技术29.1 注解处理器实战实现代码生成的注解处理器AutoService(Processor.class) public class BuilderProcessor extends AbstractProcessor { Override public boolean process(Set? extends TypeElement annotations, RoundEnvironment roundEnv) { for (Element element : roundEnv.getElementsAnnotatedWith(GenerateBuilder.class)) { TypeElement classElement (TypeElement) element; generateBuilderClass(classElement); } return true; } private void generateBuilderClass(TypeElement classElement) { String className classElement.getSimpleName() Builder; // 生成构建器类代码 } }29.2 模板代码生成使用FreeMarker生成代码Configuration cfg new Configuration(Configuration.VERSION_2_3_31); cfg.setDirectoryForTemplateLoading(new File(templates)); Template template cfg.getTemplate(Model.java.ftl); MapString, Object data new HashMap(); data.put(className, User); data.put(fields, List.of( new Field(String, username), new Field(String, password) )); try (Writer out new FileWriter(User.java)) { template.process(data, out); }30. 架构演进与对象设计30.1 CQRS模式实现命令与查询分离的典型设计// 命令端 public class OrderCommandService { private final OrderRepository repository; public void createOrder(CreateOrderCommand command) { Order order new Order(command.getItems()); repository.save(order); eventPublisher.publish(new OrderCreatedEvent(order.getId())); } } // 查询端 public class OrderQueryService { private final OrderReadRepository readRepository; public OrderDTO getOrder(String id) { return readRepository.findById(id); } }30.2 事件溯源模式实现事件存储的基本结构public class EventStore { private final ListEvent events new ArrayList(); public void append(Event event) { events.add(event); // 持久化到数据库 } public T extends AggregateRoot T load(String id, ClassT type) { ListEvent aggregateEvents events.stream() .filter(e - e.getAggregateId().equals(id)) .collect(Collectors.toList()); T aggregate type.newInstance(); aggregate.replayEvents(aggregateEvents); return aggregate; } }31. 分布式对象设计31.1 分布式锁实现基于Redis的分布式锁public class RedisDistributedLock implements DistributedLock { private final RedisTemplateString, String redis; private final String lockKey; private final String lockValue; public boolean tryLock(long timeout, TimeUnit unit) { return redis.opsForValue().setIfAbsent( lockKey, lockValue, timeout, unit ); } public void unlock() { // 使用Lua脚本保证原子性 String script if redis.call(get, KEYS[1]) ARGV[1] then return redis.call(del, KEYS[1]) else return 0 end; redis.execute(script, Collections.singletonList(lockKey), lockValue); } }31.2 一致性哈希设计实现一致性哈希算法public class ConsistentHashT { private final SortedMapInteger, T circle new TreeMap(); private final HashFunction hashFunction; private final int replicaCount; public void add(T node) { for (int i 0; i replicaCount; i) { int hash hashFunction.hash(node.toString() i); circle.put(hash, node); } } public T get(Object key) { if (circle.isEmpty()) return null; int hash hashFunction.hash(key.toString()); SortedMapInteger, T tail circle.tailMap(hash); hash tail.isEmpty() ? circle.firstKey() : tail.firstKey(); return circle.get(hash); } }32. 机器学习中的OOP32.1 特征工程对象封装特征转换逻辑public interface FeatureTransformer { String getName(); ListDouble transform(ListDouble input); } public class StandardScaler implements FeatureTransformer { private final double mean; private final double std; public StandardScaler(ListDouble samples) { this.mean calculateMean(samples); this.std calculateStd(samples); } Override public ListDouble transform(ListDouble input) { return input.stream() .map(x - (x - mean) / std) .collect(Collectors.toList()); } }32.2 模型包装模式统一模型接口设计public interface Model { String getName(); void train(Dataset dataset); Prediction predict(Instance instance); } public class RandomForestWrapper implements Model { private final SmileRandomForest model; public Prediction predict(Instance instance) { double[] features instance.getFeatures(); double prediction model.predict(features); return new Prediction(prediction, model.confidence(features)); } }33. 物联网中的对象设计33.1 设备抽象层统一设备接口设计public interface IoTDevice { String getDeviceId(); DeviceStatus getStatus(); CompletableFutureVoid sendCommand(DeviceCommand command); Flow.PublisherDeviceEvent eventPublisher(); } public class SmartThermostat implements IoTDevice { private final MqttClient mqttClient; Override public CompletableFutureVoid sendCommand(DeviceCommand cmd) { return mqttClient.publish( devices/ getDeviceId() /commands, cmd.toJson().getBytes() ); } }33.2 遥测数据处理处理设备数据的管道设计public class TelemetryPipeline { private final ListTelemetryProcessor processors; public void process(TelemetryData data) { processors.stream() .reduce( data, (d, p) - p.process(d), (d1, d2) - { throw new UnsupportedOperationException(); } ); } } public interface TelemetryProcessor { TelemetryData process(TelemetryData input); }34. 游戏开发中的OOP34.1 组件模式实现游戏对象组件系统public class GameObject { private final MapClass? extends Component, Component components new HashMap(); public T extends Component T getComponent(ClassT type) { return type.cast(components.get(type)); } public void addComponent(Component component) { components.put
阅读完成 · 觉得有帮助？
