常用设计模式

最新推荐文章于 2024-08-24 08:08:52 发布
最新推荐文章于 2024-08-24 08:08:52 发布
阅读量343 收藏
点赞数
分类专栏： Java 文章标签： 设计模式

一、单例模式

主要解决一个全局使用的类频繁地创建与销毁。

1、恶汉模式:
  • 优点：没有加锁，执行效率会提高。
  • 缺点：类加载时就初始化，浪费内存。
public class Singleton{
    private static Singleton1 singleton = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return singleton;
    }
}
2、懒汉模式:
  • 优点：第一次调用才初始化，避免内存浪费。
  • 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
public class Singleton{
    private static Singleton singleton;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
        if(singleton == null) 
            singleton = new Singleton();
        return singleton;
    }
}
3、双锁模式：
public class Singleton{
    private static Singleton singleton;
    private Singleton(){}
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
4、登记模式：
public class Singleton{  
    private static class SingletonHolder{  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton(){}  
    public static final Singleton getInstance(){  
    return SingletonHolder.INSTANCE;  
    }  
}

几种常见单例模式 - CSDN博客 https://blog.csdn.net/qq_33187881/article/details/78760182

二、工厂模式

主要解决接口选择的问题。

1、工厂模式
  • 简单工厂模式是由一个工厂对象根据收到的消息决定要创建哪一个类的对象实例。
  • 优点:在于工厂类中包含了必要的逻辑，根据客户需要的逻辑动态实例化相关的类。
//接口Shape.java
public interface Shape {
    public void draw(); 
}
//接口实现类Circle.java
public class Circle implements Shape {
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}
//接口实现类Rectangle.java
public class Rectangle implements Shape {
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}
//接口实现类Square.java
public class Square implements Shape {
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    } 
}
//创建一个ShapeFactory工厂，生成基于给定信息的实体类的对象。
public class ShapeFactory {
    public Shape getShape(String type) {
        if ("circle".equals(type)) {
            return new Circle();
        } else if ("rectangle".equals(type)) {
            return new Rectangle();
        } else if ("square".equals(type)) {
            return new Square();
        } else {
            return null;
        }
    }   
}
2、工厂方法模式
  • 定义一个创建对象工厂接口，让子类决定实例化哪个类，将实际创建工作推迟到子类当中。
  • 工厂方法模式克服了简单工厂所违背开闭原则的缺点，又保持了封装对象创建过程的优点。
//构建一个ShapeFactory工厂接口
public interface ShapeFactory { 
    public Shape getShape();    
}
//构建一个CircleFactory工厂实现ShapeFactory接口
public class CircleFactory implements ShapeFactory {
    public Shape getShape() {
        return new Circle();
    } 
}
//构建一个RectangleFactory工厂实现ShapeFactory接口
public class RectangleFactory implements ShapeFactory {
    public Shape getShape() {
        return new Rectangle();
    }
}
//构建一个RectangleFactory工厂实现ShapeFactory接口
public class SquareFactory implements ShapeFactory {
    public Shape getShape() {
        return new Square();
    }
}
//工厂方法模式测试类FactoryMethodDemo
public class FactoryMethodDemo {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        circleFactory.getShape().draw();
        ShapeFactory rectangleFactory = new RectangleFactory();
        rectangleFactory.getShape().draw();
        ShapeFactory squareFactory = new SquareFactory();
        squareFactory.getShape().draw();
    }
 }
3、抽象工厂模式
  • 抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。
  • 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
//构建一个Button接口
public interface Button {   
    public void processEvent(); 
}
//构建一个Text接口
public interface Text {
    public void getWholeText(); 
}
//构建一个LinuxButton类实现Button接口
public class LinuxButton implements Button {
    public void processEvent() {
        System.out.println("Inside LinuxButton::processEvent() method.");
    }
}
//构建一个WindowsButton类实现Button接口
public class WindowsButton implements Button {
    public void processEvent() {
        System.out.println("Inside WindowsButton::processEvent() method.");
    }
}
//构建一个LinuxText类实现Text接口
public class LinuxText implements Text {
    public void getWholeText() {
        System.out.println("Inside LinuxText::getWholeText() method.");
    }
}
//构建一个WindowsText类实现Text接口
public class WindowsText implements Text {
    public void getWholeText() {
        System.out.println("Inside WindowsText::getWholeText() method.");
    }
}
//构建一个抽象工厂AbstractFactory 接口
public interface AbstractFactory {  
    public Button createButton();   
    public Text createText(); 
}
//构建一个工厂LinuxFactory类实现AbstractFactory接口
public class LinuxFactory implements AbstractFactory {
    public Button createButton() {
        return new LinuxButton();
    }
    public Text createText() {
        return new LinuxText();
    }
}
//构建一个工厂WindowsFactory类实现AbstractFactory接口
public class WindowsFactory implements AbstractFactory {
    public Button createButton() {
        return new WindowsButton();
    }
    public Text createText() {
        return new WindowsText();
    } 
}
//抽象工厂测试类AbstractFactoryDemo
public class AbstractFactoryDemo {  
    public static void main(String[] args) {
        AbstractFactory linuxFactory = new LinuxFactory();
        linuxFactory.createButton().processEvent();
        linuxFactory.createText().getWholeText();
        AbstractFactory windowsFactory = new WindowsFactory();
        windowsFactory.createButton().processEvent();
        windowsFactory.createText().getWholeText();
    }
}

工厂模式https://blog.csdn.net/wfg18801733667/article/details/60954744

三、消费者生产者模式

主要解决多线程的问题。

1、wait() / notify()方法
@Data
public class Storage{
    private final int MAX_SIZE = 100;
    private LinkedList<Object> list = new LinkedList<Object>();
    public void produce(String producer) throws InterruptedException {
        synchronized (list){
            while (list.size() == MAX_SIZE){
                list.wait();
            }
            list.add(new Object());
            list.notifyAll();
        }
    }
    public void consume(String consumer) throws InterruptedException {
        synchronized (list){
            while (list.size()==0){
                list.wait();
            }
            list.remove();
            list.notifyAll();
        }
    }
}
2、await() / signal()方法
@Data
public class Storage {
    private final int MAX_SIZE = 100;
    private LinkedList<Object> list = new LinkedList<Object>();
    private final Lock lock = new ReentrantLock();
    private final Condition full = lock.newCondition();
    private final Condition empty = lock.newCondition();
    public void produce(String producer) throws InterruptedException {
        lock.lock();
        while (list.size() == MAX_SIZE) {
            full.await();
        }
        list.add(new Object());
        empty.signalAll();
        lock.unlock();
    }
    public void consume(String consumer) throws InterruptedException {
        lock.lock();
        while (list.size() == 0) {
            empty.await();
        }
        list.remove();
        full.signalAll();
        lock.unlock();
    }
}
3、put() / take()方法
@Data
public class Storage {
    private final int MAX_SIZE = 100;
    private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(100);
    public void produce(String producer) throws InterruptedException {
        if (list.size() == MAX_SIZE) {
        }
        list.put(new Object());
 }
    public void consume(String consumer) throws InterruptedException {
        if (list.size() == 0) {
        }
        list.take();
    }
}
4、Tset方法
public class Test {
    public static void main(String[] args) {
        Storage storage = new Storage();
        for (int i = 1; i < 6; i++) {
            int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        storage.produce(String.format("生成者%d:", finalI));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        for (int j = 1; j < 4; j++) {
            int finalJ = j;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        storage.consume(String.format("消费者%d:", finalJ));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}
5、PipedIO
public class PipedIO {
    private PipedInputStream pis = new PipedInputStream();
    private PipedOutputStream pos = new PipedOutputStream();
    public static void main(String[] args) throws IOException {
        PipedIO pipedIO = new PipedIO();
        pipedIO.initThread();
    }
    private void initThread() throws IOException {
        pos.connect(pis);
        Thread input = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        pos.write(new Date().toString().getBytes());
                        Thread.sleep(1000);
                    }
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread output = new Thread(new Runnable() {
            @Override
            public void run() {
                byte[] temp = new byte[1024];
                try {
                    int len;
                    while ((len = pis.read(temp)) != -1) {
                        Thread.sleep(1000);
                    }
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        input.start();
        output.start();
    }
}

生产者消费者模式-Java实现https://www.cnblogs.com/chentingk/p/6497107.html

四、代理模式

可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.

1、静态代理:
//接口
public interface UserDao {
    void save();
}
//接口实现类
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("保存数据");
    }
}
//代理对象
public class UserDaoProxy implements UserDao {
    private UserDao target;
    public UserDaoProxy(UserDao target){
        this.target=target;
    }
    public void save() {
        System.out.println("开始事务");
        target.save();
        System.out.println("提交事务");
    }
}
//测试
public class Tset {
    public static void main(String[] args) {
        UserDaoImpl target = new UserDaoImpl();
        UserDaoProxy proxy = new UserDaoProxy(target);
        proxy.save();
    }
}
2、动态代理:
//代理工厂模式
public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                 @Override
                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("开始事务2");
                    Object returnValue = method.invoke(target, args);
                    System.out.println("提交事务2");
                    return returnValue;
                 }
             }
        );
    }
}
//测试方法
public class Test {
    public static void main(String[] args) {
        UserDaoImpl target = new UserDao();
        System.out.println(target.getClass());
        UserDaoImpl proxy = (UserDaoImpl) new ProxyFactory(target).getProxyInstance();
        System.out.println(proxy.getClass());
        proxy.save();
    }
}
3、CGLIB代理:
//目标对象,没有实现任何接口
public class UserDao {
    public void save() {
        System.out.println("保存数据");
    }
}
//Cglib子类代理工厂
public class ProxyFactory implements MethodInterceptor{
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    public Object getProxyInstance(){
        Enhancer en = new Enhancer();
        en.setSuperclass(target.getClass());
        en.setCallback(this);
        return en.create();
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");
        Object returnValue = method.invoke(target, args);
        System.out.println("提交事务...");
        return returnValue;
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        IUserDao target = new UserDao();
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();
        proxy.save();
    }
}

Java的三种代理模式 - 岑宇 - 博客园 https://www.cnblogs.com/cenyu/p/6289209.html

q_yun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中几个常用设计模式
12-22
1.单例模式（有的书上说叫单态模式其实都一样） 　该模式主要目的是使内存中保持1个对象。看下面的例子： 　package org.sp.singleton; 　//方法一 　public class Singleton { 　//将自身的实例对象设置为一个...
Android 常用设计模式
10-18
本文将深入探讨Android开发者常用的三种设计模式：单例模式、工厂模式和构建器模式。 首先，单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。在Android应用中，单例常用于管理共享...
生产者消费者模式
as57147的博客
09-25 241
在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过消息队列（缓冲区）来进行通讯，所以生产者生产完数据之后不用等待消费者处理，...
工厂模式
最佳 Java 编程
05-31 108
工厂模式是一种创新的设计模式，其目的是提供一个用于创建相关或相关对象族的接口，而无需指定其具体类。 创建逻辑封装在工厂内，该工厂提供创建逻辑的方法或将对象的创建委托给子类。 客户端不知道接口或类的不同实现。 客户端只需要知道用于获取接口实现之一的实例的工厂即可。 客户端与对象的创建是分离的。 通常，工厂模式以单例或静态类的形式实现，因为只需要一个工厂实例。 这样集中了对象的创建。 CD...
设计模式之工厂模式
Shine_OfSun的博客
11-05 156
设计模式之工厂模式 简介 工厂模式：工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂模式使一个类的实例化延迟到其子类。 这相当于是把原本会因为业务代码而庞大的简单工厂类，拆分成了一个个的工厂类，这样代码就不会都耦合在同一个类里了。 也就是工厂模式的优点。 ​ 工厂模式还分普通工厂模式和抽象工厂模式，这里讲的是抽象工厂模式。 工厂模式两个点是工厂和产品，在面对复杂的产品时需要不同的...
Golang常用设计模式
阿璐4r的博客
06-22 2417
单例模式 // 使用once.Do可以确保 ins 实例全局只被创建一次，once.Do 函数还可以确保当同时有多个创建动作时， // 只有一个创建动作在被执行。 type singleton03 struct { } var ins03 *singleton03 var once sync.Once func GetInsOr03() *singleton03 { once.Do(func() { ins03 = &singleton03{} }) return ins03 } 工
一文讲完Java常用设计模式（全23种）
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-10 2万+
设计模式是软件开发中非常有用的工具，可以提高代码的可重用性和可维护性，同时也可以提高开发人员的工作效率。 设计模式有几种类型，包括创建型、结构型和行为型模式。 创建型模式用于以灵活和高效的方式创建对象。包括Singleton模式、工厂模式和抽象工厂模式等。 结构型模式用于组合类和对象以形成更大的结构。包括适配器模式、桥接模式和装饰器模式等。 行为型模式用于处理类或对象之间的通信和控制流。包括观察者模式、策略模式和模板方法模式。
Go语言常用设计模式
kuokay的博客
05-05 2546
前言 在软件开发中，经常会遇到各种各样的编码场景，这些场景往往重复发生，因此具有典型性。针对这些典型场景，我们可以自己编码解决，也可以采取更为省时省力的方式：直接采用设计模式。 设计模式是啥呢？简单来说，就是将软件开发中需要重复性解决的编码场景，按最佳实践的方式抽象成一个模型，模型描述的解决方法就是设计模式。使用设计模式，可以使代码更易于理解，保证代码的重用性和可靠性。 在软件领域，GoF（四人帮，全拼 Gang of Four）首次系统化提出了 3 大类、共 25 种可复用的经典设计方案，来解决常见的软件
Unity 常用设计模式
sinat_34014668的博客
02-05 3942
设计模式
C++几种常用设计模式
qq_46423987的博客
09-05 1万+
设计模式
C++常用设计模式
qq_41058438的博客
01-19 2374
设计模式本质是开发人员经验的总结，目的是为提升软件的高内聚、低耦合特性。它无法像算法解决具体的实际问题，只是一种优化代码的推荐方式。根据设计模式的参考书，目前有23种设计模式，分为创建型、结构型和行为型。以下介绍最常用的2种设计模式：单例模式和工厂模式。
Java常用设计模式介绍
06-25
blic void setMessage(String message) { this.message = ...在实际开发中，可以根据场景选择合适的设计模式，如使用单例模式管理共享资源，工厂模式创建对象，装饰器模式动态增加功能，观察者模式实现事件监听等。
ava常用设计模式-原型模式
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
java常用设计模式-工厂模式
08-26
Java常用设计模式-工厂模式 工厂模式（Factory Pattern）是一种常用的设计模式，它通过一个工厂类来实现对象的创建，而无需直接暴露对象的创建逻辑给客户端。这种模式可以使客户端代码与具体的产品类解耦，提高代码...
设计模式（三）
最新发布
dingyahui的博客
08-24 945
Circle 是具体的实现类，它实现了抽象类的方法，并使用实现类接口来完成绘制工作，测试函数中创建了两个具体的实现类对象和两个使用这些实现类的圆形对象，并调用它们的绘制方法。优点：使用代理模式创建代表对象，让代表对象来控制某对象的访问，被代理的对象可以是远程的对象，创建开销大的对象或需要安全控制的对象。：真实的角色实现实际的业务逻辑，不用关心其它非本职的事务，通过后期的代理完成附加的事务，附带的结果就是编程简洁清晰。：享元模式的优点在于大幅减少内存中对象的数量，降低程序内存的占用，提高性能。
设计模式六大原则：迪米特法则详细说明和案例示范
weixin_39996520的博客
08-20 592
只与直接的朋友通信：一个对象应当只与那些与它关系密切的对象直接通信，而不应该依赖于太多的其他对象。避免过度依赖：对象之间的依赖关系应该尽量减少，避免形成复杂的依赖链。在实际开发中，这意味着我们应该设计简洁的接口，避免对象过度依赖于其他对象的内部细节，从而减少对象之间的耦合度。迪米特法则强调对象之间的交互应尽可能少，避免产生复杂的依赖关系。通过引入中介类或封装层，可以将依赖关系控制在合理的范围内，减少类之间的耦合度，提高系统的可维护性和可扩展性。
设计模式六大原则之一的接口隔离原则
jun778895的博客
08-20 1275
接口隔离原则的定义是：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。换句话说，接口的设计应当尽量细化，每个接口只包含客户端需要的方法，而不是将所有可能的方法都放在一个接口中。接口隔离原则是面向对象设计中的一个重要原则，它强调了接口的设计应当尽量保持简洁和专一。通过细化接口、减少依赖和提高复用性等方式，接口隔离原则有助于降低系统的复杂性、提高系统的灵活性和可维护性。然而，在应用接口隔离原则时，也需要注意避免过度细化接口和增加系统的复杂性。
设计模式-visit模式-在语法树的实践
csdn问鼎
08-21 442
visit模式在解析语法树场景下的实践
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值