设计模式总结

已于 2024-06-10 19:22:13 修改
阅读量2.1k 收藏 46
点赞数 80
分类专栏： C++ 文章标签： 设计模式
于 2024-06-10 00:10:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmh_1234567/article/details/139533754
版权
设计模式是前辈们对代码开发经验的总结，是解决特定问题的⼀系列套路。它不是语法规定，⽽是⼀套来提⾼代码可复⽤性、可维护性、可读性、稳健性以及安全性的解决⽅案。
六⼤原则
单⼀职责原则
类的职责应该单⼀，⼀个⽅法只做⼀件事，职责划分清晰了
开闭原则
对扩展开放，对修改封闭
对软件实体的改动，最好⽤扩展⽽⾮修改的⽅式。
⾥⽒替换原则
通俗点讲，就是只要⽗类能出现的地⽅，⼦类就可以出现，⽽且替换为⼦类也不会产⽣任何错误或异常。
在继承类时，务必重写⽗类中所有的⽅法，尤其需要注意⽗类的protected⽅法，⼦类尽量不要暴露⾃⼰的public⽅法供外界调⽤。
依赖倒置原则
⾼层模块不应该依赖低层模块，两者都应该依赖其抽象. 不可分割的原⼦逻辑就是低层模式，原⼦逻辑组装成的就是⾼层模块。
模块间依赖通过抽象（接⼝）发⽣，具体类之间不直接依赖
迪⽶特法则【最少知道法则】
尽量减少对象之间的交互，从⽽减⼩类之间的耦合。⼀个对象应该对其他对象有最少的了解。
接⼝隔离原则
客⼾端不应该依赖它不需要的接⼝，类间的依赖关系应该建⽴在最⼩的接⼝上
使⽤建议：接⼝设计尽量精简单⼀，但是不要对外暴露没有实际意义的接⼝。
⽤例：修改密码，不应该提供修改⽤⼾信息接⼝，⽽就是单⼀的最⼩修改密码接⼝，更不要暴露数据库操作

从整体上来理解六⼤设计原则，可以简要的概括为⼀句话，⽤抽象构建框架，⽤实现扩展细节，具体  到每⼀条设计原则，则对应⼀条注意事项：

单⼀职责原则告诉我们实现类要职责单⼀；
⾥⽒替换原则告诉我们不要破坏继承体系；
依赖倒置原则告诉我们要⾯向接⼝编程；
接⼝隔离原则告诉我们在设计接⼝的时候要精简单⼀；
迪⽶特法则告诉我们要降低耦合；
开闭原则是总纲，告诉我们要对扩展开放，对修改关闭。
单例模式

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个
访问它的全局访问点，该实例被所有程序模块共享。
比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
单例模式有两种实现模式：饿汉模式，懒汉模式


饿汉模式


就是说不管你将来用不用，程序启动时就会创建⼀个唯⼀的实例对象。 因为单例对象已经确定， 所以⽐较适⽤于多线程环境中， 多线程获取单例对象不需要加锁， 可以有效的避免资源竞争， 提⾼性能。

#include <iostream>
using namespace std;
 
class Singleton {
private:
    static Singleton _eton;
    int _data;
private:
    Singleton() :_data(99) {
        cout << "单例对象构造" << endl;
    }
    ~Singleton() {}
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static Singleton& getInstance()
    {
        return _eton;
    }
    int getData() {
        return _data;
    }
};
Singleton Singleton::_eton;
 
 
int main()
{
    //cout << Singleton::getInstance().getData() << endl;
    return 0;
}

结果演示
注释前：

ce74fbe35c21468a8ac2b1750b3617b1.png

注释后：

bfde43b2867b405b913f0a3551347b4a.png

由此可见，在main函数启动后，就会自动构造单例对象，即便是没有调用该单例对象。

懒汉模式


第⼀次使⽤要使⽤单例对象的时候创建实例对象。如果单例对象构造特别耗时或者耗费资源(加载插件、加载⽹络资源等)， 可以选择懒汉模式， 在第⼀次使⽤的时候才创建对象。

class B
{
public:
	static B* GetInstance()
	{
		if (_inst == nullptr)
		{
			_inst = new B;
		}
 
		return _inst;
	}
 
	static void DelInstance()
	{
		if (_inst)
		{
			delete _inst;
			_inst = nullptr;
		}
	}
 
private:
	B()
	{}
 
	~B()
	{
		cout << "数据写到文件" << endl;
	}
 
	B(const B& aa) = delete;
	B& operator=(const B& aa) = delete;
 
	static B* _inst;
 
	class gc
	{
	public:
		~gc()
		{
			DelInstance();
		}
	};
 
	static gc _gc;
};
 
B* B::_inst = nullptr;
B::gc B::_gc;

下面再介绍一种《Effective C++》⼀书作者 Scott Meyers 提出的⼀种更加优雅简便的单例模式 Meyers' Singleton in C++。

C++11 Static local variables 特性以确保C++11起，静态变量将能够在满⾜ thread-safe 的前提下唯⼀地被构造和析构。

#include <iostream>
using namespace std;
 
class Singleton {
private:
    int _data;
private:
    Singleton() :_data(99) {
        cout << "单例对象构造" << endl;
    }
    ~Singleton() {}
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    static Singleton& getInstance()
    {
        static Singleton _eton;
        return _eton;
    }
    int getData() {
        return _data;
    }
};
 
 
int main()
{
    cout << Singleton::getInstance().getData() << endl;
    return 0;
}

结果演示

没注释：

ca332604d967421ea05b51f59d693c59.png

注释后：

4dd720dc0e0549708cd62362b066de56.png

由此可见，懒汉模式中，只有第一次创建对象时，才会构造单例对象。

工厂模式
⼯⼚模式是⼀种创建型设计模式， 它提供了⼀种创建对象的最佳⽅式。在⼯⼚模式中，我们创建对象时不会对上层暴露创建逻辑，⽽是通过使⽤⼀个共同结构来指向新创建的对象，以此实现创建-使⽤的分离。
⼯⼚模式可以分为:简单工厂模式，工厂方法模式，抽象工厂模式。
简单工厂模式
简单⼯⼚模式: 简单⼯⼚模式实现由⼀个⼯⼚对象通过类型决定创建出来指定产品类的实例。假设
有个⼯⼚能⽣产出⽔果，当客⼾需要产品的时候明确告知⼯⼚⽣产哪类⽔果，⼯⼚需要接收⽤⼾提
供的类别信息，当新增产品的时候，⼯⼚内部去添加新产品的⽣产⽅式。
简单⼯⼚模式：通过参数控制可以⽣产任何产品
 优点：简单粗暴，直观易懂。使⽤⼀个⼯⼚⽣产同⼀等级结构下的任意产品
 缺点：
 1. 所有东西⽣产在⼀起，产品太多会导致代码量庞⼤
 2. 开闭原则遵循(开放拓展，关闭修改)的不是太好，要新增产品就必须修改⼯⼚⽅法。 
#include <iostream>
#include <string>
#include <memory>
class Fruit {
public:
	Fruit() {}
	virtual void show() = 0;
};
class Apple : public Fruit {
public:
	Apple() {}
	virtual void show() {
		std::cout << "我是一个苹果" << std::endl;
	}
};
class Banana : public Fruit {
public:
	Banana() {}
	virtual void show() {
		std::cout << "我是一个香蕉" << std::endl;
	}
};
class FruitFactory {
public:
	static std::shared_ptr<Fruit> create(const std::string& name) {
		if (name == "苹果") {
			return std::make_shared<Apple>();
		}
		else if (name == "⾹蕉") {
			return std::make_shared<Banana>();
		}
		return std::shared_ptr<Fruit>();
	}
};
int main()
{
	std::shared_ptr<Fruit> fruit = FruitFactory::create("苹果");
	fruit->show();
	fruit = FruitFactory::create("⾹蕉");
	fruit->show();
	return 0;
}
运行结果：
6fc8b8f8768c4fd88d16f4b136033509.png
这个模式的结构和管理产品对象的⽅式⼗分简单， 但是它的扩展性⾮常差，当我们需要新增产品的时候，就需要去修改⼯⼚类新增⼀个类型的产品创建逻辑，违背了开闭原则。
工厂方法模式
⼯⼚⽅法模式: 在简单⼯⼚模式下新增多个⼯⼚，多个产品，每个产品对应⼀个⼯⼚。假设现在有A、B 两种产品，则开两个⼯⼚，⼯⼚ A 负责⽣产产品 A，⼯⼚ B 负责⽣产产品 B，⽤⼾只知道产品的⼯⼚名，⽽不知道具体的产品信息，⼯⼚不需要再接收客⼾的产品类别，⽽只负责⽣产产品。

⼯⼚⽅法：定义⼀个创建对象的接⼝，但是由⼦类来决定创建哪种对象，使⽤多个⼯⼚分别⽣产指定的固定产品
 优点： 
 1. 减轻了⼯⼚类的负担，将某类产品的⽣产交给指定的⼯⼚来进⾏
 2. 开闭原则遵循较好，添加新产品只需要新增产品的⼯⼚即可，不需要修改原先的⼯⼚类
 缺点：对于某种可以形成⼀组产品族的情况处理较为复杂,需要创建⼤量的⼯⼚类. 

#include <iostream>
#include <string>
#include <memory>


class Fruit {
public:
	Fruit() {}
	virtual void show() = 0;
};
class Apple : public Fruit {
public:
	Apple() {}
	virtual void show() {
		std::cout << "我是一个苹果" << std::endl;
	}
private:
	std::string _color;
};
class Banana : public Fruit {
public:
	Banana() {}
	virtual void show() {
		std::cout << "我是一个香蕉" << std::endl;
	}
};
class FruitFactory {
public:
	virtual std::shared_ptr<Fruit> create() = 0;
};
class AppleFactory : public FruitFactory {
public:
	virtual std::shared_ptr<Fruit> create() {
		return std::make_shared<Apple>();
	}
};
class BananaFactory : public FruitFactory {
public:
	virtual std::shared_ptr<Fruit> create() {
		return std::make_shared<Banana>();
	}
};
int main()
{
	std::shared_ptr<FruitFactory> factory(new AppleFactory());
	std::shared_ptr<Fruit> fruit = factory->create();
	fruit->show();
	factory.reset(new BananaFactory());
	fruit = factory->create();
	fruit->show();
	return 0;
}

 运行结果：

b8aa883db0c84c5b8ca565197d541e72.png

⼯⼚⽅法模式每次增加⼀个产品时，都需要增加⼀个具体产品类和⼯⼚类，这会使得系统中类的个数成倍增加，在⼀定程度上增加了系统的耦合度。
抽象工厂模式
抽象⼯⼚模式: ⼯⼚⽅法模式通过引⼊⼯⼚等级结构，解决了简单⼯⼚模式中⼯⼚类职责太重的问
题，但由于⼯⼚⽅法模式中的每个⼯⼚只⽣产⼀类产品，可能会导致系统中存在⼤量的⼯⼚类，势
必会增加系统的开销。此时，我们可以考虑将⼀些相关的产品组成⼀个产品族（位于不同产品等级
结构中功能相关联的产品组成的家族），由同⼀个⼯⼚来统⼀⽣产，这就是抽象⼯⼚模式的基本思
想。
抽象⼯⼚：围绕⼀个超级⼯⼚创建其他⼯⼚。每个⽣成的⼯⼚按照⼯⼚模式提供对象。
思想：将⼯⼚抽象成两层，抽象⼯⼚ & 具体⼯⼚⼦类， 在⼯⼚⼦类种⽣产不同类型的⼦产品 
#include <iostream>
#include <string>
#include <memory>

class Fruit {
public:
	Fruit() {}
	virtual void show() = 0;
};
class Apple : public Fruit {
public:
	Apple() {}
	virtual void show() {
		std::cout << "我是一个苹果" << std::endl;
	}
private:
	std::string _color;
};
class Banana : public Fruit {
public:
	Banana() {}
	virtual void show() {
		std::cout << "我是一个香蕉" << std::endl;
	}
};
class Animal {
public:
	virtual void voice() = 0;
};
class Lamp : public Animal {
public:
	void voice() { std::cout << "咩咩咩\n"; }
};
class Dog : public Animal {
public:
	void voice() { std::cout << "汪汪汪\n"; }
};
class Factory {
public:
	virtual std::shared_ptr<Fruit> getFruit(const std::string& name) = 0;
	virtual std::shared_ptr<Animal> getAnimal(const std::string& name) = 0;
};
class FruitFactory : public Factory {
public:
	virtual std::shared_ptr<Animal> getAnimal(const std::string& name) {
		return std::shared_ptr<Animal>();
	}
	virtual std::shared_ptr<Fruit> getFruit(const std::string& name) {
		if (name == "苹果") {
			return std::make_shared<Apple>();
		}
		else if (name == "⾹蕉") {
			return std::make_shared<Banana>();
		}
		return std::shared_ptr<Fruit>();
	}
};
class AnimalFactory : public Factory {

public:
	virtual std::shared_ptr<Fruit> getFruit(const std::string& name) {
		return std::shared_ptr<Fruit>();
	}
	virtual std::shared_ptr<Animal> getAnimal(const std::string& name) {
		if (name == "⼩⽺") {
			return std::make_shared<Lamp>();
		}
		else if (name == "⼩狗") {
			return std::make_shared<Dog>();
		}
		return std::shared_ptr<Animal>();
	}
};
class FactoryProducer {
public:
	static std::shared_ptr<Factory> getFactory(const std::string& name) {
		if (name == "动物") {
			return std::make_shared<AnimalFactory>();
		}
		else {
			return std::make_shared<FruitFactory>();
		}
	}
};
int main()
{
	std::shared_ptr<Factory> fruit_factory = FactoryProducer::getFactory("⽔果");
	std::shared_ptr<Fruit> fruit = fruit_factory->getFruit("苹果");
	fruit->show();
	fruit = fruit_factory->getFruit("⾹蕉");
	fruit->show();
	std::shared_ptr<Factory> animal_factory = FactoryProducer::getFactory("动物");
	std::shared_ptr<Animal> animal = animal_factory->getAnimal("⼩⽺");
	animal->voice();
	animal = animal_factory->getAnimal("⼩狗");
	animal->voice();
	return 0;
}

运行结果：

84b18cc41e5f472da8e9db09dfb4880e.png

建造者模式
建造者模式是⼀种创建型设计模式， 使⽤多个简单的对象⼀步⼀步构建成⼀个复杂的对象，能够将⼀个复杂的对象的构建与它的表⽰分离，提供⼀种创建对象的最佳⽅式。主要⽤于解决对象的构建过于复杂的问题。
建造者模式主要基于四个核⼼类实现：
抽象产品类：

具体产品类：⼀个具体的产品对象类
抽象Builder类：创建⼀个产品对象所需的各个部件的抽象接⼝
具体产品的Builder类：实现抽象接⼝，构建各个部件
指挥者Director类：统⼀组建过程，提供给调⽤者使⽤，通过指挥者来构造产品 
#include <iostream>
#include <memory>
/*抽象电脑类*/
class Computer {
public:
	Computer() {}
	void setBoard(const std::string& board) { _board = board; }
	void setDisplay(const std::string& display) { _display = display; }
	virtual void setOs() = 0;
	std::string toString() {
		std::string computer = "Computer:{\n";
		computer += "\tboard=" + _board + ",\n";
		computer += "\tdisplay=" + _display + ",\n";
		computer += "\tOs=" + _os + ",\n";
		computer += "}\n";
		return computer;
	}
protected:
	std::string _board;
	std::string _display;
	std::string _os;
};
/*具体产品类*/
class MacBook : public Computer {
public:
	MacBook() {}
	virtual void setOs() {
		_os = "Max Os X12";
	}
};
/*抽象建造者类：包含创建⼀个产品对象的各个部件的抽象接⼝*/
class Builder {
public:
	virtual void buildBoard(const std::string& board) = 0;
	virtual void buildDisplay(const std::string& display) = 0;
	virtual void buildOs() = 0;
	virtual std::shared_ptr<Computer> build() = 0;
};
/*具体产品的具体建造者类：实现抽象接⼝，构建和组装各个部件*/
class MacBookBuilder : public Builder {
public:
	MacBookBuilder() : _computer(new MacBook()) {}
	virtual void buildBoard(const std::string& board) {
		_computer->setBoard(board);
	}
	virtual void buildDisplay(const std::string& display) {
		_computer->setDisplay(display);
	}
	virtual void buildOs() {
		_computer->setOs();
	}
	virtual std::shared_ptr<Computer> build() {
		return _computer;
	}
private:
	std::shared_ptr<Computer> _computer;
};
/*指挥者类，提供给调⽤者使⽤，通过指挥者来构造复杂产品*/
class Director {
public:
	Director(Builder* builder) :_builder(builder) {}
	void construct(const std::string& board, const std::string& display) {
		_builder->buildBoard(board);
		_builder->buildDisplay(display);
		_builder->buildOs();
	}
private:
	std::shared_ptr<Builder> _builder;
};
int main()
{
	Builder* buidler = new MacBookBuilder();
	std::unique_ptr<Director> pd(new Director(buidler));
	pd->construct("英特尔主板", "VOC显示器");
	std::shared_ptr<Computer> computer = buidler->build();
	std::cout << computer->toString();
	return 0;
}

 运行结果：

9b5c90d666524029bff6d379d6753aba.png

代理模式
代理模式指代理控制对其他对象的访问,也就是代理对象控制对原对象的引⽤。在某些情况下,⼀个对象不适合或者不能直接被引⽤访问,⽽代理对象可以在客⼾端和⽬标对象之间起到中介的作⽤。
代理模式的结构包括⼀个是真正的你要访问的对象(⽬标类),⼀个是代理对象。⽬标对象与代理对象实现同⼀个接⼝，先访问代理类再通过代理类访问⽬标对象。
代理模式分为静态代理、动态代理：
静态代理指的是，在编译时就已经确定好了代理类和被代理类的关系。也就是说，在编译时就已经确定了代理类要代理的是哪个被代理类。
动态代理指的是，在运⾏时才动态⽣成代理类，并将其与被代理类绑定。这意味着，在运⾏时才能确定代理类要代理的是哪个被代理类。
以租房为例，房东将房⼦租出去，但是要租房⼦出去，需要发布招租启⽰， 带⼈看房，负责维修，这些⼯作中有些操作并⾮房东能完成，因此房东为了图省事，将房⼦委托给中介进⾏租赁。 代理模式实现： 
/*房东要把⼀个房⼦通过中介租出去理解代理模式*/
#include <iostream>
#include <string>
class RentHouse {
public:
	virtual void rentHouse() = 0;
};
/*房东类：将房⼦租出去*/
class Landlord : public RentHouse {
public:
	void rentHouse() {
		std::cout << "将房子租出去\n";
	}
};
/*中介代理类：对租房⼦进⾏功能加强，实现租房以外的其他功能*/
class Intermediary : public RentHouse {
public:
	void rentHouse() {
		std::cout << "发布招租启示\n";
		std::cout << "带人看房\n";
		_landlord.rentHouse();
		std::cout << "负责租后维修\n";
	}
private:
	Landlord _landlord;
};
int main()
{
	Intermediary intermediary;
	intermediary.rentHouse();
	return 0;
}

运行结果：

9af79b328f7246febd92e0f421f93ec9.png

新绿MEHO
关注
  • 80
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 74
    评论
专栏目录
设计模式总结.pdf
07-01
自己整理的关于设计模式的总结，有全部的设计模式介绍，以及常用的设计模式总结记忆，适合程序员面试前突击以及日常学习使用
Java设计模式总结
波波烤鸭的博客
04-18 4917
什么是设计模式   设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。通过对这些设计模式的合理使用能够是我们的系统更加的健壮。 六大设计原则 设计原则 简单说明 单一职责 一个类只负责一项职责 里氏替换原则 子类可以扩展父类的功能，但不能改变父类原有的功能 依赖倒置原则 要依赖于抽象，不要依赖于具体，核心思想是面向接...
Java常见设计模式总结
张维鹏的博客
09-18 18万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
23种设计模式总结
lgxzzz的博客
05-25 7万+
一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
常用设计模式总结
热门推荐
yjclsx的博客
07-31 43万+
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，是可复用面向对象软件的基础。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中...
游戏设计模式总结
林深藏却云门寺
03-22 3317
后续这本书的读书笔记感悟都将更新在这里。
常见的23种设计模式总结
秃头的博客
10-20 3275
创建型模式：单例模式、建造者模式、工厂模式、原型模式。 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式、过滤器模式。 行为型模式：模版模式(模版方法模式)、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式、访问者模式。
【软考笔记 ——软件设计师】（七） 设计模式 总结
CPT1024
09-26 4573
总结看红色设计模式4个基本要素1、模式名称2、问题3、解决方案4 、 效果背 中英都要适配器模式 类和对象都一样背创建型 和 结构型创建型 （类 / 对象 ） 模式。
Spring 设计模式总结1
08-04
Spring设计模式总结 在软件开发中，设计模式是解决常见问题的经验总结，它们为程序员提供了在特定场景下设计高效、可维护代码的蓝图。在Spring框架中，许多设计模式被广泛应用，以提升系统的灵活性和可扩展性。以下...
所有设计模式总结
06-14
上面总结用的是思维导图，（注意：需要用xmind软件打开）设计模式总结，分为三个大类型：创建型，结构型，行为型。总结了它们适用于解决什么问题，用了后所要达到的意图。
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1089
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
iOS开发设计模式篇第一篇MVC设计模式
我叫柱子哥
07-22 1333
MVC（Model-View-Controller）是一种常见的软件设计模式，旨在将应用程序的逻辑、用户界面和输入进行分离。在iOS开发中，MVC帮助开发者组织代码，提高可维护性和可扩展性，使得项目结构更加清晰。本文将介绍MVC的基本概念、在iOS中的具体实现、优缺点、实践建议，以及其他常见的架构模式。
设计模式实战：在线购物系统的设计与实现
qq_40254606的博客
07-20 1105
本篇文章将介绍如何设计一个在线购物系统，系统包括购物车、订单处理、支付等功能。我们将通过这一项目，应用组合模式、命令模式、策略模式和观察者模式来解决具体的设计问题。通过本项目，我们综合应用了组合模式、命令模式、策略模式和观察者模式，解决了在线购物系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
(四)js前端开发中设计模式之简单工厂模式
峰会路转的博客
07-21 306
简单工厂模式,又叫静态工厂方法，由一个工厂对象决定创建出哪一种产品类的实例，主要用来创建同一类对象。
Java 和 SpringBoot 中的设计模式 详解
weixin_68074170的博客
07-19 726
假如有一结果api结果返回值的类Person，其在代码中频繁被使用。这两种使用方法的弊端有：（1）：当只需要部分参数的时候需要再定义个构造函数（比如失败的情况只需要code和message，结果肯定是空，因此不需要data），且一旦参数较多，则；（2）；Lombok插件的@Builder注解。
跟着GPT学设计模式之模板模式
欢迎关注公众号“雨林寻北”，添加个人微信codetrend（备注技术）。
07-19 998
模板模式是一种行为型设计模式，它定义了一个操作中的算法骨架，将一些步骤的具体实现延迟到子类中。该模式使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
设计模式总结：建型与结构型模式详解
"这篇文章除了标题'设计模式总结(1)'，还涉及了设计模式的分类，包括创建型、结构型和行为型设计模式的概述。文章着重讲解了创建型模式中的SingletonPattern（单例模式），并对其意图和适用性进行了详细描述，同时...
评论 74
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

新绿MEHO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值