软件设计师-下午题-试题6(15分)

目录

1 设计模式

1.1 简单工厂模式

1.2 工厂方法模式

1.3 抽象工厂模式

1.4 2012下半年

2 生成器模式

2.1 真题

3 原型模式

3.1 真题

4 适配器模式

4.1 真题

5 桥接模式

5.1 真题

6 组合模式

6.1 真题

7 装饰器模式

7.1 真题

8 享元模式

8.1 真题

9 命令模式

9.1 真题

10 观察者模式

10.1 真题

11 状态模式

11.1 真题

12 策略模式

12.1 真题

13 访问者模式

13.1 真题

14 访问者模式

14.1 真题

---

1 设计模式

1.1 简单工厂模式

/**
 * 简单工厂模式
 */

public class SimpleFactory {

	public static void main(String[] args){
		Product productA = Factory.createProduct(type:"A");
		productA.info();

		Product productB = Factory.createProduct(type:"B");
		productB.info();
	}
}

class Factory{

	public static Product createProduct(String type){
		Product product = null;

		switch (type){
		case "A";
			product = new ProductA();
			break;
		case "B";
			product = new ProductB();
			break;
		default:
			System.out.println("没有" + type + "类型的产品：");
			break;
		}

		return product;
	}
}

abstract class Product {
	public abstract void info();
}

class ProductA extends Product {

	@Override
	public void info() {
		System.out.println("产品的信息：A");
	}
}

class ProductB extends Product {

	@Override
	public void info(){
		System.out.println("产品的信息：B");
	}

1.2 工厂方法模式

public class SimpleFactory {
	public static void main(String[] args){
        Factory factoryA = new FactoryA();
        //父类 对象名 = new 子类();

		Product productA = FactoryA.createProduct();
		productA.info();

	    Factory factoryB = new FactoryB();

		Product productB = FactoryB.createProduct();
		productB.info();
	}
}

//class Factory
interface Factory{

	public Product createProduct();

}

class FactoryA implements Factory{

	@Override
	public Product createProduct(){
		return new ProductA();
	}
}

class FactoryB implements Factory{

	@Override
	public Product createProduct(){
		return new ProductB();
	}
}

// abstract class Product
interface Product {
	//public abstract void info();
	public  void info();
}


//class ProductA extends Product
class ProductA implements Product {

	@Override
	public void info() {
		System.out.println("产品的信息：A");
	}
}

//class ProductA extends Product
class ProductB implements Product {

	@Override
	public void info(){
		System.out.println("产品的信息：B");
	}
}

1.3 抽象工厂模式

public class AbstractFactory {
	public static void main(String[] args){
		Factory factory1 = new Factory1();

		Product productA = Factory1.createProductA();
		productA.info();

		Factory factory2 = new Factory2();

		Product productB = Factory2.createProductB();
		productB.info();
	}
}

//class Factory
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();
	}
}

// abstract class Product
interface ProductA {
	//public abstract void info();
	public  void info();
}


//class ProductA extends Product
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 ProductA extends Product
class ProductB1 implements ProductB {

	@Override
	public void info(){
		System.out.println("产品的信息：B1");
	}
}

class ProductB2 implements ProductB {

	@Override
	public void info(){
		System.out.println("产品的信息：B2");
	}
}

1.4 2012下半年

2 生成器模式

import java.util.*;

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

		Builder builder1 = new Builder1();
		dierctor.Construct(builder1);
		Product product1 = builder1.getResult();
		product1.show();

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

class Director {
	private 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(part:"A");
		product.Add(part:"B");
		product.Add(part:"C");
		product.Add(part:"D");
		product.Add(part:"E");
		product.Add(part:"F");
	}

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

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

	@Override
	public void BuildPart() {
		product.Add(part:"A");
		product.Add(part:"B");
		product.Add(part:"C");
	}

	@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.println("产品的组成：");
		for (String s : parts)
			System.out.print(s + " ");

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

2.1 真题

1.2017年上半年

2.2018年上半年

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

3.1 真题

1.2013年上半年

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数据线");
    }
}

4.1 真题

1.2016年上半年

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

5.1 真题

1.2009年上半年

2.2013年下半年

3.2017年下半年

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

6.1 真题

1.2009年下半年

2.2010年下半年

3.2011年上半年

4.2021年上半年

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

7.1 真题

1.2012年上半年

2.2016年下半年

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

8.1 真题

1.2021年下半年

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("电视机关机了...");
    }
}

9.1 真题

1.2014年下半年

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

10.1 真题

1.2014年上半年

2.2019年下半年

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

11.1 真题

1.2011年下半年

2.2018年下半年

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

12.1 真题

1.2010年上半年

2.2015年下半年

3.2019年上半年

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<Person> personList = new ArrayList<Person>();

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

13.1 真题

1.2015年上半年

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

14.1 真题

1.2020年下半年