Welcome to Torosamy`s blog

Appearance

创建型 ​

单例模式（Singleton） ​

确保一个类只有一个实例，并提供一个全局访问点。符合单一职责原则和开放封闭原则。

  • Java代码演示
java
//饿汉式方式 但会浪费内存空间 因为程序只要运行 会一直存在
//但是极力推荐 唯一一种不会被破坏的单例模式 实现简单
public enum Singleton  {
    INSTANCE;
    Singleton() {};
    public static Singleton getInstance() {return INSTANCE;}


    private String value;
    public String getValue() {return value;}
    public void setValue(String value) {this.value = value;}
}
  • Cpp代码演示
cpp
#ifndef SINGLETON_H
#define SINGLETON_H
#include <memory>

class Singleton {
public:
    Singleton() = default;
    void setNum(const int& num);
    int getNum() const;
    static std::shared_ptr<Singleton> getInstance();
private:
    static std::shared_ptr<Singleton> instance;
    int mNum;
};

#endif
cpp
#include <memory>
#include "Singleton.hpp"

std::shared_ptr<Singleton> Singleton::instance;

std::shared_ptr<Singleton> Singleton::getInstance() {
    if (nullptr == instance) instance = std::make_shared<Singleton>();

    return instance;
}

void Singleton::setNum(const int& num) {
    this->mNum = num;
}

int Singleton::getNum() const {
    return this->mNum;
}
cpp
#include <iostream>
#include "Singleton.hpp"

int main() {
    std::shared_ptr<Singleton> singleton = Singleton::getInstance();
    std::cout<<singleton->getNum()<<std::endl;
    singleton->setNum(114514);

    std::cout<<singleton->getNum()<<std::endl;
    
    std::shared_ptr<Singleton> singleton2 = Singleton::getInstance();

    std::cout<<singleton2->getNum()<<std::endl;
}

工厂方法模式（Factory Method） ​

定义一个用于创建对象的接口，让子类决定实例化哪一个类。符合开放封闭原则和依赖倒置原则。

  • Java代码演示
java
// 产品接口
interface Product {
    void doSomething();
}

// 具体产品类
class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA is doing something");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB is doing something");
    }
}

// 抽象工厂类
abstract class Creator {
    public abstract Product factoryMethod();
}

// 具体工厂类
class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

public class FactoryMethodPattern {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        Product productA = creatorA.factoryMethod();
        productA.doSomething(); // 输出: ConcreteProductA is doing something

        Creator creatorB = new ConcreteCreatorB();
        Product productB = creatorB.factoryMethod();
        productB.doSomething(); // 输出: ConcreteProductB is doing something
    }
}
  • Cpp代码演示
cpp
#include <iostream>
using namespace std;

// 产品接口
class Product {
public:
    virtual void doSomething() = 0;
    virtual ~Product() {}
};

// 具体产品类
class ConcreteProductA : public Product {
public:
    void doSomething() override {
        cout << "ConcreteProductA is doing something" << endl;
    }
};

class ConcreteProductB : public Product {
public:
    void doSomething() override {
        cout << "ConcreteProductB is doing something" << endl;
    }
};

// 抽象工厂类
class Creator {
public:
    virtual Product* factoryMethod() = 0;
    virtual ~Creator() {}
};

// 具体工厂类
class ConcreteCreatorA : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProductA();
    }
};

class ConcreteCreatorB : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProductB();
    }
};

int main() {
    Creator* creatorA = new ConcreteCreatorA();
    Product* productA = creatorA->factoryMethod();
    productA->doSomething();  // 输出: ConcreteProductA is doing something

    Creator* creatorB = new ConcreteCreatorB();
    Product* productB = creatorB->factoryMethod();
    productB->doSomething();  // 输出: ConcreteProductB is doing something

    delete creatorA;
    delete creatorB;
    delete productA;
    delete productB;

    return 0;
}

抽象工厂模式（Abstract Factory） ​

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。符合依赖倒置原则。

  • Java代码演示
java
// 抽象产品类
interface Button {
    void render();
}

interface Checkbox {
    void render();
}

// 具体产品类
class WinButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering Windows Button");
    }
}

class MacButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering Mac Button");
    }
}

class WinCheckbox implements Checkbox {
    @Override
    public void render() {
        System.out.println("Rendering Windows Checkbox");
    }
}

class MacCheckbox implements Checkbox {
    @Override
    public void render() {
        System.out.println("Rendering Mac Checkbox");
    }
}

// 抽象工厂类
interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 具体工厂类
class WinFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WinButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new WinCheckbox();
    }
}

class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

public class AbstractFactoryPattern {
    public static void main(String[] args) {
        GUIFactory factory = new WinFactory();
        Button button = factory.createButton();
        Checkbox checkbox = factory.createCheckbox();
        button.render();    // 输出: Rendering Windows Button
        checkbox.render();  // 输出: Rendering Windows Checkbox

        factory = new MacFactory();
        button = factory.createButton();
        checkbox = factory.createCheckbox();
        button.render();    // 输出: Rendering Mac Button
        checkbox.render();  // 输出: Rendering Mac Checkbox
    }
}
  • Cpp代码演示
cpp
#include <iostream>
using namespace std;

// 抽象产品类
class Button {
public:
    virtual void render() = 0;
    virtual ~Button() {}
};

class Checkbox {
public:
    virtual void render() = 0;
    virtual ~Checkbox() {}
};

// 具体产品类
class WinButton : public Button {
public:
    void render() override {
        cout << "Rendering Windows Button" << endl;
    }
};

class MacButton : public Button {
public:
    void render() override {
        cout << "Rendering Mac Button" << endl;
    }
};

class WinCheckbox : public Checkbox {
public:
    void render() override {
        cout << "Rendering Windows Checkbox" << endl;
    }
};

class MacCheckbox : public Checkbox {
public:
    void render() override {
        cout << "Rendering Mac Checkbox" << endl;
    }
};

// 抽象工厂类
class GUIFactory {
public:
    virtual Button* createButton() = 0;
    virtual Checkbox* createCheckbox() = 0;
    virtual ~GUIFactory() {}
};

// 具体工厂类
class WinFactory : public GUIFactory {
public:
    Button* createButton() override {
        return new WinButton();
    }
    
    Checkbox* createCheckbox() override {
        return new WinCheckbox();
    }
};

class MacFactory : public GUIFactory {
public:
    Button* createButton() override {
        return new MacButton();
    }

    Checkbox* createCheckbox() override {
        return new MacCheckbox();
    }
};

int main() {
    GUIFactory* factory = new WinFactory();
    Button* button = factory->createButton();
    Checkbox* checkbox = factory->createCheckbox();
    button->render();    // 输出: Rendering Windows Button
    checkbox->render();  // 输出: Rendering Windows Checkbox

    delete button;
    delete checkbox;
    
    factory = new MacFactory();
    button = factory->createButton();
    checkbox = factory->createCheckbox();
    button->render();    // 输出: Rendering Mac Button
    checkbox->render();  // 输出: Rendering Mac Checkbox

    delete button;
    delete checkbox;
    delete factory;

    return 0;
}

建造者模式（Builder） ​

将一个复杂对象的构建过程分解成多个简单的步骤。符合单一职责原则和开放封闭原则。

  • Java代码演示
java
public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainBoard;

    private Phone(Builder builder) {
        this.cpu = builder.cpu;
        this.screen = builder.screen;
        this.memory = builder.memory;
        this.mainBoard = builder.mainBoard;
    }

    public static final class Builder{
        private String cpu;
        private String screen;
        private String memory;
        private String mainBoard;


        public Builder(){}

        public Builder setCpu(final String cpu){
            this.cpu = cpu;
            return this;
        }
        public Builder setScreen(final String screen){
            this.screen = screen;
            return this;
        }
        public Builder setMemory(final String memory){
            this.memory = memory;
            return this;
        }
        public Builder setMainBoard(final String mainBoard){
            this.mainBoard = mainBoard;
            return this;
        }

        public Phone build(){
            return new Phone(this);
        }
    }
}
java
public class Main {
    public static void main(String[] args) {
        Phone phone = new Phone.Builder()
                .setMainBoard("华硕")
                .setCpu("Intel")
                .setMemory("金士顿")
                .setScreen("三星")
                .build();

        System.out.println(phone);
    }
}
  • Cpp代码演示
cpp
#include <iostream>
#include <memory>

class Player {
public:
    std::string getName() const { return mName; }
    int getID() const { return mId; }
    int getHP() const { return mHp; }
    int getLevel() const { return mLevel; }

    Player() = default;

    ~Player() = default;

    void show() const {
        std::cout << mName << "-" << mId << "-" << mHp << "-" << mLevel << std::endl;
    }

    class PlayBuilder {
    public:
        std::string mName;
        int mId;
        int mHp;
        int mLevel;

        PlayBuilder() = default;

        PlayBuilder& setName(const std::string& name) {
            this->mName = name;
            return *this;
        }

        PlayBuilder& setID(const int& id) {
            this->mId = id;
            return *this;
        }

        PlayBuilder& setHP(const int& hp) {
            this->mHp = hp;
            return *this;
        }

        PlayBuilder& setLevel(const int& level) {
            this->mLevel = level;
            return *this;
        }

        std::unique_ptr<Player> build() const {
            std::unique_ptr<Player> player = std::make_unique<Player>();
            player->mHp = this->mHp;
            player->mName = this->mName;
            player->mLevel = this->mLevel;
            player->mId = this->mId;

            return player;
        }
    };

    static PlayBuilder builder() {
        return PlayBuilder();
    }

private:
    std::string mName;
    int mId;
    int mHp;
    int mLevel;
};

int main() {
    std::unique_ptr<Player> p1 = Player::builder()
        .setName("Alice")
        .setID(101)
        .setHP(150)
        .setLevel(5)
        .build();
    p1->show();

    std::unique_ptr<Player> p2 = Player::builder()
        .setName("Bob")
        .setID(102)
        .setHP(120)
        .setLevel(3)
        .build();
    p2->show();

    std::unique_ptr<Player> p3 = Player::builder()
        .setName("Charlie")
        .setID(103)
        .setHP(200)
        .setLevel(7)
        .build();
    p3->show();

    return 0;
}

原型模式（Prototype） ​

通过复制现有的实例来创建新的对象，而不是通过构造函数。符合开放封闭原则。

  • Java代码演示
java
public class Student implements Serializable {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
java
public class Citaion implements Cloneable, Serializable {

    private Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    /**
     * 浅克隆 非基础类 还是同一个
     *  * 使用场景 1.创建一个对象比较复杂的时候 就可以克隆
     *  *          2.对性能和安全要求比较高
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    protected Citaion clone() throws CloneNotSupportedException {
        return (Citaion) super.clone();
    }

    public void show() {
        System.out.println(student.getName());
    }
}
java
public class Main {
    public static void main(String[] args) throws Exception {
        Citaion citaion1 = new Citaion();
        Student student = new Student();
        student.setName("Jack");
        citaion1.setStudent(student);

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\b.txt"));
        oos.writeObject(citaion1);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\b.txt"));
        Citaion citaion2 = (Citaion) ois.readObject();
        ois.close();

        citaion2.getStudent().setName("Tom");

        citaion1.show();
        citaion2.show();


    }
}
  • Cpp代码演示
cpp
#include <iostream>
#include <string>
using namespace std;

// 原型接口
class Prototype {
public:
    virtual Prototype* clone() const = 0;
    virtual ~Prototype() {}
};

// 具体原型类
class ConcretePrototype : public Prototype {
private:
    string name;

public:
    ConcretePrototype(const string& name) : name(name) {}

    Prototype* clone() const override {
        return new ConcretePrototype(*this);
    }

    string getName() const {
        return name;
    }
};

int main() {
    ConcretePrototype prototype1("Prototype1");
    ConcretePrototype* clone = dynamic_cast<ConcretePrototype*>(prototype1.clone());

    cout << "Original: " << prototype1.getName() << endl;  // 输出: Prototype1
    cout << "Clone: " << clone->getName() << endl;        // 输出: Prototype1

    delete clone;
    return 0;
}