1.单例模式
单例模式是一种常用的软件设计模式,其定义是单例对象的类只能允许一个实例存在。
优点:
-
在内存中只有一个对象,节省内存空间;
-
避免频繁的创建销毁对象,可以提高性能;
-
避免对共享资源的多重占用,简化访问;
-
为整个系统提供一个全局访问点。
缺点:
-
不适用于变化频繁的对象;
-
滥用单例将带来一些负面问题,如为了节省资源将数据库连接池对象设计为的单例类,可能会导致共享连接池对象的程序过多而出现连接池溢出;
-
如果实例化的对象长时间不被利用,系统会认为该对象是垃圾而被回收,这可能会导致对象状态的丢失;
示例:
public class Singleton {
// 指向自己实例的私有静态引用,主动创建
private static Singleton singleton = new Singleton();
// 私有的构造方法
private Singleton(){}
// 以自己实例为返回值的静态的公有方法,静态工厂方法
public static Singleton1 getSingleton(){
return singleton;
}
}
2.工厂模式
工厂顾名思义就是创建产品,根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式,根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建,是一种创建型模式。
工厂方法模式的结构组成:
- 抽象工厂类厂(
ShoesFactory
):工厂方法模式的核心类,提供创建具体产品的接口,由具体工厂类实现。 - 具体工厂类(
NiKeProducer\AdidasProducer\LiNingProducer
):继承于抽象工厂,实现创建对应具体产品对象的方式。 - 抽象产品类(
Shoes
):它是具体产品继承的父类(基类)。 - 具体产品类(
NiKeShoes\AdidasShoes\LiNingShoes
):具体工厂所创建的对象,就是此类。
示例:
ShoesFactory
抽象工厂类,提供了创建具体鞋子产品的纯虚函数。NiKeProducer
、AdidasProducer
、LiNingProducer
具体工厂类,继承持续工厂类,实现对应具体鞋子产品对象的创建。
// 鞋子抽象类
class Shoes
{
public:
virtual ~Shoes() {}
virtual void Show() = 0;
};
// 耐克鞋子
class NiKeShoes : public Shoes
{
public:
void Show()
{
std::cout << "我是耐克球鞋,我的广告语:Just do it" << std::endl;
}
};
// 阿迪达斯鞋子
class AdidasShoes : public Shoes
{
public:
void Show()
{
std::cout << "我是阿迪达斯球鞋,我的广告语:nothing is Impossible" << std::endl;
}
};
// 李宁鞋子
class LiNingShoes : public Shoes
{
public:
void Show()
{
std::cout << "我是李宁球鞋,我的广告语:Everything is possible" << std::endl;
}
};
// 总鞋厂
class ShoesFactory
{
public:
virtual Shoes *CreateShoes() = 0;
virtual ~ShoesFactory() {}
};
// 耐克生产者/生产链
class NiKeProducer : public ShoesFactory
{
public:
Shoes *CreateShoes()
{
return new NiKeShoes();
}
};
// 阿迪达斯生产者/生产链
class AdidasProducer : public ShoesFactory
{
public:
Shoes *CreateShoes()
{
return new AdidasShoes();
}
};
// 李宁生产者/生产链
class LiNingProducer : public ShoesFactory
{
public:
Shoes *CreateShoes()
{
return new LiNingShoes();
}
};
3.观察者模式
当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知它的依赖对象。观察者模式属于行为型模式。
实现:
观察者模式使用三个类 Subject、Observer 和 Client。
Subject 对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。
示例:
//创建 Subject 类。
public class Subject {
private List<Observer>observers = new ArrayList<Observer>();
private int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
notifyAllObservers();
}
public void attach(Observer observer){
observers.add(observer);
}
public void notifyAllObservers(){
for(Observer observer: observers){
observer.update();
}
}
}
//创建 Observer 类。
public abstract class Observer {
protected Subject subject;
public abstract void update();
}
//创建实体观察者类。
public class BinaryObserver extends Observer{
public BinaryObserver(Subject subject) {
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println("Binary String:"+Integer.toBinaryString(subject.getState()));
}
}
//创建实体观察者类。
public class OctalObserver extends Observer{
public OctalObserver(Subject subject) {
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println("Octal String:"+Integer.toOctalString(subject.getState()));
}
}
//创建实体观察者类。
public class HexaObserver extends Observer {
public HexaObserver(Subject subject) {
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println("Hex String:"+Integer.toHexString(subject.getState()).toUpperCase());
}
}
//使用 Subject 和实体观察者对象。
public class ObserverPatternDemo {
public static void main(String[] args)
{
Subject subject = new Subject();
new HexaObserver(subject);
new OctalObserver(subject);
new BinaryObserver(subject);
System.out.println("First state change:15");
subject.setState(15);
System.out.println("Second state change:10");
subject.setState(10);
}
}
输出结果:
First state change:15
Hex String:F
Octal String:17
Binary String:1111
Second state change:10
Hex String:A
Octal String:12
Binary String:1010
4.生产者消费者模式
生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的
组成:
- 三种角色:生产者、消费者、仓库
- 两种关系:生产者与生产者之间是互斥关系,消费者与消费者之间是互斥关系,生产者与消费者之间是同步与互斥关系。
- 一个交易场所:仓库(这里我们用阻塞队列来表示)
优点:
- 解耦–生产者。消费者之间不直接通信,降低了耦合度。
- 支持并发
- 支持忙闲不均