程序设计模式作业（java 和 c++ 两种实现方式）

最新推荐文章于 2022-10-19 11:20:09 发布

zyw2002

最新推荐文章于 2022-10-19 11:20:09 发布

阅读量1.2k

点赞数 3

分类专栏： # 程序设计模式文章标签：程序设计模式

本文链接：https://blog.csdn.net/zyw2002/article/details/124242628

版权

程序设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

3. 简单工厂模式
5. 抽象工厂模式
7. 原型模式
8. 单例模式
9. 适配器模式
10. 桥接模式
12. 装饰模式
13. 外观模式
14. 享元模式
15. 代理模式
16. 职责链模式
18. 解释器模式
22. 观察者模式
23. 状态模式

3. 简单工厂模式

简单工厂模式：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。
在这里插入图片描述
🎯 java版本

// Chart： 抽象表接口，充当抽象产品类
public interface Chart{
    public void display();
}

// Histogram: 柱状图类，充当具体产品类
public class HistogramChart implements Chart{
    public HistogramChart(){
        System.out.println("Create Histogram!");
    }
    public void display(){
        System.out.println("Display Histogram!");
    }
}

//PieChart: 饼状图类，充当具体产品类
public class PieChart implements Chart{
    public PieChart(){
        System.out.println("Create PieChart!");
    }
    public void display(){
        System.out.println("Display PieChart!");
    }
}

//LineChart: 折线图类，充当具体产品类
public class LineChart implements Chart{
    public LineChart(){
        System.out.println("Create LineChart!");
    }
    public void display() {
        System.out.println("Display LineChart!");
    }
}

//ChartFactory: 图表工厂类，充当工厂
public class ChartFactory{
    public static Chart getChart(string type){
        Chart chart = null;
        if(type.equalsIgnoreCase("histogram")){
            chart=new HistogramChart();
            System.out.println("Init Histogram...");
        }else if{
            chart=new PieChart()
            System.out.println("Init PieChart...");
        }else if{
            chart=new LineChart()
            System.out.println("Init LineChart...");
        }
        return chart;
    }
}

// Client: 客户端测试类
public class Client{
    public static void main(String args[]){
        Chart chart;
        chart=ChartFactory.getChart("histogram");
        chart.display();
    }
}

🎯 c++版本

#include <stdlib.h>
#include <iostream>
#include <string.h>
using namespace std;
// Chart： 抽象表接口，充当抽象产品类
class Chart
{
public:
	Chart() { cout << "Init Chart"; };
	virtual void display() = 0;
	virtual ~Chart() { cout << "Destroy Chart"; };
};

// Histogram: 柱状图类，充当具体产品类
class HistogramChart : public Chart
{
public:
	HistogramChart() {
		cout << "Create Histogram!" << endl;
	}
	virtual void display() {
		cout << "Display Histogram!" << endl;
	}
};

//PieChart: 饼状图类，充当具体产品类
class PieChart : public Chart
{
public:
	PieChart() {
		cout << "Create PieChart!" << endl;
	}
	virtual void display() {
		cout << "Display PieChart!" << endl;
	}
};

//LineChart: 折线图类，充当具体产品类
class LineChart : public Chart
{
public:
	LineChart() {
		cout << "Create LineChart!" << endl;
	}
	virtual void display() {
		cout << "Display LineChart!" << endl;
	}
};

//ChartFactory: 图表工厂类，充当工厂
class ChartFactory
{
public:
	static Chart* getChart(string type) {
		Chart* chart = NULL;
		if (type == "HistogramChart") {
			chart = new HistogramChart();
			cout << "Init HistogramChart" << endl;
		}
		else if (type == "PieChart") {
			chart = new PieChart();
			cout << "Init PieChart" << endl;
		}
		else if (type == "LineChart") {
			chart = new LineChart();
			cout << "Init LineChart" << endl;
		}
		return chart;
	}
};

int  main() {
	ChartFactory* factory=new ChartFactory();
	Chart* chart = factory->getChart("HistogramChart");
	return 0;
}

5. 抽象工厂模式

抽象工厂模式：提供一个创建一个或者一些列相关或者相互依赖对象的接口，而无需指定具体的类
在这里插入图片描述
🎯 java版本

public interface Button {
    public void display();
}
public class SpringButton implements Button{
    @Override
    public void display() {
        System.out.println("green button");
    }
}
public class SummerButton implements Button{
    @Override
    public void display() {
        System.out.println("Blue Button");
    }
}

public interface TextField {
    public void display();
}
public class SpringTextField implements TextField{
    @Override
    public void display() {
        System.out.println("green textfield");
    }
}
public class SummerTextfield implements TextField{
    @Override
    public void display() {
        System.out.println("blue textfield");
    }
}
public interface ComboBox {
    public void display();
}
public class SpringComboBox implements ComboBox{
    @Override
    public void display() {
        System.out.println("green ComboVBox");
    }
}
public class SummerComboBox implements  ComboBox{
    @Override
    public void display() {
        System.out.println("blue ComboVBox");
    }
}
public interface SkinFactory {
    public Button createButton();
    public TextField createTextField();
    public ComboBox createComboBox();
}
public class SpringSkinFactory implements SkinFactory{
    @Override
    public Button createButton() {
        return new SpringButton();
    }

    @Override
    public TextField createTextField() {
        return new SpringTextField();
    }
    
    @Override
    public ComboBox createComboBox() {
        return new SpringComboBox();
    }    
}
public class SummerSkinFactory implements SkinFactory{
    @Override
    public Button createButton() {
        return new SummerButton();
    }

    @Override
    public TextField createTextField() {
        return new SummerTextfield();
    }
    
    @Override
    public ComboBox createComboBox() {
        return new SummerComboBox();
    }
}

public class Client {
    public static void main(String[] args){
        SkinFactory factory = new SpringSkinFactory();
        Button button = factory.createButton();
        button.display();
    }
}

🎯 c++版本

#include <iostream>
#include <stdlib.h>
using namespace std;

class Button {
public:
	virtual void display() =0;
};
class SpringButton : Button {
public:
	virtual void display() {
		cout << "green button" << endl;
	 }
};
class SummerButton : Button {
public:
	virtual void display() {
		cout << "blue button" << endl;
	}
};

class TextField {
public:
	virtual void display()=0;
};
class SpringTextField : TextField {
public:
	virtual void display() {
		cout << "green TextField" << endl;
	}
};
class SummerTextField : TextField {
public:
	virtual void display() {
		cout << "blue TextFieldn" << endl;
	}
};

class  ComboBox {
public:
	virtual void display()=0;
};
class SpringComboBox: ComboBox {
public:
	virtual void display() {
		cout << "green  ComboBox " << endl;
	}
};
class SummerComboBox : ComboBox {
public:
	virtual void display() {
		cout << "blue  ComboBox " << endl;
	}
};

class SkinFactory {
public :
	virtual Button* createButton() = 0;
	virtual TextField* createTextField() = 0;
	virtual ComboBox* createComboBox() = 0;
};

class SpingSkingFactory :SkinFactory{
public:
	virtual Button* createButton() {
		Button* button =(Button*) new SpringButton();
		return button;
	}
	virtual TextField* createTextField() {
		TextField* textfield = (TextField*) new SpringTextField();
		return textfield;
	}
	virtual ComboBox* createComboBox() {
		ComboBox* combobox = (ComboBox*) new SpringComboBox();
		return combobox;
	}
};

class SummerFactory :SkinFactory {
public:
	virtual Button* createButton() {
		Button* button = (Button*) new SummerButton();
		return button;
	}
	virtual TextField* createTextField() {
		TextField* textfield = (TextField*) new SummerTextField();
		return textfield;
	}
	virtual ComboBox* createComboBox() {
		ComboBox* combobox = (ComboBox*) new SummerComboBox();
		return combobox;
	}
};

void main() {
	SkinFactory* factory =(SkinFactory*) new SpingSkingFactory();
	Button* button = factory->createButton();
	button->display();
}

7. 原型模式

原型模式：使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象。
在这里插入图片描述
🎯 java版本

public abstract class Book {
    public abstract Book clone();
}

public class BookA extends Book{
    private String author;
    private String content;
    private Integer price;
    private Disk disk;

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    public Disk getDisk() {
        return disk;
    }

    public void setDisk(Disk disk) {
        this.disk = disk;
    }

    @Override
    public Book clone() {
        Book book=new BookA();
        ((BookA) book).setPrice(this.price);
        ((BookA) book).setDisk((Disk) this.disk.clone());
        ((BookA) book).setContent(this.content);
        ((BookA) book).setAuthor(this.author);
        return book;
    }
}

public class Disk extends Book{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void display(){
        System.out.println("光盘名称为"+name);
    }
    
    public void displayInfo(){
        System.out.println("author: "+this.author);
        System.out.println("content: "+this.content);
        System.out.println("price: "+this.price);
        this.disk.display();
    }
    
    public  Book clone(){
        Book copy=new Disk();
        ((Disk) copy).setName(this.name);
        return copy;
    }
}

public class Client {
    public static void main(String[] args) {
        BookA book1=new BookA();
        book1.setAuthor("author1");
        book1.setContent("content1");
        book1.setPrice(45);
        Disk diska=new Disk();
        diska.setName("disk1");
        book1.setDisk(diska);
        BookA book2= (BookA)book1.clone();
        System.out.println("book1's information:");
        book1.displayInfo();
        System.out.println("book2's information:");
        book2.displayInfo();
        System.out.println("书籍是否相同？"+(book1==book2));
        System.out.println("光盘是否相同？"+(book1.getDisk()==book2.getDisk()));
    }
}

🎯 c++ 版本

#include <iostream>
#include <string.h>
using namespace std;

class Book {
public:
	virtual Book* clone()=0;
};
class Disk :Book{
private:
	string name;
public:
	string getName() {
		return name;
	}
	void setName(string name) {
		this->name = name;
	}
	void display() {
		cout << "光盘名称为: " << name << endl;
	}
	Book* clone() {
		Book* copy = new Disk();
		((Disk*)copy)->setName(this->name);
		return copy;
	}
};
class  BookA :Book {
private:
	string author;
	string content;
	int price;
	Disk* disk;

public:
    string getAuthor() {
        return author;
    }

    void setAuthor(string author) {
        this->author = author;
    }

    string getContent() {
        return content;
    }

    void setContent(string content) {
        this->content = content;
    }

    int getPrice() {
        return price;
    }

    void setPrice(int price) {
        this->price = price;
    }

    Disk* getDisk() {
        return disk;
    }

    void setDisk(Disk* disk) {
        this->disk = disk;
    }

    Book* clone() {
        Book* book = new BookA();
        ((BookA*) book)->setPrice(this->price);
        ((BookA*)book)->setDisk((Disk*)this->disk->clone());
        ((BookA*)book)->setContent(this->content);
        ((BookA*)book)->setAuthor(this->author);
        return book;
    }

    void displayInfo() {
        cout << "author:" << this->author<<endl;
        cout << "content:" << this->content<<endl;
        cout << "price:" << this->price<<endl;
        this->disk->display();
    }
};

int main() {
    BookA* book1 = new BookA();
    book1->setAuthor("author1");
    book1->setContent("content1");
    book1->setPrice(45);
    Disk* diska = new Disk();
    diska->setName("disk1");
    book1->setDisk(diska);
    BookA* book2 = (BookA*)book1->clone();
    cout << "book1的信息：" << endl;
    book1->displayInfo();
    cout << "book2的信息：" << endl;
    book1->displayInfo();
    cout << "书籍是否相同？" << (book1==book2) << endl;
    cout << "光盘是否相同？" << (book1->getDisk() == book2->getDisk()) << endl;
}

8. 单例模式

单例模式：确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一的实例。
在这里插入图片描述
🎯 java版本

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

// 假设一个国家内只有两个国王，一个国王的管辖城市可以有多个
public class King {
    private static ArrayList<King> instance =new ArrayList<>();
    private static final int N = 2;
    private List cityList=null;
    private King(){
        cityList=new ArrayList();
    }

    public static King getInstance(){
        while (instance.size()<N){
            instance.add(new King());
        }
        Random r=new Random();
        int i=r.nextInt(N);
        return instance.get(i);
    }

    public  void addCity(String city){
        cityList.add(city);
    }

    public void delCity(String city){
        cityList.remove(city);
    }
    public void showCity(){
       for(int i=0;i<cityList.size();i++){
           System.out.println("city "+i+": "+cityList.get(i));
       }
    }
}

public class Client {
    public static void main(String[] args) {
        King k1,k2,k3;
        k1=King.getInstance();
        k2=King.getInstance();
        k3=King.getInstance();
        System.out.println("k1==k2?" + (k1==k2));
        System.out.println("k2==k3?" + (k2==k3));
        System.out.println("k1==k3?" + (k1==k3));
        k1.addCity("c1");
        k2.addCity("c2");
        k3.addCity("c3");
        System.out.println("k1----city");
        k1.showCity();
        System.out.println("k2----city");
        k2.showCity();
        System.out.println("k3----city");
        k3.showCity();
    }
}

🎯 c++版本

#include <iostream>
#include <stdlib.h>
#include <list>
#include <vector>
#include <string.h>
#include<time.h>
using namespace std;

class King {
private:
	static int N;
	static vector<King*> instance;
	list<string> citylist;
	King() {
		cout << "King()" << endl;
	}

public:
	static King* getInstance() {
		while (instance.size() < N) {
			instance.push_back(new King());
		}
		int i = rand() % instance.size();
		return instance[i];
	}
	void addCity(string city) {
		citylist.push_back(city);
	}
	void delCity(string city) {
		citylist.remove(city);
	}
	void showCity() {
		list<string>::iterator It = citylist.begin();
		while (It != citylist.end())
			cout << *(It++) << " ";
		cout << endl;
	}
};

int King::N = 2;
vector<King*> King::instance = vector<King*>();
int main(){
	King* k1, *k2, *k3;
	k1 = King::getInstance();
	k2 = King::getInstance();
	k3 = King::getInstance();
	cout << "k1==k2? " << (k1 == k2) << endl;
	cout << "k2==k3? " << (k2 == k3) << endl;
	cout << "k1==k3? " << (k1 == k3) << endl;
	k1->addCity("c1");
	k2->addCity("c2");
	k3->addCity("c3");
	cout<<"k1----city"<<endl;
	k1->showCity();
	cout<<"k2----city"<<endl;
	k2->showCity();
	cout << "k3----city" << endl;
	k3->showCity();
	return 0;
}

9. 适配器模式

适配器模式：将一个类的接口转化成客户希望的另一个接口，适配器模式让那些接口不兼容的类可以一起工作。
在这里插入图片描述

public abstract class Robot {
    public void move(){
        System.out.println("Robot is moving");
    }
    public abstract void sing();
    public abstract void dance();
}

public class ArtSing {
    public  void singer(){
        System.out.println("singing...");
    }
}

public class ArtDance {
    public  void  dancer(){
        System.out.println("dancing...");
    }
}

public class ArtRobotAdapter extends Robot{
    private ArtDance dancer;
    private ArtSing singer;
    public ArtRobotAdapter(){
        singer=new ArtSing();
        dancer=new ArtDance();
    }
    @Override
    public void sing() {
        singer.singer();
    }

    @Override
    public void dance() {
        dancer.dancer();
    }
}

public class Client {
    public static void main(String[] args) {
        Robot robot =new ArtRobotAdapter();
        robot.move();
        robot.dance();
        robot.sing();
    }
}

🎯 C++ 版本

#include <iostream>
#include <stdlib.h>
using namespace std;

class Robot{
public:
	void move() {
		cout << "robot is moving" << endl;
	}
	virtual void sing()=0;
	virtual void dance()=0;
};

class ArtSing {
public:
	virtual void singer() {
		cout << "singing..." << endl;
	}
};

class ArtDance {
public:
	virtual void dancer() {
		cout << "dancing..." << endl;
	}
};

class ArtRobotAdapter : Robot {
private:
	ArtDance* dancer;
	ArtSing* singer;
public:
	ArtRobotAdapter() {
		dancer = new ArtDance();
		singer = new ArtSing();
	}
	void sing() {
		singer->singer();
	}
	void dance() {
		dancer->dancer();
	}
};

int main() {
	Robot* robot =(Robot *) new ArtRobotAdapter();
	robot->move();
	robot->dance();
	robot->sing();
}

10. 桥接模式

桥接模式：将抽象部分与它的实现部分解耦，使得二者都能够独立变化
在这里插入图片描述

🎯 java版本

public interface Color {
    public void setColor();
}
public class Green implements Color{
    @Override
    public void setColor() {
        System.out.println("color is green!");
    }
}
public class Red implements Color{
    @Override
    public void setColor() {
        System.out.println("color is red!");
    }
}
public class Blue implements Color{
    @Override
    public void setColor() {
        System.out.println("color is blue!");
    }
}
public abstract class Brush {
    protected  Color color;

    public void setColorBrush(Color color) {
        color.setColor();
    }
    public abstract void draw();
}
public class BigBrush extends Brush{
    @Override
    public void draw() {
        System.out.println("big brush is drawing");
    }
}
public class MediumBrush extends Brush{
    @Override
    public void draw() {
        System.out.println("medium brush is drawing");
    }
}
public class SmallBrush extends Brush{
    @Override
    public void draw() {
        System.out.println("small brush is drawing");
    }
}
public class Client {
    public static void main(String[] args) {
        Color color = new Green();
        Brush brush = new BigBrush();
        brush.setColorBrush(color);
        brush.draw();
    }
}

🎯 c++模式

#include <iostream>
#include <stdlib.h>
using namespace std;

class Color {
public:
	 virtual void setColor()= 0 ;
};

class Green : Color {
public:
	virtual void setColor() {
		cout << "color is green！" << endl;
	}
};

class Red : Color {
public:
	virtual void setColor() {
		cout << "color is red！" << endl;
	}
};

class Blue : Color {
public:
	virtual void setColor() {
		cout << "color is blue！"<<endl;
	}
};

class Brush {
public:
	void setColorBrush(Color* color) {
		color->setColor();
	}
	virtual void draw()=0;
protected:
		Color* color;
};

class BigBrush : Brush {
public:
	virtual void draw() {
		cout << "Big brush is drawing" << endl;
	}
};

class MediumBrush : Brush {
public:
	virtual void draw() {
		cout << "Medium brush is drawing" << endl;
	}
};

class SmallBrush : Brush {
public:
	virtual void draw() {
		cout << "Small brush is drawing"<<endl;
	}
};

int main() {
	Color* color =(Color *) new Green();
	Brush* brush = (Brush*) new BigBrush();
	brush->setColorBrush(color);
	brush->draw();
}

12. 装饰模式

装饰模式：动态的给一个对象添加一些额外的职责。就拓展能力而言，装饰模式提供了一种比使用子类更加灵活的替代方案。
在这里插入图片描述
🎯 java实现版本

public abstract class Component {
    public abstract void display();
}
public class ListBox extends Component{
    @Override
    public void display() {
        System.out.println("show listbox");
    }
}
public class TextBox extends Component{
    @Override
    public void display() {
        System.out.println("show textbox");
    }
}
public class Window extends Component{
    @Override
    public void display() {
        System.out.println("show window!");
    }
}
public class ComponentDecorator extends Component{
    private  Component component;
    public ComponentDecorator(Component component){
        this.component=component;
    }
    public void display(){
        component.display();
    }
}
public class BlackBorderDecorator extends ComponentDecorator{
    public BlackBorderDecorator(Component component) {
        super(component);
    }

    @Override
    public void display() {
        this.setBlackBoder();
        super.display();
    }

    public void setBlackBoder(){
        System.out.println("add BlackBorder!");
    }
}
public class ScrollBarDecorator extends ComponentDecorator{
    public ScrollBarDecorator(Component component) {
        super(component);
    }

    @Override
    public void display() {
        this.setScrollBar();
        super.display();
    }

    public void setScrollBar(){
        System.out.println("add scrollBar!");
    }
}
public class Client {
    public static void main(String[] args) {
        Component component,componentSB,componentBB;
        component=new Window();
        componentSB= new ScrollBarDecorator(component);
        componentBB=new BlackBorderDecorator(componentSB);
        componentBB.display();
    }
}

🎯 c++实现版本

#include <iostream>
#include <string.h>
using namespace std;

class Component {
public:
	virtual void display() = 0;
};

class ListBox : public Component {
public:
	virtual void display() {
		cout << "show listbox" << endl;
	}
};

class TextBox :public Component {
public:
	virtual void display() {
		cout << "show textbox" << endl;
	}
};

class Window :public Component {
public:
	virtual void display() {
		cout << "show window" << endl;
	}
};

class ComponentDecorator : public  Component {
private:
	Component* m_component;
public:
	ComponentDecorator(Component* component): m_component(component) {}
	virtual void display() {
		m_component->display();
	}
};

class BlackBorderDecorator : public ComponentDecorator {
public:
	BlackBorderDecorator(Component* component) :ComponentDecorator(component) {}
	void display() {
		ComponentDecorator::display();
		setBlackborder();
	}
private:
	void setBlackborder() {
		cout << "add blackborder" << endl;
	}

};

class ScrollBarDecorator : public ComponentDecorator {
public:
	ScrollBarDecorator(Component* component) :ComponentDecorator(component) {}
	void display() {
		ComponentDecorator::display();
		setScrollBar();
	}
private:
	void setScrollBar() {
		cout << "add scrollbar" << endl;
	}

};

int main() {
	Component* component;
	Component* componentSB;
	Component *componentBB;
	component = new Window();
	componentSB = new ScrollBarDecorator(component);
	componentBB = new BlackBorderDecorator(componentSB);
	componentBB->display();
	return 0;
}

13. 外观模式

外观模式：为子系统中的一组接口提供一个统一的入口。外观模式定义了一个高层接口，这个接口使得一个子系统更加容易使用。
抽象外观模式：外观模式违背了开闭原则，通过引入一个抽象外观类解决了该问题。
在这里插入图片描述
🎯 java版本

public abstract class AbstractEncryptFacade {
    public abstract void fileEncrypt(String fileNameSrc,String fileNameDes);
}

public class EncryptFacade extends AbstractEncryptFacade{
    private FileReader reader;
    private CipherMachine cipher;
    private FileWriter writer;

    public EncryptFacade(){
        reader=new FileReader();
        cipher=new CipherMachine();
        writer=new FileWriter();
    }

    public void fileEncrypt(String fileNameSrc,String fileNameDes){
        String plainStr=reader.read(fileNameSrc);
        String encryptStr=cipher.encrypt(plainStr);
        writer.write(encryptStr,fileNameDes);
    }
}
import javax.imageio.stream.FileImageInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileReader {
    public String read(String fileNameSrc){
        System.out.println("读取文件，获取明文:");
        StringBuffer sb= new StringBuffer();
        try {
            FileInputStream inFS=new FileInputStream(fileNameSrc);
            int data;
            while((data=inFS.read())!=-1){
                sb=sb.append((char)data);
            }
            inFS.close();
            System.out.println(sb.toString());
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在");
        }catch (IOException e){
            System.out.println("文件操作错误");
        }
        return sb.toString();
    }

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileWriter {
    public void write(String encryStr,String fileName){
        System.out.println("保存密文，写入文件");
        try{
            FileOutputStream outFs=new FileOutputStream(fileName);
            outFs.write(encryStr.getBytes());
            outFs.close();
        } catch (FileNotFoundException e) {
           System.out.println("文件不存在！");
        } catch (IOException e) {
            System.out.println("文件操作错误！");
        }
    }
}

public class CipherMachine {
    public String encrypt(String plainText){
        System.out.println("数据加密，将明文转换为密文:");
        String es="";
        for(int i=0;i<plainText.length();i++){
            String c=String.valueOf(plainText.charAt(i)%7);
            es+=c;
        }
        System.out.println(es);
        return es;
    }
}
public class NewChipherMachine {
    public String encrypt(String plainText){
        System.out.println("数据加密，将明文转换为密文");
        String es="";
        int key=10;
        for(int i=0;i<plainText.length();i++){
            char c=plainText.charAt(i);
            if(c>='a'&& c<='z'){
                c+=key%26;
                if(c>'z') c-=26;
                if(c<'A') c+=26;
            }
            es += c;
        }
        System.out.println(es);
        return es;
    }
}

public class NewEncryptFacade extends AbstractEncryptFacade{
    private FileReader reader;
    private NewChipherMachine cipher;
    private FileWriter writer;

    public NewEncryptFacade(){
        reader=new FileReader();
        cipher=new NewChipherMachine();
        writer=new FileWriter();
    }
    @Override
    public void fileEncrypt(String fileNameSrc, String fileNameDes) {
        String plainStr=reader.read(fileNameSrc);
        String encryptStr= cipher.encrypt(plainStr);
        writer.write(encryptStr,fileNameDes);
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractEncryptFacade ef1 =new NewEncryptFacade();
        ef1.fileEncrypt("file1.txt","file2.txt");
        System.out.println("------------------------");
        AbstractEncryptFacade ef2= new EncryptFacade();
        ef2.fileEncrypt("file1.txt","file3.txt");
    }
}

🎯 cpp版本

#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

class AbstractEncryptFacade {
public:
    virtual void fileEncrypt(string fileNameSrc, string fileNameDes) = 0;
};

class FileReader {
public:
    string read(string fileNameSrc) {
        cout << "读取文件，获取明文:" << endl;
        string s = "hello world";
        return s;
    }
};

class FileWriter {
public:
    void write(string encryStr,string filename) {
        cout << "将密文"<<encryStr<<"写入文件"<<filename << endl;
    }
};

class CipherMachine {
public:
    string encrypt(string plainText) {
        cout << "数据加密，将明文转换为密文:" << endl;
        string es = "233364062325";
        cout << es << endl;
        return es;
    }
};

class NewCipherMachine {
public:
    string encrypt(string plainText) {
        cout << "数据加密，将明文转换为密文:" << endl;
        string es = "Hovvy gybvn!";
        cout << es << endl;
        return es;
    }
};

class EncryptFacade : AbstractEncryptFacade {
private:
    FileReader* reader;
    CipherMachine* cipher;
    FileWriter* writer;

public:
    EncryptFacade() {
        reader = new FileReader();
        cipher = new CipherMachine();
        writer = new FileWriter();
    }
    void fileEncrypt(string fileNameSrc, string fileNameDes) {
        string plainStr = reader->read(fileNameSrc);
        string encryptStr = cipher->encrypt(plainStr);
        writer->write(encryptStr, fileNameDes);
    }
};

class NewEncryptFacade : AbstractEncryptFacade {
private:
    FileReader* reader;
    NewCipherMachine* cipher;
    FileWriter* writer;

public:
    NewEncryptFacade() {
        reader = new FileReader();
        cipher = new NewCipherMachine();
        writer = new FileWriter();
    }
    void fileEncrypt(string fileNameSrc, string fileNameDes) {
        string plainStr = reader->read(fileNameSrc);
        string encryptStr = cipher->encrypt(plainStr);
        writer->write(encryptStr, fileNameDes);
    }
};

int main() {
    AbstractEncryptFacade* ef1 =(AbstractEncryptFacade*) new NewEncryptFacade();
    ef1->fileEncrypt("file1.txt", "file2.txt");
    cout<<"------------------------"<<endl;
    AbstractEncryptFacade* ef2 = (AbstractEncryptFacade*) new EncryptFacade();
    ef2->fileEncrypt("file1.txt", "file3.txt");
}

14. 享元模式

享元模式：运用共享技术有效支持大量细粒度对象的复用。
在这里插入图片描述
🎯 java 模式

public abstract class IgoChessman {
    public abstract String getColor();
    public void display(){
        System.out.println("the color of chess is: "+ this.getColor());
    }
}

public class BlackIgoChess extends IgoChessman{
    @Override
    public String getColor() {
        return "black";
    }
}

public class WhiteIgoChess extends IgoChessman{
    @Override
    public String getColor() {
        return "white";
    }
}

import java.util.Hashtable;

public class IgoChessmanFactory{
    private static IgoChessmanFactory instance = new IgoChessmanFactory();
    private static Hashtable ht;

    private IgoChessmanFactory(){
        ht= new Hashtable();
        IgoChessman black,white;
        black= new BlackIgoChess();
        white = new WhiteIgoChess();
        ht.put("b",black);
        ht.put("w",white);
    }

    public static IgoChessmanFactory getInstance(){
        return instance;
    }

    public static IgoChessman getIgoChessman(String color){
        return (IgoChessman) ht.get(color);
    }
}

public class Client {
    public static void main(String[] args) {
        IgoChessman black1,black2,white1,white2;
        IgoChessmanFactory factory =IgoChessmanFactory.getInstance();
        black1=factory.getIgoChessman("b");
        black2=factory.getIgoChessman("b");
        System.out.println("black1==black2?  "+(black1==black2));
        black1.display();
        black2.display();
        white1=factory.getIgoChessman("w");
        white2=factory.getIgoChessman("w");
        System.out.println("white1==white2?  "+(white1==white2));
        white1.display();
        white2.display();
    }
}

🎯 c++版本

#include <iostream>
#include <string.h>
#include <map>
using namespace std;

class IgoChessman {
public:
	void display() {
		cout << "the color of chess is : " << this->getColor() << endl;
	}
	virtual string getColor() = 0;
};

class BlackIgoChess :IgoChessman {
public:
	virtual string getColor() {
		return "black";
	}
};

class WhiteIgoChess :IgoChessman {
public:
	virtual string getColor() {
		return "white";
	}
};


class IgoChessmanFactory {
private:
	static IgoChessmanFactory* instance;
	map<string, IgoChessman*> mp;
	IgoChessmanFactory() {
		IgoChessman* black, * white;
		black = (IgoChessman*) new BlackIgoChess();
		white = (IgoChessman*) new WhiteIgoChess();
		mp["b"] = black;
		mp["w"] = white;
	}
public:
	static IgoChessmanFactory* getInstance() {
		return instance;
	}
	IgoChessman* getIgoChessman(string color) {
		return mp.find(color)->second;
	}
};
IgoChessmanFactory* IgoChessmanFactory::instance = new IgoChessmanFactory();

int main() {
	IgoChessman* black1, * black2, * white1, * white2;
	IgoChessmanFactory* factory = IgoChessmanFactory::getInstance();
	black1 = factory->getIgoChessman("b");
	black2 = factory->getIgoChessman("b");
	cout << "black1==black2?  " << (black1 == black2) << endl;
	black1->display();
	black2->display();

	white1 = factory->getIgoChessman("w");
	white2 = factory->getIgoChessman("w");
	cout << "white1==white2?  " <<(white1 == white2) << endl;
	white1->display();
	white2->display();
}

15. 代理模式

代理模式：给某个对象提供一个代码或者占位符，并由代理对象来控制对原对象的访问。
在这里插入图片描述

🎯 java版本

public abstract class Subject {
    public abstract void request();
}

public class RealSubject extends Subject{
    public void request(){
        System.out.println("具体业务方法的实现！");
    }
}

public class Proxy extends Subject{
    private RealSubject realSubject=new RealSubject();
    private void preRequest(){
        System.out.println("preRequest...");
    }
    private void postRequest(){
        System.out.println("postRequest...");
    }
    @Override
    public void request() {
        preRequest();
        realSubject.request();
        postRequest();
    }
}

public class Client {
    public static void main(String[] args) {
        Subject subject= new Proxy();
        subject.request();
    }
}

🎯 c++版本

#include <iostream>
using namespace std;

class Subject {
public:
	virtual void request() = 0;
};

class RealSubject :Subject {
public:
	virtual void request() {
		cout << "具体业务方法的实现" << endl;
	}
};

class Proxy : Subject {
private:
	RealSubject* realsubject = new RealSubject();
	void preRequest() {
		cout << "preRequest..." << endl;
	}
	void postRequest() {
		cout << "postRequest..." << endl;
	}
	void request() {
		preRequest();
		realsubject->request();
		postRequest();
	}
};

int main() {
	Subject* subject = (Subject*)new Proxy();
	subject->request();
}

16. 职责链模式

职责链模式：避免将一个请求的发送者和接收者耦合在一起，让多个对象都有机会处理请求。将接受请求的对象连接成一条链。并且沿着这条链传递请求，直到有一个对象可以处理它为止。
在这里插入图片描述

public class PurchaseRequest {
    private double amount; // 采购金额
    private int number; // 采购单编号
    private String purpose; // 采购目的

    public PurchaseRequest(double amount,int number, String purpose){
        this.amount=amount;
        this.number=number;
        this.purpose=purpose;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getPurpose() {
        return purpose;
    }

    public void setPurpose(String purpose) {
        this.purpose = purpose;
    }
}

public abstract class Approver {
    protected Approver successor; //定义后继对象
    protected String name;

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

    // 设置后继者
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }

    // 抽象请求处理方法
    public abstract void processRequest(PurchaseRequest request);
}

public class Director extends Approver{

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

    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount()<50000){ //处理请求
            System.out.println("主任"+this.name+"审批采购单："+request.getNumber()+",金额"+request.getAmount()+"元，采购目的"+request.getPurpose()+".");
        }
        else{
            this.successor.processRequest(request);
        }
    }
}

public class VicePresident extends Approver{
    public VicePresident(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount()<100000){ //处理请求
            System.out.println("副董事长"+this.name+"审批采购单："+request.getNumber()+",金额"+request.getAmount()+"元，采购目的"+request.getPurpose()+".");
        }
        else{
            this.successor.processRequest(request);
        }
    }
}

public class President extends Approver{
    public President(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount()<500000){ //处理请求
            System.out.println("董事长"+this.name+"审批采购单："+request.getNumber()+",金额"+request.getAmount()+"元，采购目的"+request.getPurpose()+".");
        }
        else{
            this.successor.processRequest(request);
        }
    }
}

public class Congress extends Approver{
    public Congress(String name) {
        super(name);
    }

    @Override
    public void processRequest(PurchaseRequest request) {
        System.out.println("董事会"+this.name+"审批采购单："+request.getNumber()+",金额"+request.getAmount()+"元，采购目的"+request.getPurpose()+".");
    }
}

public class Client {
    public static void main(String[] args) {
        Approver Zhang,Li,Wang,Dong;
        Zhang=new Director("张三");
        Li =new VicePresident("李四");
        Wang =new President("王五");
        Dong=new Congress("董六");
        // 创建职责链
        Zhang.setSuccessor(Li);
        Li.setSuccessor(Wang);
        Wang.setSuccessor(Dong);
        // 创建采购单
        PurchaseRequest pr1=new PurchaseRequest(45000,10001,"购买商品1");
        Zhang.processRequest(pr1);
        PurchaseRequest pr2=new PurchaseRequest(60000,10002,"购买商品2");
        Zhang.processRequest(pr2);
        PurchaseRequest pr3=new PurchaseRequest(160000,10003,"购买商品3");
        Zhang.processRequest(pr3);
        PurchaseRequest pr4=new PurchaseRequest(800000,10004,"购买商品4");
        Zhang.processRequest(pr4);
    }
}

🎯 c++ 版本

#include <iostream>
#include <string>
using namespace std;

class PurchaseRequest {
private:
    double amount; // 采购金额
    int number; // 采购单编号
    string purpose; // 采购目的

public:
    PurchaseRequest(double amount, int number, string purpose) {
        this->amount = amount;
        this->number = number;
        this->purpose = purpose;
    }

    double getAmount() {
        return amount;
    }

    void setAmount(double amount) {
        this->amount = amount;
    }

    int getNumber() {
        return number;
    }

    void setNumber(int number) {
        this->number = number;
    }

    string getPurpose() {
        return purpose;
    }

    void setPurpose(string purpose) {
        this->purpose = purpose;
    }
};

class Approver {
protected:
    Approver* successor; //定义后继对象
    string name;

public:
    Approver(string name) {
        this->name = name;
    }

    // 设置后继者
    void setSuccessor(Approver* successor) {
        this->successor = successor;
    }

    // 抽象请求处理方法
    virtual void processRequest(PurchaseRequest* request) = 0;
};

class Director :Approver {
public:
    Director(string name) :Approver(name) {     }
    void processRequest(PurchaseRequest* request) {
        if (request->getAmount() < 50000) { //处理请求
            cout << "主任" << this->name + "审批采购单：" << request->getNumber() + ",金额" << request->getAmount() << "元，采购目的" << request->getPurpose() << "." << endl;
        }
        else {
            this->successor->processRequest(request);
        }
    }
};

class VicePresident :Approver {
public:
    VicePresident(string name) :Approver(name) {     }
    void processRequest(PurchaseRequest* request) {
        if (request->getAmount() < 100000) { //处理请求
            cout << "副董事长" << this->name + "审批采购单：" << request->getNumber() + ",金额" << request->getAmount() << "元，采购目的" << request->getPurpose() << "." << endl;
        }
        else {
            this->successor->processRequest(request);
        }
    }
};

class President :Approver {
public:
    President(string name) :Approver(name) {     }
    void processRequest(PurchaseRequest* request) {
        if (request->getAmount() < 500000) { //处理请求
            cout << "董事长" << this->name + "审批采购单：" << request->getNumber() + ",金额" << request->getAmount() << "元，采购目的" << request->getPurpose() << "." << endl;
        }
        else {
            this->successor->processRequest(request);
        }
    }
};


class Congress :Approver {
public:
    Congress(string name) :Approver(name) {     }
    void processRequest(PurchaseRequest* request) {
        cout << "董事长" << this->name + "审批采购单：" << request->getNumber() + ",金额" << request->getAmount() << "元，采购目的" << request->getPurpose() << "." << endl;
    }
};

int main() {
    Approver* Zhang = (Approver*) new Director("张三");
    Approver* Li = (Approver*)new VicePresident("李四");
    Approver* Wang = (Approver*)new President("王五");
    Approver* Dong = (Approver*)new Congress("董六");
    // 创建职责链
    Zhang->setSuccessor(Li);
    Li->setSuccessor(Wang);
    Wang->setSuccessor(Dong);
    // 创建采购单
    PurchaseRequest* pr1 = new PurchaseRequest(45000, 10001, "购买商品1");
    Zhang->processRequest(pr1);
    PurchaseRequest* pr2 = new PurchaseRequest(60000, 10002, "购买商品2");
    Zhang->processRequest(pr2);
    PurchaseRequest* pr3 = new PurchaseRequest(160000, 10003, "购买商品3");
    Zhang->processRequest(pr3);
    PurchaseRequest* pr4 = new PurchaseRequest(800000, 10004, "购买商品4");
    Zhang->processRequest(pr4);
}

18. 解释器模式

解释器模式：定义一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
在这里插入图片描述
🎯 java版本

public abstract class AbstractNode {
    public abstract String interpret();
}
public class ActionNode extends AbstractNode{
    private String action;
    public ActionNode(String action) {
        this.action = action;
    }
    @Override
    public String interpret() {
        if(action.equalsIgnoreCase("move")){
            return "移动";
        }
        else if(action.equalsIgnoreCase("run")) {
            return "快速移动";cl
        }
        else{
            return "无效指令";
        }
    }
}
public class AndNode extends AbstractNode{
    private AbstractNode left;
    private AbstractNode right;
    public AndNode(AbstractNode left,AbstractNode right){
        this.left=left;
        this.right=right;
    }
    @Override
    public String interpret() {
        return left.interpret()+"再"+right.interpret();
    }
}
public class DirectionNode extends AbstractNode{
    private String direction;
    public DirectionNode(String direction){
        this.direction=direction;
    }
    @Override
    public String interpret() {
        if(direction.equalsIgnoreCase("up")){
            return "向上";
        }
        else if(direction.equalsIgnoreCase("down")){
            return "向下";
        }
        else if(direction.equalsIgnoreCase("left")){
            return "向左";
        }
        else if(direction.equalsIgnoreCase("right")){
            return "向右";
        }
        else{
            return "无效指令";
        }
    }
}
public class DistanceNode extends AbstractNode{
    private  String distance;
    public DistanceNode(String distance){
        this.distance=distance;
    }
    @Override
    public String interpret() {
        return this.distance;
    }
}
import java.util.*;

public class InstructionHandler {
    private AbstractNode node;
    public void handle(String instruction){
        AbstractNode left=null,right=null;
        AbstractNode direction=null,action=null,distance=null;
        Stack<AbstractNode> stack=new Stack<AbstractNode>();
        String[] words=instruction.split(" ");
        for(int i=0;i<words.length;i++){ //
            if(words[i].equalsIgnoreCase("and")){
                left=(AbstractNode)stack.pop();
                String word1=words[++i];
                direction=new DirectionNode(word1);
                String word2=words[++i];
                action=new ActionNode(word2);
                String word3=words[++i];
                distance=new DistanceNode(word3);
                right=new SentenceNode(direction,action,distance);
                stack.push(new AndNode(left,right));
            }
            else {
                String word1 = words[i];
                direction = new DirectionNode(word1);
                String word2 = words[++i];
                action = new ActionNode(word2);
                String word3 = words[++i];
                distance = new DistanceNode(word3);
                left = new SentenceNode(direction, action, distance);
                stack.push(left);
            }
        }
        this.node=(AbstractNode) stack.pop();
    }
    public String output(){
        String result=node.interpret();// 解释表达式
        return result;
    }
}
public class SentenceNode extends AbstractNode{
    private AbstractNode direction;
    private AbstractNode action;
    private AbstractNode distance;
    public SentenceNode(AbstractNode direction,AbstractNode action,AbstractNode distance){
        this.action=action;
        this.direction=direction;
        this.distance=distance;
    }
    @Override
    public String interpret() {
        return direction.interpret()+action.interpret()+distance.interpret();
    }
}
public class Client {
    public static void main(String[] args) {
        String instruction="up move 5 and down run 10 and left move 30";
        InstructionHandler handler=new InstructionHandler();
        handler.handle(instruction);
        String outString;
        outString=handler.output();
        System.out.println(outString);
    }
}

🎯 cpp版本

#include <iostream>
#include <string>
#include <stack>
#include <string.h>
#include<sstream>
#include <vector>
using namespace std;

class AbstractNode {
public:
	virtual string interpreter() = 0;
};

class ActionNode:AbstractNode {
private:
    string action;
public:
    ActionNode(string action) {
        this->action = action;
    }
    virtual string interpreter() {
        if (action=="move") {
            return "移动";
        }
        else if (action=="run") {
            return "快速移动";
        }
        else {
            return "无效指令";
        }

    }
};

class DistanceNode : AbstractNode {
private:
    string distance;
public:
    DistanceNode(string distance) {
        this->distance = distance;
    }
    virtual string interpreter() {
        return this->distance;
    }
};

class DirectionNode : AbstractNode {
private:
    string direction;
public:
    DirectionNode(string direction) {
        this->direction = direction;
    }
    virtual string interpreter() {
        if (direction == "up") {
            return "向上";
        }
        else if (direction == "down") {
            return "向下";
        }
        else if (direction == "left") {
            return "向左";
        }
        else if (direction == "right") {
            return "向右";
        }
        else {
            return "无效指令";
        }
    }
};

class AndNode :AbstractNode {
private:
    AbstractNode* left ;
    AbstractNode* right;
public:
    AndNode(AbstractNode* left, AbstractNode* right) {
        this->left = left;
        this->right = right;
    }
    virtual string interpreter() {
        return left->interpreter() + "再" + right->interpreter();
    }
};

class SentenceNode :AbstractNode {
private:
    AbstractNode* direction;
    AbstractNode* action;
    AbstractNode* distance;
public:
    SentenceNode(AbstractNode* direction, AbstractNode* action, AbstractNode* distance) {
        this->action = action;
        this->direction = direction;
        this->distance = distance;
    }
    string interpreter() {
        return direction->interpreter() + action->interpreter() + distance->interpreter();
    }
};

class InstructionHandler {
private:
    AbstractNode* node;
public:
    void handle(string instruction) {
        AbstractNode* left = NULL, * right = NULL;
        AbstractNode* direction = NULL, * action = NULL, * distance = NULL;
        stack<AbstractNode*> stack;
        istringstream stream(instruction);
        char array[20] = { 0 };
        vector<string> words;
        int length;
        while (stream.get(array, 20, ' ')) {
            length = stream.tellg();
            string temp = array;
            words.push_back(temp);
            stream.seekg(length + 1, ios::beg);
        }
        for (int i = 0; i < words.size(); i++) { //
            if (words[i]=="and") {
                left = stack.top();
                stack.pop();
                string word1 = words[++i];
                direction = (AbstractNode *) new DirectionNode(word1);
                string word2 = words[++i];
                action = (AbstractNode *) new ActionNode(word2);
                string word3 = words[++i];
                distance = (AbstractNode*)new DistanceNode(word3);
                right = (AbstractNode*) new SentenceNode(direction, action, distance);
                stack.push((AbstractNode*)new AndNode(left, right));
            }
            else {
                string word1 = words[i];
                direction = (AbstractNode*)new DirectionNode(word1);
                string word2 = words[++i];
                action = (AbstractNode*) new ActionNode(word2);
                string word3 = words[++i];
                distance = (AbstractNode*) new DistanceNode(word3);
                left = (AbstractNode*) new SentenceNode(direction, action, distance);
                stack.push(left);
            }
        }
        this->node = stack.top();
        stack.pop();
    }
    string output(){
        string result = node->interpreter();// 解释表达式
        return result;
    }
};

int main() {
    string instruction = "up move 5 and down run 10 and left move 30";
    InstructionHandler* handler = new InstructionHandler();
    handler->handle(instruction);
    string outString;
    outString = handler->output();
    cout<<outString<<endl;
}

22. 观察者模式

观察者模式：定义对象之间的一种一对多的依赖关系，每当一个对象的状态发生改变时，其相关依赖对象对象皆得到通知并被自动更新。
在这里插入图片描述 📖实例

🎯 Java 版本

public interface Observer {
    public String getName();
    public void setName(String name);
    public void help(); // 支持盟友方法
    public void beAttacked(AllyControlCenter acc); // 遭受攻击的方法
}

public class Player implements Observer{
    private String name;
    public Player(String name){
        this.name=name;
    }
    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public void setName(String name) {
        this.name=name;
    }

    @Override
    public void help() {
        System.out.println(this.name+"正在前往救援！");
    }

    @Override
    public void beAttacked(AllyControlCenter acc) {
        System.out.println(this.name+"被攻击！");
        acc.notifyObserver(name);
    }
}

import java.util.ArrayList;
import java.util.*;

public abstract class AllyControlCenter {
    protected String allyName;
    protected ArrayList<Observer> players=new ArrayList<Observer>();

    public String getAllyName() {
        return allyName;
    }

    public void setAllyName(String allyName) {
        this.allyName = allyName;
    }

    // 注册方法
    public void join(Observer obs){
        System.out.println(obs.getName()+"加入"+this.allyName+"战队！");
        players.add(obs);
    }
    //注销方法
    public void quit(Observer obs){
        System.out.println(obs.getName()+"退出"+this.allyName+"战队！");
        players.remove(obs);
    }
    // 声明抽象通知方法
    public abstract void notifyObserver(String name);
}

public class ConcreteAllyControlCenter extends AllyControlCenter{
    public ConcreteAllyControlCenter (String allyName){
        System.out.println(allyName+"战队组建成功！");
        System.out.println("-----------------------------");
        this.allyName=allyName;
    }

    @Override
    public void notifyObserver(String name) {
        System.out.println(this.allyName+"战队紧急通知：盟友"+name+"遭受敌人攻击！");
        for(Object obs:players){
            if(!((Observer)obs).getName().equalsIgnoreCase(name)){
                ((Observer)obs).help();
            }
        }
    }
}

public class Client {
    public static void main(String[] args) {
        AllyControlCenter acc;
        acc=new ConcreteAllyControlCenter("C1");
        Observer p1,p2,p3,p4;
        p1=new Player("P1");
        acc.join(p1);
        p2=new Player("P2");
        acc.join(p2);
        p3=new Player("P3");
        acc.join(p3);
        p4=new Player("P4");
        acc.join(p4);

        p1.beAttacked(acc);
    }
}

🎯 C++ 版本

#include <iostream>
#include <string>
#include <vector>
using namespace std;
class AllyControlCenter;
class Observer {
public:
    virtual string getName() = 0;
    virtual void setName(string name) = 0;
    virtual void help() = 0; // 支持盟友方法
    virtual void beAttacked(AllyControlCenter* acc) = 0; // 遭受攻击的方法
};
class AllyControlCenter {
protected:
    string allyName;
    vector<Observer*> players = vector<Observer*>();
public:
    string getAllyName() {
        return allyName;
    }

    void setAllyName(string allyName) {
        this->allyName = allyName;
    }

    // 注册方法
    void join(Observer* obs) {
        cout<< obs->getName() <<"加入" << this->allyName <<"战队！"<<endl;
        players.push_back(obs);
    }
    //注销方法
    void quit(Observer* obs) {
        cout<<obs->getName() << "退出" + this->allyName + "战队！";
    }
    // 声明抽象通知方法
    virtual void notifyObserver(string name)=0;
};



class Player : Observer {
private: string name;
public:
    Player(string name) {
        this->name = name;
    }

    virtual string getName() {
        return this->name;
    }

    virtual void setName(string name) {
        this->name = name;
    }

    virtual void help() {
        cout << this->name << "正在前往救援！" << endl;
    }

    virtual void beAttacked(AllyControlCenter* acc) {
        cout << this->name << "被攻击！" << endl;
        acc->notifyObserver(name);
    }
};

class ConcreteAllyControlCenter : AllyControlCenter {
public:
    ConcreteAllyControlCenter(string allyName) {
        cout << allyName << "战队组建成功！" << endl;
        cout << "-----------------------------" << endl;
        this->allyName = allyName;
    }
    void notifyObserver(string name) {
        cout << this->allyName + "战队紧急通知：盟友" + name + "遭受敌人攻击！" << endl;
        for (auto obs : players) {
            if (((Observer*)obs)->getName() != name) {
                ((Observer*)obs)->help();
            }
        }
    }
};

int main() {
    AllyControlCenter* acc;
    acc = (AllyControlCenter*)new ConcreteAllyControlCenter("C1");
    Observer *p1, *p2, *p3, *p4;
    p1 = (Observer*)new Player("P1");
    acc->join(p1);
    p2 = (Observer*) new Player("P2");
    acc->join(p2);
    p3 = (Observer*) new Player("P3");
    acc->join(p3);
    p4 = (Observer*) new Player("P4");
    acc->join(p4);

    p1->beAttacked(acc);
}

23. 状态模式

在这里插入图片描述

🎯 java版本

public class Account {
    private AccountState state;
    private String owner;
    private double balance=0;

    public Account(String owner,double init){
        this.owner=owner;
        this.balance= init;
        this.state=new NormalState(this);
        System.out.println(this.owner+"开户，初始金额为"+init);
        System.out.println("----------------------------------------------");
    }
    public double getBalance(){
        return  this.balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public void setState(AccountState state) {
        this.state = state;
    }

    public void deposit(double amount){
        System.out.println(this.owner+"存款"+amount);
        state.deposit(amount);
        System.out.println("现在账户余额为"+this.balance);
        System.out.println("现在账户的状态为"+this.state.getClass().getName());
        System.out.println("-----------------------------------------------");
    }

    public void withdraw(double amount){
        System.out.println(this.owner+"取款"+amount);
        state.withdraw(amount);
        System.out.println("现在账户余额为"+this.balance);
        System.out.println("现在账户的状态为"+this.state.getClass().getName());
        System.out.println("-----------------------------------------------");
    }

    public void computeInterest(){
        state.computeInterest();
    }
}

public abstract class AccountState {
    protected Account acc;
    public abstract void deposit(double amount);
    public abstract void withdraw(double amount);
    public abstract void computeInterest();
    public abstract void stateCheck();
}

public class NormalState extends AccountState{
    public NormalState(Account acc){
        this.acc=acc;
    }
    public NormalState(AccountState state){
        this.acc=state.acc;
    }

    @Override
    public void deposit(double amount) {
        acc.setBalance(acc.getBalance()+amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        acc.setBalance(acc.getBalance()-amount);
        stateCheck();
    }

    @Override
    public void computeInterest() {
        System.out.println("正常状态，无需支付利息！");
    }

    @Override
    public void stateCheck() {
        if(acc.getBalance()>-2000 &&acc.getBalance()<=0){
            acc.setState(new OverdraftState(this));
        }else if(acc.getBalance()==-2000){
            acc.setState(new RestrictedState(this));
        }else if(acc.getBalance()<-2000){
            System.out.println("操作受限！");
        }
    }
}

public class OverdraftState extends AccountState{
    public OverdraftState(AccountState state){
        this.acc=state.acc;
    }

    @Override
    public void deposit(double amount) {
        acc.setBalance(acc.getBalance()+amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        acc.setBalance(acc.getBalance()-amount);
        stateCheck();
    }

    @Override
    public void computeInterest() {
        System.out.println("计算利息！");
    }

    @Override
    public void stateCheck() {
        if(acc.getBalance()>0){
            acc.setState(new NormalState(this));
        }
        else if(acc.getBalance()==-2000){
            acc.setState(new RestrictedState(this));
        }
        else if(acc.getBalance()<-2000){
            System.out.println("操作受限");
        }
    }
}

public class RestrictedState extends AccountState{
    public RestrictedState(AccountState state){
        this.acc=state.acc;
    }
    @Override
    public void deposit(double amount) {
        acc.setBalance(acc.getBalance()+amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        System.out.println("账号受限，取款失败");
    }

    @Override
    public void computeInterest() {
        System.out.println("计算利息！");
    }

    @Override
    public void stateCheck() {
        if(acc.getBalance()>0){
            acc.setState(new NormalState(this));
        }
        else if(acc.getBalance()>-2000){
            acc.setState(new OverdraftState(this));
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Account acc=new Account("张三",0.0);
        acc.deposit(1000);
        acc.withdraw(2000);
        acc.deposit(3000);
        acc.deposit(1000);
        acc.withdraw(4000);
        acc.withdraw(1000);
        acc.computeInterest();
    }
}

🎯 c++版本

#include <iostream>
#include <string>
#include <typeinfo>
using namespace std;
class Account;
class NormalState;
class NormalState;
class RestrictedState;

class AccountState {
public:
    string name;
    Account* acc;
    virtual void deposit(double amount)=0;
    virtual void withdraw(double amount)=0;
    virtual void computeInterest()=0;
    virtual void stateCheck()=0;
};


class Account {
private:
    AccountState* state;
    string owner;
    double balance = 0;

public:
    Account(string owner, double init);
    double getBalance() {
        return  this->balance;
    }

    void setBalance(double balance) {
        this->balance = balance;
    }

    void setState(AccountState* state) {
        this->state = state;
    }

    void deposit(double amount) {
        cout << this->owner << "存款" << amount << endl;
        state->deposit(amount);
        cout << "现在账户余额为" << this->balance << endl;
        cout << "现在账户的状态为 " << state->name << endl;
        cout << "-----------------------------------------------" << endl;
    }

    void withdraw(double amount) {
        cout << this->owner << "存款" << amount << endl;
        state->withdraw(amount);
        cout << "现在账户余额为" << this->balance << endl;
        cout << "现在账户的状态为 " << state->name << endl;
        cout << "-----------------------------------------------" << endl;
    }

    void computeInterest() {
        state->computeInterest();
    }
};
class NormalState : AccountState {
public:
    NormalState(Account* acc) {
        this->acc = acc;
        this->name = "Normalstate";
    }

    NormalState(AccountState* state) {
        this->acc = state->acc;
        this->name = "Normalstate";
    }

    void deposit(double amount) {
        acc->setBalance(acc->getBalance() + amount);
        stateCheck();
    }

    void withdraw(double amount) {
        acc->setBalance(acc->getBalance() - amount);
        stateCheck();
    }

    void computeInterest() {
        cout << "正常状态，无需支付利息！" << endl;
    }

    void stateCheck();
};
class OverdraftState :AccountState {
public:
    OverdraftState(AccountState* state) {
        this->acc = state->acc;
        this->name = "OverdraftState";
    }

    void deposit(double amount) {
        acc->setBalance(acc->getBalance() + amount);
        stateCheck();
    }
    void withdraw(double amount) {
        acc->setBalance(acc->getBalance() - amount);
        stateCheck();
    }
    void computeInterest() {
        cout << "计算利息！" << endl;
    }

    void stateCheck();
};
class RestrictedState : AccountState {
public:
    RestrictedState(AccountState* state) {
        this->acc = state->acc;
        this->name = "RestrictedState";
    }
    void deposit(double amount) {
        acc->setBalance(acc->getBalance() + amount);
        stateCheck();
    }
    void withdraw(double amount) {
        cout << "账号受限，取款失败" << endl;
    }
    void computeInterest() {
        cout << "计算利息！" << endl;
    }

    void stateCheck() {
        if (acc->getBalance() > 0) {
            acc->setState((AccountState*)new NormalState(this));
        }
        else if (acc->getBalance() > -2000) {
            acc->setState((AccountState*)new OverdraftState(this));
        }
    }
};

Account::Account(string owner, double init) {
    this->owner = owner;
    this->balance = init;
    this->state = (AccountState*) new NormalState(this);
    cout << this->owner << "开户，初始金额为" << init << endl;
    cout << "----------------------------------------------" << endl;
}
void NormalState:: stateCheck() {
    if (acc->getBalance() > -2000 && acc->getBalance() <= 0) {
        acc->setState((AccountState*)new OverdraftState(this));
    }
    else if (acc->getBalance() == -2000) {
        acc->setState((AccountState*)new RestrictedState(this));
    }
    else if (acc->getBalance() < -2000) {
        cout << "操作受限！" << endl;
    }
}

void OverdraftState::stateCheck() {
    if (acc->getBalance() > 0) {
        acc->setState((AccountState*)new NormalState(this));
    }
    else if (acc->getBalance() == -2000) {
        acc->setState((AccountState*)new RestrictedState(this));
    }
    else if (acc->getBalance() < -2000) {
        cout << "操作受限" << endl;
    }
}

int main() {
    Account* acc = new Account("张三", 0.0);
    acc->deposit(1000);
    acc->withdraw(2000);
    acc->deposit(3000);
    acc->deposit(1000);
    acc->withdraw(4000);
    acc->withdraw(1000);
    acc->computeInterest();
}