Java中的主要设计模式

Java中的设计模式是一套被广泛认可的解决特定问题的解决方案。它们分为三大类:创建型模式、结构型模式和行为型模式。以下是一些常见的设计模式及其简要介绍和代码实现示例:

创建型模式

  1. 单例模式(Singleton): 确保一个类只有一个实例,并提供一个全局访问点。

    java 复制代码
    public class Singleton {
        private static Singleton instance;
        private Singleton() {}
    
        public static synchronized Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
  2. 工厂方法模式(Factory Method): 定义一个用于创建对象的接口,让子类决定实例化哪一个类。

    java 复制代码
    interface Product {
        void use();
    }
    
    class ConcreteProduct implements Product {
        public void use() {
            System.out.println("Using ConcreteProduct");
        }
    }
    
    abstract class Creator {
        abstract Product factoryMethod();
    }
    
    class ConcreteCreator extends Creator {
        public Product factoryMethod() {
            return new ConcreteProduct();
        }
    }
  3. 建造者模式(Builder): 用于创建一个复杂对象,同时允许用户只通过指定复杂对象的类型和内容就能构建它们。

    java 复制代码
    class Product {
        private String part1;
        private String part2;
    
        public static class Builder {
            private String part1;
            private String part2;
    
            public Builder setPart1(String part1) {
                this.part1 = part1;
                return this;
            }
    
            public Builder setPart2(String part2) {
                this.part2 = part2;
                return this;
            }
    
            public Product build() {
                return new Product(this.part1, this.part2);
            }
        }
    
        private Product(String part1, String part2) {
            this.part1 = part1;
            this.part2 = part2;
        }
    }

结构型模式

  1. 适配器模式(Adapter): 允许对象间的接口不兼容问题通过一个"适配器"来解决。

    java 复制代码
    interface Target {
        void request();
    }
    
    class Adaptee {
        public void specificRequest() {
            System.out.println("Specific Request");
        }
    }
    
    class Adapter implements Target {
        private Adaptee adaptee;
    
        public Adapter(Adaptee adaptee) {
            this.adaptee = adaptee;
        }
    
        public void request() {
            adaptee.specificRequest();
        }
    }
  2. 装饰器模式(Decorator): 动态地给一个对象添加额外的职责。

    java 复制代码
    interface Component {
        void operate();
    }
    
    class ConcreteComponent implements Component {
        public void operate() {
            System.out.println("ConcreteComponent");
        }
    }
    
    abstract class Decorator implements Component {
        protected Component component;
    
        public Decorator(Component component) {
            this.component = component;
        }
    
        public void operate() {
            component.operate();
        }
    }
    
    class ConcreteDecoratorA extends Decorator {
        public ConcreteDecoratorA(Component component) {
            super(component);
        }
    
        public void operate() {
            super.operate();
            // Add additional behavior
            System.out.println("ConcreteDecoratorA");
        }
    }

行为型模式

  1. 策略模式(Strategy): 定义一系列算法,把它们一个个封装起来,并使它们可互换。

    java 复制代码
    interface Strategy {
        void execute();
    }
    
    class ConcreteStrategyA implements Strategy {
        public void execute() {
            System.out.println("Strategy A");
        }
    }
    
    class Context {
        private Strategy strategy;
    
        public Context(Strategy strategy) {
            this.strategy = strategy;
        }
    
        public void executeStrategy() {
            strategy.execute();
        }
    }
  2. 观察者模式(Observer): 对象间的一对多依赖关系,当一个对象改变状态时,所有依赖于它的对象都会得到通知并自动更新。

    java 复制代码
    interface Observer {
        void update();
    }
    
    class ConcreteObserver implements Observer {
        public void update() {
            System.out.println("Observer updated");
        }
    }
    
    class Subject {
        private List<Observer> observers = new ArrayList<>();
    
        public void attach(Observer observer) {
            observers.add(observer);
        }
    
        public void notifyObservers() {
            for (Observer observer : observers) {
                observer.update();
            }
        }
    }
相关推荐
段帅龙呀29 分钟前
Redis构建缓存服务器
服务器·redis·缓存
ai小鬼头2 小时前
Ollama+OpenWeb最新版0.42+0.3.35一键安装教程,轻松搞定AI模型部署
后端·架构·github
互联网搬砖老肖3 小时前
运维打铁: MongoDB 数据库集群搭建与管理
运维·数据库·mongodb
萧曵 丶3 小时前
Rust 所有权系统:深入浅出指南
开发语言·后端·rust
netyeaxi3 小时前
Java:使用spring-boot + mybatis如何打印SQL日志?
java·spring·mybatis
典学长编程3 小时前
数据库Oracle从入门到精通!第四天(并发、锁、视图)
数据库·oracle
小七mod4 小时前
【MyBatis】MyBatis与Spring和Spring Boot整合原理
spring boot·spring·mybatis
老任与码4 小时前
Spring AI Alibaba(1)——基本使用
java·人工智能·后端·springaialibaba
积跬步,慕至千里4 小时前
clickhouse数据库表和doris数据库表迁移starrocks数据库时建表注意事项总结
数据库·clickhouse
华子w9089258594 小时前
基于 SpringBoot+VueJS 的农产品研究报告管理系统设计与实现
vue.js·spring boot·后端