软件设计师中级下午java题

转载

技术博客达人 2024-10-04 10:38:42

文章标签 软件设计师中级下午java题 java 开发语言软件工程 ide 文章分类 Java 后端开发

[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收到消息
    }
}
 
 
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。