设计模式总结

最新推荐文章于 2024-07-15 22:27:18 发布
最新推荐文章于 2024-07-15 22:27:18 发布
阅读量98 收藏
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36682077/article/details/115825520
版权

单例模式 Singleton

懒汉模式 lazy loading

有多种，用的不多，不推荐使用

饿汉模式

推荐使用，简单粗暴，没那么复杂，项目中用到最多的模式也是这个

public static T INSTANCE = new T();

private T (){};

最完美的模式 enum模式

effective java 作者推荐的模式，保证单例，且不会被反序列化实例出来（即不会被反射创建出来）

public enum T{
	INSTANCE;
}

策略模式 Strategy

最典型的例子是jdk的Comparator比较器。本质就是传个function进去。

public BiFunction<Integer,Integer,Integer> calculator;

public BiFunction<Integer,Integer,Integer> addiotnCalculator = (p0,p1)->p0+p1;
public BiFunction<Integer, Integer, Integer> multiplicationCalculator = (p0, p1) -> p0 * p1;

public int calculator (int param0,int param1){
	calculator = addiotnCalculator;
	//calculator = multiplicationCalculator;
	return calculator.apply(param0,param1);
}

工厂模式 Factory 以及 抽象工厂模式 AbstractFactory

工厂：实例不由自己去创建，而交给工厂创建，项目代码
抽象工厂：## 标题创建工厂的工厂

public class AbstractFactoryPattern {
    private static final Data DB_DMG = DataFactory.newFactory("Db").newDataInstance(new Object());
    private static final Data MC_DMG = DataFactory.newFactory("Redis").newDataInstance(new Object());

}

abstract class DataFactory{
    abstract Data newDataInstance(Object param);
    static DataFactory newFactory(String factoryName){
        if(Objects.equals(factoryName,"Db")){
            return new DbDataFactory();
        }
        if(Objects.equals(factoryName,"Redis")){
            return new RedisDataFactory();
        }
        DataFactory defaultFactory = null;
        return defaultFactory;
    }
}

class DbDataFactory extends DataFactory{
    Data newDataInstance(Object param){
        int tableId = 0;
        int dataId = 1;
        return new DbData(tableId,dataId);
    }
}

class RedisDataFactory extends DataFactory{
    Data newDataInstance(Object param){
        String reidsKey = "";
        return new RedisData(reidsKey);
    }
}

abstract class Data{
    abstract int get(int userId);
    abstract void set(int userId);
}

class DbData extends Data{
    int tableId;
    int dataId;

    public DbData(int tableId, int dataId) {
        this.tableId = tableId;
        this.dataId = dataId;
    }

    @Override
    int get(int userId) {
        /*mysql操作*/
        return 0;
    }

    @Override
    void set(int userId) {
        /*mysql操作*/
    }
}

class RedisData extends Data{
    String reidsKey;

    public RedisData(String reidsKey) {
        this.reidsKey = reidsKey;
    }

    @Override
    int get(int userId) {
        /*redis操作*/
        return 0;
    }

    @Override
    void set(int userId) {
        /*redis操作*/
    }
}

门面模式 Facade和Meidator

简单的说就是把所有的相关的操作全部聚合到一个类中

class Person(){
	int id;
	Clothes clothes;
	Pet pet;
	...
}

class PersonUtil{
	ClothesManager clothesManager;
	PetManager petManager;
	...

	/*通过id拿到clothes*/
	Clothes getClothes(int id){
		/*clothesManager里面有自己的业务逻辑*/
		clothesManager.get(id);
	}

	/*通过id拿到pet*/
	Pet getPet(int id){
		/*petManager里面有自己的业务逻辑*/
		petManager.get(id);
	}

	...
}

装饰器模式 Decorator

这个平时没怎么用到，理解的还不是很深，简单的用代码实现一下，方便后面自己理解

interface Decorator{
	void decorate();
}

class ADecorator implements  Decorator{
	void decorate(){
		
	}
}

class BDecorator implements  Decorator{
	Decorator decorator;

	public BDecorator(Decorator decorator){
		this.decorator = decorator;
	}
	
	void decorate(){
		/*自己需要的业务逻辑*/
		decorator.decorate();
	}
}

责任链 Chain Of Responsibility

非常重要，也非常实用。简单的来说就是用一个for循环
最典型的例子,filter的实现。
项目中的代码，判断技能是否命中：

private void executeSingle() {
		beforeCast(param);
		// 计算命中伤害前如果死亡则技能无效
		if (hasEffect(param)) {
			//技能命中业务代码
		} else {
			//技能没命中业务代码
		}
		endCast(param);
	}

boolean hasEffect(Param param){
	/*这里采用的就是责任链模式，若有个buff是必定闪避，则只要在改buff生成的
	status里面将hasEffect重新为return false,就可以实现该逻辑*/
	List<Status> statusList = param.getAllStatus();
	for(Status s:statusList){
		if(!s.hasEffect()){
			return false;
		}
	}
	//其他的判断
	return true;
}

观察者模式 Observer

同样非常重要，也非常实用。简单的来说就是将function存在一个list里面，然后触发某个时间可以依次执行list里面的函数。
resoucre,信息源，抛出event的地方，就是在哪里触发的
event,事件本身，可以理解为function的参数
listener,监听者，事件触发后的执行，可以理解为function本身
典型例子为键盘和鼠标的响应事件
在项目之中的应用

class EventDispatcher{
	private static HashMap<Class, List<ListenerWrap>> map;

	static{
		//这里将监听者注册到map里面，这里只是方便演示，项目中用的是反射将所有监听事件注册进来
		AListen aListen = new AListen();
		Method[] methods = aListen.getClass().getMethods();
        for (Method method:methods){
            EventInject ei = m.getAnnotation(EventInject.class);
			if(ei != null){
				map.get(ei.value).add(new ListenerWrap(method,aListen));
			}
        }
		
	}

	public static boolean dispatch(Event event) {
		List<ListenerWrap> listenerList = map.get(event.class);
		for(ListenerWrap l:listenerList){
			l.invoke(event);
		}
	}
}

class ListenerWrap(){
	public Method method;
	public Object inv;

	public 	ListenerWrap(Method method,Object inv){
		this.method = method;
		this.inv = inv;
	}

	invoke(Event event){
		method.invoke(inv,event);
	};
}

class Resoucre{
	void A(){
		//其他代码
		EventDispatcher.dispatch(new XEvent(Object param))
	}
}

class Event{}

class XEvent extends Event{
	Object param;

	public XEvent(Object param){
		this.param = param;
	}
}

class AListen{
	@EventInject(XEvent.class)
	public void listen(XEvent event){
		//业务逻辑
	}
}

组合模式 Composite

一个树状结构，分为叶子节点和非叶子节点
典型例子为文件系统

public class Composite {
    public static void main(String[] args) {
        Directory root = new Directory("root");
        File f1 = new File("file1");
        File f2 = new File("file1");
        Directory d1 = new Directory("directory1");
        Directory d2 = new Directory("directory2");
        root.addNode(f1);
        root.addNode(f2);
        root.addNode(d1);
        root.addNode(d2);
        File f11 = new File("file11");
        File f12 = new File("file12");
        d1.addNode(f11);
        d1.addNode(f12);
        File f21 = new File("file21");
        File f22 = new File("file22");
        d2.addNode(f21);
        d2.addNode(f22);
        print(root, 0);
    }

    private static void print(Node root, int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("--");
        }
        System.out.println(root.name);
        if (root instanceof Directory) {
            Directory d = (Directory) root;
            for (Node n : d.nodes) {
                print(n, depth + 1);
            }
        }
    }
}

abstract class Node {
    String name;

    public Node(String name) {
        this.name = name;
    }
}

class File extends Node {
    public File(String name) {
        super(name);
    }
}

class Directory extends Node {
    List<Node> nodes = new ArrayList<>();

    public Directory(String name) {
        super(name);
    }

    void addNode(Node node) {
        nodes.add(node);
    }
}

享元模式 flyweight

池化技术，创建一个池回收对象，减少对象的创建和销毁
String,Integer，线程池，连接池都属于该模式

备忘录模式 Memento

数据持久化
java中采用serializable将对象序列化储存，利用transient关键字可以将字段不序列化

public class Memento {
    MementoSerializable m = new MementoSerializable();

    public static void main(String[] args) throws Exception{
        Memento memento = new Memento();
        memento.save();
        MementoSerializable nm = memento.load();
        /*MementoSerializable{id=0, name='dream', age=0}*/
        System.out.println(nm.toString());
    }

    private void save() throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\MementoSerializable.data"));
        oos.writeObject(m);
        oos.flush();
        oos.close();
    }

    private MementoSerializable load() throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\MementoSerializable.data"));
        MementoSerializable nm = (MementoSerializable)ois.readObject();
        ois.close();
        return nm;
    }
}

class MementoSerializable implements Serializable {
    int id = 0;
    String name = "dream";
    transient int age = 22;

    @Override
    public String toString() {
        return "MementoSerializable{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

原型模式 Prototype

对象的拷贝
java中实现Cloneable将对象浅拷贝，深拷贝则需要将对象的属性也加上Cloneable。另外String类型是属于深拷贝的，具体实现是String的池化技术和final关键字。

模板模式 Template

项目常用，比如说一个命令的接收，我们只需要关注doSome的具体业务实现，而不用关注全部的流程实现

public abstract class Father{
	public void receive(User u,Param param){
		Response re = new Response();
		doSome(u,param,re);
		sendResponse(u,re);
	}

	protected abstract void doSome(User u,Param param,Response re);
}

public class Child{
	@Override
	protected void doSome(User u,Param param,Response re){
		//dosomething
	}
}

代理模式 proxy

静态代理

与 decorate几乎一样

动态代理

使用Proxy.Proxy.newProxyInstance()方法

public class Main3 {
    public static void main(String[] args) {
        Movable c = (Movable)Proxy.newProxyInstance(Car.class.getClassLoader(), new Class[]{Movable.class},new CarInvocationHandler(new Car()));
        c.move();
    }
}

class CarInvocationHandler implements InvocationHandler{
    Movable m;

    public CarInvocationHandler(Movable m) {
        this.m = m;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(m,args);
        System.out.println("end");
        return result;
    }
}

class Car implements Movable{

    @Override
    public void move() {
        System.out.println("car move");
    }
}

interface Movable{
    void move();
}

迭代器模式 Iterator

典型例子：List 的next()和hasNext()方法

访问者模式 visitor

适合结构固定的

建造者模式 Builder

实例时可以选择需要的参数进行实例，且不用写过多的构造方法

public class Main4 {
    int a;
    int b;
    int c;
    int d;
    int g;

    public static void main(String[] args) {
        Main4 m = new Buider().
                setA(1).
//                setB(2).
                setC(3).
//                setD(4).
                build();
    }
}

class Buider{
    Main4 m;

    Buider(){
        m = new Main4();
    }

    public Buider setA(int a){
        m.a = a;
        return this;
    }

    public Buider setB(int b){
        m.b = b;
        return this;
    }

    public Buider setC(int c){
        m.c = c;
        return this;
    }

    public Buider setD(int d){
        m.d = d;
        return this;
    }

    public Main4 build() {
        return m;
    }
}

适配器模式 Adapter

将接口类型不一致的两个类通过第三个类关联起来
典型例子 callable和Thread

public static void main(String[] args) throws Exception{
        Callable<Integer> c = ()->1;
        /*FutureTask充当适配器角色*/
        FutureTask<Integer> f = new FutureTask(c);
        Thread t = new Thread(f);
        t.start();
        System.out.println(f.get());
    }

命令行模式 Command

撤销（undo），回滚（rollback）等操作

总结

设计模式的本质就是多态，所以不用太过于纠结。做好四大性能和遵循六大原则就行
四大性能

  1. 可维护性 maintainability
  2. 可复用性 reusability
  3. 可扩展性 scalability/extensibility
  4. 灵活性 flexibility/mobility/adaptability

六大原则

  1. 单一职责原则 single responsibility principle
  2. 开闭原则 open-closed principle
  3. 依赖倒置原则 dependency inversion principle
  4. 接口隔离原则 interface segregation principle
  5. 里氏替换原则 Liskov Substitution principle
  6. 高内聚 低耦合原则 minimize coupling
笨笨鸟啊啊啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式-
Pbp__的博客
01-06 844
设计模式
Datafactory的使用
啊啊啊啊2
09-05 1114
1.解压下面文件2.解压完之后如下图3.点击箭头方向点击安装4.这个时候你还需要打开下图这个软件5.打开后如下图第一个框填用户名 例：fang686第二个框是生成的秘钥暂时不管第三个框是选择类型，这里我们选择Datafactory然后点击创建6.点击创建之后会出现秘钥如图7.选择你安装好的软件，点击打开，点击修改，选择datafactory，会弹出用户名，这里的用户名就是刚刚设置的用户名，点击ok...
设计模式回顾-factory模式
无名程序员
03-11 165
设计模式回顾-factory模式 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 介绍 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟...
设计模式总结.pdf
07-01
自己整理的关于设计模式的总结，有全部的设计模式介绍，以及常用的设计模式总结记忆，适合程序员面试前突击以及日常学习使用
Spring 设计模式总结1
08-04
Spring设计模式总结 在软件开发中，设计模式是解决常见问题的经验总结，它们为程序员提供了在特定场景下设计高效、可维护代码的蓝图。在Spring框架中，许多设计模式被广泛应用，以提升系统的灵活性和可扩展性。以下...
所有设计模式总结
06-14
上面总结用的是思维导图，（注意：需要用xmind软件打开）设计模式总结，分为三个大类型：创建型，结构型，行为型。总结了它们适用于解决什么问题，用了后所要达到的意图。
java学习----递归
qq_56798493的博客
07-13 162
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 787
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 627
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 868
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 995
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java 线程池详解
qq_41591215的博客
07-13 940
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 141
【JAVA】相关程序组件
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 590
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 495
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 693
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 498
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
从零手写实现 nginx-27-return 指令
07-14 661
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat。
设计模式总结：建型与结构型模式详解
"这篇文章除了标题'设计模式总结(1)'，还涉及了设计模式的分类，包括创建型、结构型和行为型设计模式的概述。文章着重讲解了创建型模式中的SingletonPattern（单例模式），并对其意图和适用性进行了详细描述，同时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值