中级软件设计师下午题：试题六

最新推荐文章于 2024-10-02 18:16:11 发布

BeckyWan_

最新推荐文章于 2024-10-02 18:16:11 发布

阅读量282

点赞数 1

分类专栏：软考文章标签： java 开发语言软件工程

本文链接：https://blog.csdn.net/BeckyWan_/article/details/132316670

版权

软考专栏收录该内容

7 篇文章 26 订阅

订阅专栏

[1.抽象工厂]

代码：

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

    Factory factory2 = new Factory2();

    ProductB productB = factory2.createProductB();
    productB.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(); }

[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 product1 = builder1.getResult();
    product1.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");
    product.Add("F");
}

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

class Builder2 extends Builder { Product product = new Product();
@Override
public void BuildPart() {
    product.Add("A");
    product.Add("B");
    product.Add("C");
}

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

class Product { List parts = new ArrayList();
public void Add(String part) {
    parts.add(part);
}

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

    System.out.print("\n");
}
}

[3.原型模式]

代码：

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

    Product product3 = (Product) product1.Clone();
    System.out.println(product3.getId() + " " + product3.getPrice());
}
}

interface Prototype { public Object Clone(); }

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

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

public int getId() {
    return id;
}

public double getPrice() {
    return price;
}

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

    return object;
}
}

[4.适配器]

代码：

public class AdapterPattern { public static void main(String[] args) { USB usb = new Adapter(); usb.Request(); } }

class USB { public void Request() { System.out.println("USB数据线"); } }

class Adapter extends USB { private TypeC typeC = new TypeC();
@Override
public void Request() {
    typeC.SpecificRequest();
}
}

class TypeC { public void SpecificRequest() { System.out.println("Type-C数据线"); } }

[5.桥接模式]

代码：

public class BridgePattern { public static void main(String[] args) { Product productA1 = new ProductA(); Product productA2 = new ProductA(); Color red = new Red();
    productA1.setName("产品A1");
    productA1.setColor(red);
    productA1.Operation();


    Blue blue = new Blue();
    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 + "：蓝色");
}
}

[6.组合]

代码：

import java.util.*;

public class CompositePattern { public static void main(String[] args) { // 父类名对象名 = new 子类名(); AbstractFile root = new Folder("root");

    AbstractFile folderA = new Folder("folderA");
    AbstractFile folderB = new Folder("folderB");

    AbstractFile fileC = new File("fileC");
    AbstractFile fileD = new File("fileD");
    AbstractFile fileE = new File("fileE");

    root.Add(folderA);
    root.Add(folderB);
    root.Add(fileC);

    folderA.Add(fileD);
    folderA.Add(fileE);

    print(root);
}

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

    List<AbstractFile> childrenList = file.getChildren();
    if (childrenList == null) return;

    // for (对象类型 对象名 : 遍历对象)
    for (AbstractFile children : childrenList) {
        // children.printName();
        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 { private List childrenList = new ArrayList();

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;
}

}

[7.装饰器]

public class DecoratorPattern { public static void main(String[] args) { Person zhangsan = new Student("张三"); zhangsan = new DecoratorA(zhangsan); zhangsan = new DecoratorB(zhangsan); zhangsan.Operation();
    System.out.println("\n=====我是分割线=====");

    // 对象链
    Person lisi = new DecoratorB(new DecoratorA(new Student("李四")));
}
}

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.print("写作业 ");
}
}

class DecoratorB extends Decorator { public DecoratorB(Person person) { this.person = person; }
@Override
public void Operation() { // 职责
    person.Operation(); // 原本的职责
    System.out.print("考试 ");
}
}

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.print(name + "的职责：学习 ");
}
}

[8.享元模式]

代码：

import java.util.*;

public class FlyWeightPattern { public static void main(String[] args) { ShapeFactory factory = new ShapeFactory();
    Random random = new Random();
    String[] colors = {"red", "blue", "green", "white", "black"};

    for (int i = 1; i <= 100; i ++ ) {
        int x = random.nextInt(colors.length); // [0 ~ 4]
        Shape shape = factory.getShape(colors[x]);

        System.out.print("第" + i + "个圆：");
        shape.draw(random.nextInt(2022), random.nextInt(528));
    }
}
}

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 + " y：" + y);
}
}

[9.命令模式]

代码：

public class CommandPattern { 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.Execute();
}
}

interface Command { // 命令接口 public void Execute(); // 执行命令 }

class OnCommand implements Command { // 开机命令 private Tv tv;
public OnCommand(Tv tv) {
    this.tv = tv;
}

@Override
public void Execute() {
    tv.OnAction();
}
}

class OffCommand implements Command { // 关机命令 private Tv tv;
public OffCommand(Tv tv) {
    this.tv = tv;
}

@Override
public void Execute() {
    tv.OffAction();
}
}

class Tv { // 接收者电视机 public void OnAction() { // 开机行为 System.out.println("电视机开机了..."); }
public void OffAction() { // 关机行为
    System.out.println("电视机关机了...");
}
}

[10.观察者]

代码:

import java.util.*;

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

    Observer observerB = new ConcreteObserver("张三", subjectA);
    Observer observerC = new ConcreteObserver("李四", subjectA);
    Observer observerD = new ConcreteObserver("王五", subjectA);

    subjectA.setState("更新了");

    System.out.println("======================================");

    subjectA.Detach(observerD);

    subjectA.setState("停更了");
}

}

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() {
    // for (遍历对象类型 对象名 : 遍历对象)
    for (Observer observer : observerList) {
        observer.update();
    }
}

}

interface Observer { // 观察者接口 public void update(); // 收到通知更新观察者的状态 }

class ConcreteObserver implements Observer { private String name; private String state;

private Subject subject;

public ConcreteObserver(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);
}

}

[11.状态]

代码:

public class StatePattern { public static void main(String[] args) { Context context = new Context(); // count：3

    System.out.println(context.getState());

    context.Request(); // 购买一个饮料 count = 2
    context.Request(); // 购买一个饮料 count = 1
    context.Request(); // 购买一个饮料 count = 0

    System.out.println(context.getState());

    context.Request(); // 无货 等待补货 补货成功 count = 5

    System.out.println(context.getState());

    context.Request(); // 购买一个饮料 count = 4
    System.out.println(context.getCount());

}

}

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

private State state;

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

public int getCount() {
    return count;
}

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

public State getState() {
    return state;
}

public void setState(State state) {
    this.state = 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());
        }
    } 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());
    }
}

}

[12.策略]

代码:

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(2022, 528);

    context = new OperationContext(subtraction);
    context.Operation(2022, 528);

    context = new OperationContext(multiply);
    context.Operation(2022, 528);
}
}

class OperationContext { private Strategy strategy;
public OperationContext(Strategy strategy) {
    this.strategy = strategy;
}

public void Operation(int a, int b) {
    strategy.TwoNumberOperation(a, b);
}
}

interface Strategy { public void TwoNumberOperation(int a, int b); }

class AddStrategy implements Strategy {
@Override
public void TwoNumberOperation(int a, int b) {
    System.out.println(a + b);
}
}

class SubtractionStrategy implements Strategy {
@Override
public void TwoNumberOperation(int a, int b) {
    System.out.println(a - b);
}
}

class MultiplyStrategy implements Strategy {
@Override
public void TwoNumberOperation(int a, int b) {
    System.out.println(a * b);
}
}

[13.访问者]

代码:

import java.util.*;

public class VisitorPattern { public static void main(String[] args) { PersonStructure structure = new PersonStructure();

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

    System.out.println("=========================================");

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

}

interface Visitor { public void visitStudent(Student student); // 访问学生 public void visitTeacher(Teacher teacher); // 访问老师 }

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

public int getStudentAgeSum() {
    return studentAgeSum;
}

public int getTeacherAgeSum() {
    return teacherAgeSum;
}

@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());
    teacherAgeSum += teacher.getAge();
}

}

class Visitor2 implements Visitor { // 访问者2 分别求出学生的最高成绩以及老师的最高工龄 private int maxScore = -1; private int maxWorkYear = -1;

public int getMaxScore() {
    return maxScore;
}

public int getMaxWorkYear() {
    return maxWorkYear;
}

@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());
    maxWorkYear = Math.max(maxWorkYear, teacher.getWorkYear());
}

}

class PersonStructure { private List personList = new ArrayList();

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

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

public void Accept(Visitor visitor) {
    // for (遍历对象类型 对象名 : 遍历对象)
    for (Person person : personList) {
        person.Accept(visitor);
    }
}

}

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(Visitor visitor);

}

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(Visitor visitor) {
    visitor.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(Visitor visitor) {
    visitor.visitTeacher(this);
}

}

[14.中介者模式]

代码：

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); // 让同事2收到消息
    } else {
        colleague1.Notify(message); // 让同事1收到消息
    }
}
}