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();
            }
        }
    }
相关推荐
lifallen5 分钟前
Paimon 原子提交实现
java·大数据·数据结构·数据库·后端·算法
TDengine (老段)34 分钟前
TDengine 数据库建模最佳实践
大数据·数据库·物联网·时序数据库·tdengine·涛思数据
Elastic 中国社区官方博客44 分钟前
Elasticsearch 字符串包含子字符串:高级查询技巧
大数据·数据库·elasticsearch·搜索引擎·全文检索·lucene
舒一笑1 小时前
PandaCoder重大产品更新-引入Jenkinsfile文件支持
后端·程序员·intellij idea
Gauss松鼠会1 小时前
GaussDB应用场景全景解析:从金融核心到物联网的分布式数据库实践
数据库·分布式·物联网·金融·database·gaussdb
PetterHillWater1 小时前
AI编程之CodeBuddy的小试
后端·aigc
天河归来2 小时前
springboot框架redis开启管道批量写入数据
java·spring boot·redis
合作小小程序员小小店2 小时前
web网页,在线%食谱推荐系统%分析系统demo,基于vscode,uniapp,vue,java,jdk,springboot,mysql数据库
vue.js·spring boot·vscode·spring·uni-app
守城小轩2 小时前
Chromium 136 编译指南 - Android 篇:开发工具安装(三)
android·数据库·redis
codervibe2 小时前
如何用 Spring Security 构建无状态权限控制系统(含角色菜单控制)
java·后端