软考常考模式代码

最新推荐文章于 2024-08-13 16:16:10 发布

这种幸福很生活

最新推荐文章于 2024-08-13 16:16:10 发布

阅读量122

点赞数 4

分类专栏：软考设计模式代码文章标签：设计模式 java 开发语言

本文链接：https://blog.csdn.net/qq_54429126/article/details/133953267

版权

软考同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

设计模式代码

1 篇文章 0 订阅

订阅专栏

1 抽象工厂模式

抽象工厂模式：代码
package AbstractFactory;

public class AbstractFactory {
    public static void main(String[] args) {
        Factory factory1 = new Factory1();
        ProductA proctudA = factory1.createProductA();
        proctudA.info();

        Factory factory2 = new Factory2();
        ProductB proctudB = factory2.createProductB();
        proctudB.info();
    }
}

interface Factory{

    public ProductA createProductA();
    public ProductB createProductB();

}

class Factory1 implements Factory{

    @Override
    public ProductA createProductA(){
        return new ProductA1();
    }
    @Override
    public ProductB createProductB(){
        return new ProductB1();
    }
}
class Factory2 implements Factory{

    @Override
    public ProductA createProductA(){
        return new ProductA2();
    }
    @Override
    public ProductB createProductB(){
        return new ProductB2();
    }
}

interface ProductA{
    public void info();
}
class ProductA1 implements ProductA{
    @Override
    public void info(){
        System.out.println("我是产品A1");
    }

}

class ProductA2 implements ProductA{
    @Override
    public void info(){
        System.out.println("我是产品A2");
    }

}

interface ProductB{
    public void info();
}
class ProductB1 implements ProductB{
    @Override
    public void info(){
        System.out.println("我是产品B1");
    }

}

class ProductB2 implements ProductB{
    @Override
    public void info(){
        System.out.println("我是产品B2");
    }

}

2 生成器模式：代码

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Director director = new Director();

        Builder builder1 = new Builder1();
        director.Construct(builder1);
        Product product = builder1.getResult();
        product.show();

        Builder builder2 = new Builder2();
        director.Construct(builder2);
        Product product2 = builder2.getResult();
        product2.show();
    }
}

class Director {
    public void Construct(Builder builder) {
        builder.BuildPart();
    }
}

abstract class Builder {
    public abstract void BuildPart();

    public abstract Product getResult();
}

class Builder1 extends Builder {
    Product product = new Product();

    @Override
    public void BuildPart() {
        product.Add("a");
        product.Add("b");
        product.Add("c");
        product.Add("d");
        product.Add("e");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

class Builder2 extends Builder {
    Product product = new Product();

    @Override
    public void BuildPart() {
        product.Add("a");
        product.Add("b");

    }

    @Override
    public Product getResult() {
        return product;
    }
}

class Product {
    List<String> parts = new ArrayList<String>();

    public void Add(String part) {
        parts.add(part);
    }

    public void show() {
        System.out.print("产品的组成:");
        for (String s : parts)
            System.out.print(s + " ");
        System.out.println("\n");
    }
}

3 原型模式代码：

public class Main {
    public static void main(String[] args) {
        Product product1 = new Product(2023,11.4);
        System.out.println(product1.getId() + " " + product1.getPrice());
        Product product2 = (Product) product1.Clone();
        System.out.println(product2.getId() + " " + product2.getPrice());
    }
}

interface Prototype{
    public Object Clone();
}
class Product implements Prototype{
    private int id;
    private double price;

    public Product() {
    }

    public int getId() {
        return id;
    }

    public double getPrice() {
        return price;
    }

    public Product(int id, double price) {
        this.id = id;
        this.price = price;
    }

    @Override
    public Object Clone(){
        Product object = new Product();
        object.id = this.id;
        object.price = this.price;
        return object;
    }
}

4 单例模式代码：

public class SingletonPattern {
    public static void main(String[] args) {
        //Singleton singleton1 = new Singleton();
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();//其实是同一个单例
        System.out.println(singleton.getNumber()+ " "+ singleton2.getNumber());
        singleton2.setNumber(36);
        System.out.println(singleton.getNumber()+ " "+ singleton2.getNumber());
        //更改的其实只是一个单例，singleton1 = singleton2 同一个单例
    }
}
class Singleton{
    private int number = 2023;

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

    public int getNumber() {
        return number;
    }

    private static Singleton instance = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){//全局访问点
        return instance;
    }
}

5 适配器模式代码：

public class ApadterPatter {
    public static void main(String[] args) {
        USB usb1 = new USB();
        usb1.Request();//使用适配器前
        USB usb = new Apadter();
        usb.Request();//使用适配器后
    }
}
class USB{
    public void Request(){
        System.out.println("USB数据线");
    }
}
class Apadter extends USB{
    private TypeC typeC =new TypeC();
    @Override
    public void Request(){
        typeC.SpecificRequest();
    }
}
class TypeC{
    public void SpecificRequest(){
        System.out.println("Type-C数据线");
    }
}

6 桥接模式代码：

public class BridgePatter {
    public static void main(String[] args) {
        Product productA = new ProductA();
        Product productA2 = new ProductA();
        Color red = new Red();
        Blue blue = new Blue();

        productA.setName("产品A");
        productA.setColor(red);
        productA.Operation();

        productA2.setName("产品A2");
        productA2.setColor(blue);
        productA2.Operation();
    }
}

abstract class Product {
    private String name;
    protected Color color;

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

    public String getName() {
        return name;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public abstract void Operation();
}

class ProductA extends Product {
    @Override
    public void Operation() {
        color.OperationImp(this.getName());
    }
}

interface Color {
    public void OperationImp(String name);
}

class Red implements Color {
    @Override
    public void OperationImp(String name) {
        System.out.println(name + " 红色");
    }
}

class Blue implements Color {
    @Override
    public void OperationImp(String name) {
        System.out.println(name + " 蓝色");
    }
}

7 组合模式代码：

import java.util.*;

public class CompositePatter {
    public static void main(String[] args) {
        AbstractFile root = new Folder("root");
        AbstractFile folderA = new Folder("folderA");
        folderA.printName();

        AbstractFile fileB = new Folder("fileB");
        fileB.printName();//显示名字
        System.out.println(root.Add(fileB));//添加成功
        System.out.println(root.Add(folderA));//添加成功

        // System.out.println(root.Remove(fileB));//删除成功
        // System.out.println(root.Remove(fileB));//删除失败
        AbstractFile fileC = new Folder("fileC");
        AbstractFile fileD = new Folder("fileD");
        AbstractFile fileF = new Folder("fileF");
        System.out.println(root.Add(fileC));
        System.out.println(folderA.Add(fileD));
        System.out.println(folderA.Add(fileF));
        print(root);
        //遍历组合模式中的所有文件夹的方法在主方法外面

    }
    static void print(AbstractFile file){
        file.printName();

        List<AbstractFile>childrenList = file.getChildren();
        if(childrenList == null)
            return;
        for (AbstractFile children:childrenList)
            print(children);
    }
}

abstract class AbstractFile {
    protected String name;

    public void printName() {
        System.out.println(name);
    }

    public abstract boolean Add(AbstractFile file);

    public abstract boolean Remove(AbstractFile file);

    public abstract List<AbstractFile> getChildren();
}

class Folder extends AbstractFile {
    List<AbstractFile> childrenList = new ArrayList<AbstractFile>();

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

    @Override
    public boolean Add(AbstractFile file) {
        return childrenList.add(file);
    }

    @Override
    public boolean Remove(AbstractFile file) {
        return childrenList.remove(file);
    }

    @Override
    public List<AbstractFile> getChildren() {
        return childrenList;
    }
}

class File extends AbstractFile {
    public File(String name) {
        this.name = name;
    }

    @Override
    public boolean Add(AbstractFile file) {
        return false;
    }

    @Override
    public boolean Remove(AbstractFile file) {
        return false;
    }

    @Override
    public List<AbstractFile> getChildren() {
        return null;
    }
}

8 装饰器模式代码：

public class DecoratorPattern {
    public static void main(String[] args) {
        Person zhangsan = new Student("张三");
        zhangsan.Operation();
        System.out.println("-----我是分割线—————");
        zhangsan = new DecoratorA(zhangsan);
        zhangsan.Operation();
        System.out.println("-----我是分割线—————");
        zhangsan = new DecoratorB(zhangsan);
        zhangsan.Operation();
//对象链方式也可以
    }
}
abstract class Person{
    protected String name;
    public abstract void Operation();
}
class Student extends Person{
    public Student(String name){
        this.name = name;
    }
    @Override
    public void Operation(){
        System.out.println(name + "的职责 ： 学习");
    }
}
abstract class Decorator extends Person{
    protected Person person;
}
class DecoratorA extends Decorator{
    public DecoratorA(Person person){
        this.person = person;
    }
    @Override
    public void Operation(){
        person.Operation();//原来的职责
        System.out.println("写作业");
    }
}
class DecoratorB extends Decorator{
    public DecoratorB(Person person){
        this.person = person;
    }
    @Override
    public void Operation(){
        person.Operation();//原来的职责
        System.out.println("做家务");
    }
}

9 外观模式代码：

public class FacadePattern {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.methodA();
        facade.methodB();
        facade.methodC();

    }
}

class Facade {
    SubSystemone subSystemone;
    SubSystemtwo subSystemtwo;
    SubSystemthree subSystemthree;

    public Facade() {
        subSystemone = new SubSystemone();
        subSystemtwo = new SubSystemtwo();
        subSystemthree = new SubSystemthree();
    }

    public void methodA() {
        subSystemone.methodone();
    }

    public void methodB() {
        subSystemtwo.methodtwo();
    }

    public void methodC() {
        subSystemthree.methodthree();
    }
}

class SubSystemone {
    public void methodone() {
        System.out.println("第一个子系统");
    }
}

class SubSystemtwo {
    public void methodtwo() {
        System.out.println("第二个子系统");
    }
}

class SubSystemthree {
    public void methodthree() {
        System.out.println("第三个子系统");
    }
}

10 享元模式代码：

public class FlyweightPattern {
    public static void main(String[] args) {
        PieceFactory factory = new PieceFactory();

        Piece whitePiece1 = factory.getPiece(0);
        Piece blackPiece2 = factory.getPiece(1);
        whitePiece1.draw(2023,114);
        blackPiece2.draw(2023,528);
    }
}
class PieceFactory{
    private Piece[] pieces ={new WhitePiece(),new BlackPiece()};

    public Piece getPiece(int key){
        if (key==0)return pieces[0];
        else return pieces[1];
    }
}
abstract class Piece{
    protected String color;
    public abstract void draw(int x,int y);
}
class WhitePiece extends Piece{
    public WhitePiece(){
        this.color = "white";
    }
    @Override
    public void draw(int x,int y){
        System.out.println("draw a piece" + color + " piece x:"+ x +"  piece Y:" +y );
    }
}
class BlackPiece extends Piece{
    public BlackPiece(){
        this.color = "black";
    }
    @Override
    public void draw(int x,int y){
        System.out.println("draw a piece" + color + " piece x:"+ x +"  piece Y:" +y );
    }
}

//享元模式代码二：用map函数完成
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class FlyweightPattern {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();
        Random random = new Random();

        String[] colors = {"red", "blue", "green", "wilte", "black"};
        for (int i = 1;i<=10;i++){
            int x = random.nextInt(colors.length);
            Shape shape = factory.getShape(colors[x]);
            System.out.println("第"+i+"个圆");
            shape.draw(random.nextInt(2023),random.nextInt(114));
        }

    }


}

class ShapeFactory {
    private Map<String, Shape> map = new HashMap<String, Shape>();

    public Shape getShape(String key) {
        if (!map.containsKey(key)) {
            map.put(key, new Circle(key));
            System.out.println("create color: " + key + "circle");
        }
        return map.get(key);
    }
}

abstract class Shape {
    protected String color;

    public abstract void draw(int x, int y);
}

class Circle extends Shape {
    public Circle(String color) {
        this.color = color;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("draw a color: " + color + " circle X" + x + " circle Y:" + y);
    }
}

11 命令模式代码：

public class CommanPattern {
    public static void main(String[] args) {
        TV tv = new TV();
        Command onCommand = new OnCommand(tv);
        Command offCommand = new OffCommand(tv);
        Invoker invoker = new Invoker();

        invoker.setCommand(onCommand);
        invoker.call();

        System.out.println("----------------");
        
        invoker.setCommand(offCommand);
        invoker.call();

    }
}

class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void call() {
        command.execule();
    }
}

interface Command {
    public void execule();
}

class OnCommand implements Command {//开机命令
    private TV tv;

    public OnCommand(TV tv) {
        this.tv = tv;
    }

    @Override
    public void execule() {
        tv.OnCommand();
    }
}

class OffCommand implements Command {//关机命令
    private TV tv;

    public OffCommand(TV tv) {
        this.tv = tv;
    }

    @Override
    public void execule() {
        tv.OffCommand();
    }
}

class TV {//接收者

    public void OnCommand() {
        System.out.println("开机命令");
    }

    public void OffCommand() {
        System.out.println("关机命令");
    }
}

12 观察者模式代码：

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

public class ObserverPattern {
    public static void main(String[] args) {
        Subject subjectA = new ConcreteSubject("目标A");

        Observer observerB = new ConcreteObserve("张三", subjectA);
        Observer observerC = new ConcreteObserve("李四", subjectA);
        Observer observerD = new ConcreteObserve("王五", subjectA);
        System.out.println("目标的状态发生改变");
        subjectA.setState("更新了");
        subjectA.getState();
        System.out.println("====================");
        subjectA.Detach(observerD);
        subjectA.setState("停更了");
        subjectA.getState();


    }
}

interface Subject {
    public void Attach(Observer observer);

    public void Detach(Observer observer);

    public void Notify();


    public void setState(String state);
    public String getState();
}

class ConcreteSubject implements Subject {

    private String name;
    private String state;

    private List<Observer> observerlist;

    public ConcreteSubject(String name){
        state ="未更新";
        this.name = name;
        observerlist = new ArrayList<Observer>();
    }

    public void setState(String state){
        this.state =state;
        System.out.println(name+"的状态发生改变,变化后的状态为："+state);
        Notify();
    }
    public String getState(){
        return state;
    }

    public void Attach(Observer observer) {
        observerlist.add(observer);
    }

    public void Detach(Observer observer) {
        observerlist.remove(observer);
    }

    public void Notify() {
        //fot（遍历对象类型 遍历对象名：遍历对象）
        for (Observer observer : observerlist) {
            observer.update();
        }
    }
}

interface Observer {
    public void update();
}

class ConcreteObserve implements Observer {
    private Subject subject;
    private String name;
    private String state;

    public ConcreteObserve(String name, Subject subject) {
        this.name = name;
        this.subject = subject;
        subject.Attach(this);
        state = subject.getState();
    }

    @Override
    public void update() {
        System.out.println(name + "收到通知");
        state = subject.getState();

        System.out.println(name + "改变后的状态为："+state);
    }
}

13 状态模式代码：

public class StatePattern {
    public static void main(String[] args) {
        Context context = new Context();
        System.out.println(context.getState());//当前为状态A
        context.Request();
        context.Request();
        context.Request();
        System.out.println(context.getState());//当前状态为B
        context.Request();//补货成功,再买一个
        System.out.println(context.getState());//当前状态为A
        context.Request();
        System.out.println(context.getCount());//剩余四个

    }
}

class Context {//贩卖机
    private int count;

    private State state;

    public Context() {
        count = 3;
        state = new StateA();
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getCount() {
        return count;
    }

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

    public State getState() {
        return state;
    }

    public void Request() {//买一个饮料
        state.Handle(this);
    }
}

interface State {
    public void Handle(Context context);
}

class StateA implements State {//有货

    @Override
    public void Handle(Context context) {
        int count = context.getCount();
        if (count >= 1) {
            System.out.println("购买成功！");
            context.setCount(count - 1);
            if (context.getCount() == 0) {
                context.setState(new StateB());//转移状态B
            }
        } else {
            System.out.println("购买失败！");
        }
    }
}

class StateB implements State {//无货

    @Override
    public void Handle(Context context) {
        int count = context.getCount();

        if (count == 0) {
            System.out.println("购买失败！等待补货。");

            context.setCount(5);
            System.out.println("补货成功！请重新购买");
            context.setState(new StateA());//转移状态A
        }

    }
}

14 策略模式代码：

public class StrategyPattern {
    public static void main(String[] args) {
        Strategy add = new AddStrategy();
        Strategy subtraction = new SubtractionStrategy();
        Strategy multiply = new MultiplyStrategy();
        OperationContext context = new OperationContext(add);
        context.Operation(2023,1104);
        context = new OperationContext(subtraction);
        context.Operation(2023,1104);
        context = new OperationContext(multiply);
        context.Operation(2023,1104);
        
    }
}
class OperationContext{
    private Strategy strategy;

    public OperationContext(Strategy strategy){
        this.strategy = strategy;
    }
    public void Operation(int a,int b){
        strategy.TwoNumberOpeation(a,b);
    }
}
interface Strategy{
    public void TwoNumberOpeation(int a,int b);
}
class AddStrategy implements Strategy{
    @Override
    public void TwoNumberOpeation(int a,int b){
        System.out.println(a+b);
    }
}
class SubtractionStrategy implements Strategy{
    @Override
    public void TwoNumberOpeation(int a,int b){
        System.out.println(a-b);
    }
}class MultiplyStrategy implements Strategy{
    @Override
    public void TwoNumberOpeation(int a,int b){
        System.out.println(a*b);
    }
}

15 访问者模式代码

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

public class VistorPattern {
    public static void main(String[] args) {
        PresonStructure structure = new PresonStructure();
        Vistor vistor1 = new Vistor1();
        Vistor vistor2 = new Vistor2();

        System.out.println("=====访问者1访问记录===");
        structure.Accept(vistor1);
        System.out.println("学生的年龄总和："+((Vistor1) vistor1).getStudentAgeSum()+" 老师的年龄总和："+((Vistor1) vistor1).getTecaherAgeSum());

        System.out.println("=====访问者2访问记录==");
        structure.Accept(vistor2);
        System.out.println("学生的最高成绩： "+((Vistor2) vistor2).getMaxScore()+" 老师的最大工龄"+((Vistor2) vistor2).getMaxWorkYear());
    }
}

interface Vistor {
    public void visitStudent(Student student);

    public void visitTeacher(Teacher teacher);
}

class Vistor1 implements Vistor {//访问者1分别统计学生和老师的年龄总和
    private int studentAgeSum = 0;
    private int tecaherAgeSum = 0;

    public int getStudentAgeSum() {
        return studentAgeSum;
    }

    public int getTecaherAgeSum() {
        return tecaherAgeSum;
    }

    @Override
    public void visitStudent(Student student) {
        System.out.println("访问者1访问学生：" + student.getName() + "年龄" + student.getAge());
        studentAgeSum += student.getAge();
    }

    @Override
    public void visitTeacher(Teacher teacher) {
        System.out.println("访问者1访问老师：" + teacher.getName() + " 年龄" + teacher.getAge());
        tecaherAgeSum += teacher.getAge();
    }
}

class Vistor2 implements Vistor {//访问者2
    private int maxScore = -1;
    private int maxWorkYera = -1;

    public int getMaxScore() {
        return maxScore;
    }

    public int getMaxWorkYear() {
        return maxWorkYera;
    }

    @Override
    public void visitStudent(Student student) {
        System.out.println("访问者2访问学生：" + student.getName() + "成绩：" + student.getScore());
        maxScore = Math.max(maxScore, student.getScore());
    }

    @Override
    public void visitTeacher(Teacher teacher) {
        System.out.println("访问者2访问老师：" + teacher.getName() + "工龄:" + teacher.getWorkYear());
        maxWorkYera = Math.max(maxWorkYera, teacher.getWorkYear());
    }
}

class PresonStructure {
    private List<Person> personList = new ArrayList<Person>();

    public PresonStructure() {
        personList.add(new Student("张三", 20, 80));
        personList.add(new Student("李四", 22, 70));
        personList.add(new Student("王五", 21, 90));

        personList.add(new Teacher("刘老师", 26, 3));
        personList.add(new Teacher("王老师", 27, 4));
        personList.add(new Teacher("李老师", 28, 5));
    }

    public void Accept(Vistor vistor) {
        for (Person person : personList) {
            person.Accept(vistor);
        }
    }
}

abstract class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public abstract void Accept(Vistor vistor);
}

class Student extends Person {
    private int score;

    public Student(String name, int age, int score) {
        super(name, age);
        this.score = score;
    }

    public int getScore() {
        return score;
    }

    @Override
    public void Accept(Vistor vistor) {
        vistor.visitStudent(this);
    }
}

class Teacher extends Person {
    private int workYear;

    public Teacher(String name, int age, int workYear) {
        super(name, age);
        this.workYear = workYear;
    }

    public int getWorkYear() {
        return workYear;
    }

    @Override
    public void Accept(Vistor vistor) {
        vistor.visitTeacher(this);
    }
}

16 中介者模式代码：

public class MediatorPattern {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        Colleague1 colleague1 = new Colleague1(mediator);
        Colleague2 colleague2 = new Colleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.sendMessage("软考加油");
        colleague2.sendMessage("考试顺利");
    }
}

abstract class Colleague {
    protected Mediator mediator;
}

class Colleague1 extends Colleague {
    public Colleague1(Mediator mediator) {
        this.mediator = mediator;
    }

    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

    public void Notify(String message) {
        System.out.println("同事1收到消息" + message);
    }
}

class Colleague2 extends Colleague {
    public Colleague2(Mediator mediator) {
        this.mediator = mediator;
    }

    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

    public void Notify(String message) {
        System.out.println("同事2收到消息" + message);
    }
}

abstract class Mediator {
    public abstract void sendMessage(String message, Colleague colleague);
}

class ConcreteMediator extends Mediator {
    private Colleague1 colleague1;
    private Colleague2 colleague2;

    public void setColleague1(Colleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(Colleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    public void sendMessage(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.Notify(message);
        } else {
            colleague1.Notify(message);
        }
    }

}