文章目录

  • 实验一：工程方法与抽象工厂模式
    • 实验题目
    • 目录结构
    • 实验代码
      • 简单工厂
      • 工厂方法
      • 抽象工厂
  • 实验二：生成器模式与原型模式的编程实现
    • 实验题目
    • 目录结构
    • 实验代码
  • 实验三：装饰模式的编程实现
    • 实验题目
    • 目录结构
    • 实现代码
  • 实验四：组合模式与责任链模式
    • 实验题目
    • 实验代码
  • 实验五：解释器模式
    • 实验题目
    • 目录结构
    • 实验代码
  • 大作业
    • 一
      • 题目
      • 项目目录结构
      • 实现代码
      • UML图
    • 二
      • 题目
      • 项目目录结构
      • 实现代码
      • UML图
    • 三
      • 题目
      • 项目目录结构
      • 实现代码
      • UML图

实验一：工程方法与抽象工厂模式

实验题目

利用工厂方法和抽象工厂模式模拟实现服装工厂生产衣服的过程，具体内容如下：

现有三种品牌A、B和C的夹克，分别利用简单工厂模式和工厂方法模式实现生产各种品牌夹克的代码（即打印“生产A品牌夹克”之类的句子即可）

A、B和C各品牌除了生产夹克，还可以再生产裤子，利用抽象工厂模式实现各品牌夹克与裤子生产过程。

目录结构

D:.
└─com└─longstudy├─abstractfactory│  ├─factory│  │  │  AbstractFactory.java│  │  ││  │  └─impl│  │          AFactory.java│  │          BFactory.java│  │          CFactory.java│  ││  ├─jacket│  │  │  Jacket.java│  │  ││  │  └─impl│  │          JacketA.java│  │          JacketB.java│  │          JacketC.java│  ││  └─trouser│      │  Trouser.java│      ││      └─impl│              TrouserA.java│              TrouserB.java│              TrouserC.java│├─factory│  │  JacketFactory.java│  ││  └─jacket│      │  Jacket.java│      ││      └─impl│              JacketA.java│              JacketB.java│              JacketC.java│└─factorymethod├─factory│  │  JFactory.java│  ││  └─impl│          JacketAFractory.java│          JacketBFractory.java│          JacketCFractory.java│└─jacket│  Jacket.java│└─implJacketA.javaJacketB.javaJacketC.java

实验代码

简单工厂

public interface Jacket {void printJacket();
}

public class JacketA implements Jacket {@Overridepublic void printJacket() {System.out.println("生产夹克A");}
}

public class JacketB implements Jacket {@Overridepublic void printJacket() {System.out.println("生产夹克B");}
}

public class JacketC implements Jacket {@Overridepublic void printJacket() {System.out.println("生产夹克C");}
}

public class JacketFactory {public Jacket getJacket(String jacket){if(jacket==null){return null;}if (jacket.equals("A")){return new JacketA();}else if(jacket.equals("B")){return new JacketB();}else if(jacket.equals("C")){return new JacketC();}return null;}
}

测试：

public class JacketFactory {public Jacket getJacket(String jacket){if(jacket==null){return null;}if (jacket.equals("A")){return new JacketA();}else if(jacket.equals("B")){return new JacketB();}else if(jacket.equals("C")){return new JacketC();}return null;}
}

工厂方法

public interface JFactory {Jacket createJacket();
}

public class JacketAFractory implements JFactory {@Overridepublic Jacket createJacket() {return new JacketA();}
}

public class JacketBFractory implements JFactory {@Overridepublic Jacket createJacket() {return new JacketB();}
}

public class JacketCFractory implements JFactory {@Overridepublic Jacket createJacket() {return new JacketC();}
}

测试：

public class MyTest2 {@Testpublic void factoryMethodTest(){JFactory afactoty = new JacketAFractory();Jacket a = afactoty.createJacket();System.out.println(a.getClass());a.printJacket();JFactory bfactoty = new JacketBFractory();Jacket b = bfactoty.createJacket();System.out.println(b.getClass());b.printJacket();JFactory cfactoty = new JacketCFractory();Jacket c = cfactoty.createJacket();System.out.println(c.getClass());c.printJacket();}
}

抽象工厂

public abstract class AbstractFactory {public abstract Jacket getJacket();public abstract Trouser getTrouser();
}

public class AFactory extends AbstractFactory {@Overridepublic Jacket getJacket() {return new JacketA();}@Overridepublic Trouser getTrouser() {return new TrouserA();}
}

public class BFactory extends AbstractFactory {@Overridepublic Jacket getJacket() {return new JacketB();}@Overridepublic Trouser getTrouser() {return new TrouserB();}
}

public class CFactory extends AbstractFactory {@Overridepublic Jacket getJacket() {return new JacketC();}@Overridepublic Trouser getTrouser() {return new TrouserC();}
}

测试：

public class MyTest3 {@Testpublic void abstractFactoryTest(){try{AbstractFactory afactory = new AFactory();afactory.getJacket().printJacket();afactory.getTrouser().trouserPrint();AbstractFactory bfactory = new BFactory();bfactory.getJacket().printJacket();bfactory.getTrouser().trouserPrint();AbstractFactory cfactory = new CFactory();cfactory.getJacket().printJacket();cfactory.getTrouser().trouserPrint();}catch (NullPointerException e){e.printStackTrace();}}
}

实验二：生成器模式与原型模式的编程实现

实验题目

使用生产器模式模拟实现IBM电脑的生产，其中IBM电脑的主要结构用如下表示：

class IBM{string monitor = "IBM的显示器";string keyboard = "IBM的键盘";string mouse = "IBM的鼠标";Motherboard* MB;void display();
}

其中MB是一个主板类，其主要接哦股如下：

class Motherboard{string CPU;string RAM;
}

即主板包含CPU和RAM，display是一个打印各个组件的函数，主要用于检查是否生产正确。

建造顺序为先生产主板，再一次生产显示器、键盘、鼠标。

使用生产器模式生产出第一台IBM电脑后，利用原型模式，将该电脑再赋值两台。

目录结构

│  Director.java
│  IBMProduct.java
│  Main.java
│  Motherboard.java
└─builderBuilder.javaConcreteBuilderPlan.java

实验代码

Motherboard类：

public class Motherboard {private String CPU;private String RAM;public Motherboard() {}public Motherboard(String CPU, String RAM) {this.CPU = CPU;this.RAM = RAM;}@Overridepublic String toString() {return "Motherboard{" + CPU + "," + RAM  + '}';}public Motherboard clone(){Motherboard motherboard = new Motherboard();motherboard.setCPU(this.CPU);motherboard.setRAM(this.RAM);return motherboard;}public String getCPU() {return CPU;}public void setCPU(String CPU) {this.CPU = CPU;}public String getRAM() {return RAM;}public void setRAM(String RAM) {this.RAM = RAM;}
}

IBMProduct：

public class IBMProduct {private String monitor;private String keyboard;private String mouse;private Motherboard MB;public IBMProduct() {}public IBMProduct clone(){IBMProduct ibmProduct = new IBMProduct();ibmProduct.setKeyboard(this.keyboard);ibmProduct.setMonitor(this.monitor);ibmProduct.setMouse(this.mouse);Motherboard mb = MB.clone();ibmProduct.setMB(mb);return ibmProduct;}public void show() {System.out.println("IBM product:");System.out.println(this.MB.getCPU()+","+this.MB.getRAM());System.out.println(this.monitor);System.out.println(this.keyboard);System.out.println(this.mouse);}public void setMonitor(String monitor) {this.monitor = monitor;}public void setKeyboard(String keyboard) {this.keyboard = keyboard;}public void setMouse(String mouse) {this.mouse = mouse;}public void setMB(Motherboard MB) {this.MB = MB;}
}

Builder接口：

public interface Builder {void BuildMonitor();void BuildKeyboard();void BuildMouse();void BuildMotherBoard();default IBMProduct getResult(){return null;}
}

Builder接口的实现类：

public class ConcreteBuilderPlan implements Builder {private IBMProduct product = new IBMProduct();@Overridepublic void BuildMonitor() {product.setMonitor("IBM----显示器");}@Overridepublic void BuildKeyboard() {product.setKeyboard("IBM----显示器");}@Overridepublic void BuildMouse() {product.setMouse("IBM----鼠标");}@Overridepublic void BuildMotherBoard() {Motherboard motherboard = new Motherboard();motherboard.setCPU("IBM----CPU");motherboard.setRAM("IBM----RAM");product.setMB(motherboard);}@Overridepublic IBMProduct getResult() {return product;}
}

指挥者类：

public class Director {public void construct(Builder builder){builder.BuildMotherBoard();builder.BuildMonitor();builder.BuildKeyboard();builder.BuildMouse();}
}

测试：

public class Main {public static void main(String[] args) {Director director = new Director();ConcreteBuilderPlan concreteBuilderPlan = new ConcreteBuilderPlan();director.construct(concreteBuilderPlan);IBMProduct result = concreteBuilderPlan.getResult();result.show();System.out.println("*************原型模式***************");IBMProduct clone = result.clone();clone.setMouse("惠普----鼠标");clone.setKeyboard("华硕----键盘");clone.setMouse("惠普----鼠标");clone.setMB(new Motherboard("英特尔----CPU","AMD----RAM"));clone.show();System.out.println("*************原型模式2***************");IBMProduct clone2 = result.clone();clone2.setMouse("AMD----鼠标");clone2.setKeyboard("AMD----键盘");clone2.setMonitor("AMD----键盘");clone2.setMouse("AMD----鼠标");clone2.setMB(new Motherboard("AMD----CPU","AMD----RAM"));clone2.show();}
}

实验三：装饰模式的编程实现

实验题目

利用工厂方法模式实例化两个汽车类，例如丰田和沃尔沃。

对于这两种初始的汽车类（丰田和沃尔沃），利用装饰模式分别给它们添加新功能，其中丰田可以导航和自动驾驶，沃尔沃可以导航和语音控制。

目录结构

G:.
│  Client.java
├─car
│      Car.java
│      Toyota.java
│      Volvo.java
├─decorator
│      NewToyota.java
│      NewVolvo.java
│      ToyotaDecorator.java
│      VolvoDecorator.java
└─factoryCarFactory.javaToyotaFactory.javaVolvoFactory.java

实现代码

实例：

public interface Car {void printCar();
}

public class Toyota implements Car {@Overridepublic void printCar() {System.out.println("这是一辆Toyota");}
}

public class Volvo implements Car {@Overridepublic void printCar() {System.out.println("这是一辆Volvo");}
}

工厂：

public interface CarFactory {Car createCar();
}

public class ToyotaFactory implements CarFactory {@Overridepublic Toyota createCar() {return new Toyota();}
}

public class VolvoFactory implements CarFactory{@Overridepublic Volvo createCar() {return new Volvo();}
}

装饰器：

public interface NewToyota extends Car {// 导航void navigation();// 自动驾驶void autopilot();
}

public interface NewVolvo extends Car {// 导航void navigation();// 语音控制void voiceControl();
}

public class ToyotaDecorator implements NewToyota {private final Car car;public ToyotaDecorator(Car car) {this.car = car;}@Overridepublic void navigation() {System.out.println("添加功能---导航");}@Overridepublic void autopilot() {System.out.println("添加功能---自动驾驶");}@Overridepublic void printCar() {car.printCar();}
}

public class VolvoDecorator implements NewVolvo {private final Car car;public VolvoDecorator(Car car) {this.car = car;}@Overridepublic void navigation() {System.out.println("添加功能---导航");}@Overridepublic void voiceControl() {System.out.println("添加功能---语音控制");}@Overridepublic void printCar() {car.printCar();}
}

客户端调用：

public class Client {public static void main(String[] args) {/*** 丰田*/// 工厂生产ToyotaFactory toyotaFactory = new ToyotaFactory();Toyota toyota = toyotaFactory.createCar();// 装饰ToyotaDecorator toyotaDecorator = new ToyotaDecorator(toyota);toyotaDecorator.printCar();toyotaDecorator.autopilot();toyotaDecorator.navigation();/*** 沃尔沃*/VolvoFactory volvoFactory = new VolvoFactory();Volvo volvo = volvoFactory.createCar();VolvoDecorator volvoDecorator = new VolvoDecorator(volvo);volvoDecorator.printCar();volvoDecorator.navigation();volvoDecorator.voiceControl();}
}

实验四：组合模式与责任链模式

实验题目

根据下图，利用组合模式构建该公司的结构。

即总公司下设上海华东分公司，华东分公司下设南京办事处和杭州办事处。其中，各级分公司均设有人力资源部和财务部。

利用组合模式构建好该结构后，利用职责链模式处理各地员工加薪请求。

例如，一南京员工提出加薪请求，如果加薪不超过1000元，南京办事处即可批准；如果超过1000元，则上报华东分公司，如果2000元以内，则批准；超过则上报北京总公司，如果不超过3000元，则总公司批准，否则拒绝。

实验代码

public interface Component {void add(Component c);void remove(Component c);void print(int depth);void handlerRequest(int request);
}

public class Department implements Component{private String name;// 最低工资和最高工资区间private int low;private int high;private Component successor;private List<Component> departmentsList = new LinkedList<>();public Department() { }public Department(String name) {this.name = name;}// 设置薪资上下限public void setBound(int low,int high){this.low=low;this.high=high;}public void setSuccessor(Component c){this.successor=c;}@Overridepublic void add(Component c) {this.departmentsList.add(c);}@Overridepublic void remove(Component c) {this.departmentsList.remove(c);}// 递归打印构建的树public void print(int depth){for(int i=1;i<=depth;i++){System.out.print("--");}System.out.println(this.name);for (Component department : departmentsList) {department.print(depth+1);}}@Overridepublic void handlerRequest(int request) {if(request>=low && request<=high){System.out.println(this.name+">>>处理请求,加薪:"+request);}else if(successor!=null){System.out.println(this.name+">>>没有权限");successor.handlerRequest(request);}else{System.out.println(this.name+">>>就是不给你加薪");}}
}

客户端测试：

public class Client {public static void main(String[] args) {Department node1 = new Department("北京公司总部");Department node2 = new Department("人力资源部");Department node3 = new Department("上海华东分公司");Department node4 = new Department("财务部");Department node5 = new Department("南京办事处");Department node6 = new Department("杭州办事处");// 构建树node1.add(node2);node1.add(node3);node1.add(node4);node3.add(node5);node3.add(node2);node3.add(node4);node3.add(node6);node5.add(node2);node5.add(node4);node6.add(node2);node6.add(node4);node1.print(0);// 构建责任链node5.setSuccessor(node3);node6.setSuccessor(node3);node3.setSuccessor(node1);// 设置加薪边界node5.setBound(0,1000);node6.setBound(0,1000);node3.setBound(1000,2000);node1.setBound(2000,3000);// 请求加薪System.out.println("**********************");node5.handlerRequest(500);System.out.println("**********************");node5.handlerRequest(1500);System.out.println("**********************");node5.handlerRequest(2500);System.out.println("**********************");node5.handlerRequest(3500);}
}

实验五：解释器模式

实验题目

利用解释器模式，打印并计算实现浮点数的四则运算

例如：3+(4*6-(7/2))=23.5

目录结构

G:.
│  Client.java
└─expression│  Context.java│  Expression.java│  Variable.java└─implAddExpression.javaBracket.javaDivExpression.javaMulExpression.javaSubExpression.java

实验代码

声明抽象类：

public abstract class Expression {/*** 解析* @param con 变量对象-数字* @return 数字*/public abstract double interpreter(Context con);/*** 打印* @param con 变量对象-数字*/public abstract void display(Context con);
}

变量封装：

public class Variable extends Expression {@Overridepublic double interpreter(Context con) {return con.LookupValue(this);}@Overridepublic void display(Context con) {System.out.print(con.LookupValue(this));}
}

public class Context {private Map<Variable,Double> valueMap = new HashMap<>();/*** 将变量存放到HashMap中以便后面的运算* @param x 变量对象* @param y 数字*/public void addValue(Variable x,double y){valueMap.put(x, y);}/*** 获取变量x对应的映射的数字* @param x 变量对象* @return 获取的数字*/public double LookupValue(Variable x){return valueMap.get(x);}
}

具体实现的加减乘除括号操作：

public class AddExpression extends Expression{private Expression left;private Expression right;public AddExpression(Expression left, Expression right) {this.left = left;this.right = right;}/*** 将变量对象解析成数字后进行运算* @param con 变量对象-数字* @return*/@Overridepublic double interpreter(Context con) {return left.interpreter(con)+right.interpreter(con);}@Overridepublic void display(Context con) {left.display(con);System.out.print("+");right.display(con);}
}

public class SubExpression extends Expression{private Expression left;private Expression right;public SubExpression(Expression left, Expression right) {this.left = left;this.right = right;}@Overridepublic double interpreter(Context con) {return left.interpreter(con)-right.interpreter(con);}@Overridepublic void display(Context con) {left.display(con);System.out.print("-");right.display(con);}
}

public class MulExpression extends Expression {private Expression left;private Expression right;public MulExpression(Expression left, Expression right) {this.left = left;this.right = right;}@Overridepublic double interpreter(Context con) {return left.interpreter(con)*right.interpreter(con);}@Overridepublic void display(Context con) {left.display(con);System.out.print("*");right.display(con);}
}

public class DivExpression extends Expression {private Expression left;private Expression right;public DivExpression(Expression left, Expression right) {this.left = left;this.right = right;}@Overridepublic double interpreter(Context con) {return (1.0*left.interpreter(con))/right.interpreter(con);}@Overridepublic void display(Context con) {left.display(con);System.out.print("/");right.display(con);}
}

/*** 括号解析* @author Jonny Long* @date 2021/6/17 9:15*/
public class Bracket extends Expression {private Expression exp;public Bracket(Expression exp) {this.exp = exp;}@Overridepublic double interpreter(Context con) {return exp.interpreter(con);}@Overridepublic void display(Context con) {System.out.print("(");exp.display(con);System.out.print(")");}
}

客户端测试：

public class Client {public static void main(String[] args) {Expression exp;Context con = new Context();Variable a = new Variable();Variable b = new Variable();Variable c = new Variable();Variable d = new Variable();Variable e = new Variable();con.addValue(a,3);con.addValue(b,4);con.addValue(c,6);con.addValue(d,7);con.addValue(e,2);exp = new AddExpression(a,new Bracket(new SubExpression(new MulExpression(b,c),new DivExpression(d,e))));exp.display(con);System.out.print("="+exp.interpreter(con));}
}

大作业

一

题目

综合利用抽象工厂模式和单件模式，模拟实现服装工厂生产衣服的过程，具体内容如下：

现有两种服装品牌的工厂A和B，品牌A和品牌B的工厂都可以生产夹克和裤子，利用抽象工厂模式实现生产各种品牌的夹克和裤子的代码(即打印“生产A品牌夹克”之类的句子即可)，并且利用单件模式，将品牌A和品牌B的工厂实现为单件。

试完成以下工作：

（1）画出UML类图

（2）给出核心实现代码

项目目录结构

G:.
│  Client.java
├─bean
│  │  Jacket.java
│  │  Trouser.java
│  │
│  ├─jacket
│  │      JacketA.java
│  │      JacketB.java
│  └─trouser
│          TrouserA.java
│          TrouserB.java
└─factory│  AbstractFactory.java└─implAFactory.javaBFactory.java

实现代码

夹克和上衣接口及实现类：

public interface Jacket {void printJacket();
}

public interface Trouser {void printTrouser();
}

public class JacketA implements Jacket {@Overridepublic void printJacket() {System.out.println("生产A牌夹克");}
}

public class JacketB implements Jacket {@Overridepublic void printJacket() {System.out.println("生产B牌夹克");}
}

public class TrouserA implements Trouser {@Overridepublic void printTrouser() {System.out.println("生产A牌上衣");}
}

public class TrouserB implements Trouser {@Overridepublic void printTrouser() {System.out.println("生产B牌上衣");}
}

定义工厂：

public abstract class AbstractFactory {public abstract Jacket getJacket();public abstract Trouser getTrouser();
}

public class AFactory extends AbstractFactory {private static AFactory instanceA = new AFactory();public static AFactory getInstanceA(){return instanceA;}@Overridepublic Jacket getJacket() {return new JacketA();}@Overridepublic Trouser getTrouser() {return new TrouserA();}
}

public class BFactory extends AbstractFactory {private static BFactory instanceB = new BFactory();public static BFactory getInstanceB(){return instanceB;}@Overridepublic Jacket getJacket() {return new JacketB();}@Overridepublic Trouser getTrouser() {return new TrouserB();}
}

客户端测试：

public class Client {public static void main(String[] args) {AFactory instanceA = AFactory.getInstanceA();instanceA.getJacket().printJacket();instanceA.getTrouser().printTrouser();BFactory instanceB = BFactory.getInstanceB();instanceB.getJacket().printJacket();instanceB.getTrouser().printTrouser();}
}

UML图

二

题目

利用解释器模式，实现只含加减法及括号的代数表达式的打印及运算。例如对于代数表达式a+b-(c+3)，当给a赋值3，b赋值4，c赋值5时，输出如下：

a+b-(c+3)
=3+4-(5+3)
=-1

其中变量名只能是‘a’,’b’,…,’z’,所有变量赋值以及常数都是0-9之间的整数。输出结果中第一行打印原始表达式，a+b-(c+3)，即含有变量名；第二行将变量替换为所赋的值，即3+4-(5+3)；第三行打印计算结果。

试完成以下工作：

（1）给出文法表达式

（2）画出UML类图

（3）给出核心实现代码

项目目录结构

G:.
│  Client.java
│  Context.java
│  Expression.java
│  Variable.java
└─implAddExpression.javaBracket.javaSubExpression.java

实现代码

接口与变量类：

public abstract class Expression {public abstract double interpreter(Context con);public abstract void display(Context con);
}

public class Context {private Map<Variable,Double> valueMap = new HashMap<>();public void addValue(Variable x,double y){valueMap.put(x,y);}public double lookupValue(Variable x){return valueMap.get(x);}
}

public class Variable extends Expression {@Overridepublic double interpreter(Context con) {return con.lookupValue(this);}@Overridepublic void display(Context con) {System.out.print(con.lookupValue(this));}
}

实现的运算：

public class AddExpression extends Expression {private Expression left;private Expression right;public AddExpression(Expression left, Expression right) {this.left = left;this.right = right;}@Overridepublic double interpreter(Context con) {return left.interpreter(con)+right.interpreter(con);}@Overridepublic void display(Context con) {left.display(con);System.out.print("+");right.display(con);}
}

public class SubExpression extends Expression {private Expression left;private Expression right;public SubExpression(Expression left, Expression right) {this.left = left;this.right = right;}@Overridepublic double interpreter(Context con) {return left.interpreter(con)-right.interpreter(con);}@Overridepublic void display(Context con) {left.display(con);System.out.print("-");right.display(con);}
}

public class Bracket extends Expression {private Expression exp;public Bracket(Expression exp) {this.exp = exp;}@Overridepublic double interpreter(Context con) {return exp.interpreter(con);}@Overridepublic void display(Context con) {System.out.print("(");exp.display(con);System.out.print(")");}
}

客户端测试：

public class Client {public static void main(String[] args) {Expression exp;Context con = new Context();Variable a = new Variable();Variable b = new Variable();Variable c = new Variable();con.addValue(a,3);con.addValue(b,4);con.addValue(c,5);Variable d = new Variable();con.addValue(d,3);exp = new SubExpression(new AddExpression(a,b),new Bracket(new AddExpression(c,d)));System.out.print("a+b-(c+3)\n=");exp.display(con);System.out.println("\n="+exp.interpreter(con));}
}

UML图

三

题目

利用观察者模式和中介者模式，实现一个二元函数的函数计算器。该计算器含有两个数据类：

class A{int x;
}
class B{int y;
}

分别存储整型变量x和y。需要实现三个函数计算器类，分别计算f1(x,y)=x+y，f2(x,y)=x-y和f3(x)=2x。

要求：

（1）当且仅当类A和类B都发布通知时，3个函数计算器才相应地计算出3个新的值。

（2）类A、类B与三个函数计算器类尽可能解耦。

（3）可以动态地增加和减少函数计算器。

试完成以下工作：

（1）画出UML类图

（2）通过修改类A和类B，以及增加适当的类，实现其代码

项目目录结构

G:.
│  Client.java
├─data
│      A.java
│      AbstractData.java
│      B.java
├─mediator
│      AbstractMediator.java
│      ConcreteMediator.java
└─observerF1.javaF2.javaF3.javaObserver.java

实现代码

数据类：

public abstract class AbstractData {protected AbstractMediator abstractMediator;public int num;public AbstractData(AbstractMediator abstractMediator) {this.abstractMediator = abstractMediator;}public abstract void send(int num);
}

public class A extends AbstractData {public A(AbstractMediator abstractMediator) {super(abstractMediator);}@Overridepublic void send(int num) {abstractMediator.send(num,this);}
}

public class B extends AbstractData {public B(AbstractMediator abstractMediator) {super(abstractMediator);}@Overridepublic void send(int num) {abstractMediator.send(num,this);}
}

中介者+被观察者：

这个中介者类兼有两种智能：

  • 作为中介器
  • 作为被观察的对象
public abstract class AbstractMediator {// 作为中介器的接口public abstract void send(int num, AbstractData abstractData);// 被观察者private List<Observer> observerList = new LinkedList<>();public void attach(Observer observer){observerList.add(observer);}public void detach(Observer observer){observerList.remove(observer);}public void notifyObserver(){for (Observer o:observerList) {o.update();}}
}

public class ConcreteMediator extends AbstractMediator {private A a;private B b;@Overridepublic void send(int num, AbstractData abstractData) {if (a == abstractData) {a.num = num;} else if (b == abstractData) {b.num = num;}}public void setA(A a) {this.a = a;}public void setB(B b) {this.b = b;}public A getA() {return a;}public B getB() {return b;}
}

观察者类：

public interface Observer {void update();
}

public class F1 implements Observer{private int result;private ConcreteMediator concreteMediator;public F1(ConcreteMediator concreteMediator) {this.concreteMediator = concreteMediator;}@Overridepublic void update() {result = concreteMediator.getA().num+concreteMediator.getB().num;showResult();}public void showResult() {System.out.println("函数f1(x,y)=x+y计算结果="+result);}
}

public class F2 implements Observer {private int result;private ConcreteMediator concreteMediator;public F2(ConcreteMediator concreteMediator) {this.concreteMediator = concreteMediator;}@Overridepublic void update() {result = concreteMediator.getA().num-concreteMediator.getB().num;showResult();}public void showResult() {System.out.println("函数f2(x,y)=x-y计算结果="+result);}
}

public class F3 implements Observer {private int result;private ConcreteMediator concreteMediator;public F3(ConcreteMediator concreteMediator) {this.concreteMediator = concreteMediator;}@Overridepublic void update() {result = concreteMediator.getA().num*2;showResult();}public void showResult() {System.out.println("函数f3(x)=2x计算结果="+result);}
}

public class Client {public static void main(String[] args) {// mediator既做中介器，又做被观察的对象ConcreteMediator mediator = new ConcreteMediator();A a = new A(mediator);B b = new B(mediator);mediator.setA(a);mediator.setB(b);a.send(20);b.send(5);mediator.attach(new F1(mediator));mediator.attach(new F2(mediator));mediator.attach(new F3(mediator));mediator.notifyObserver();// 让对象a发布新的通知System.out.println("************新通知*************");a.send(-100);mediator.notifyObserver();}
}

UML图

安徽大学软件构造（设计模式）实验集相关推荐

  1. 软件构造Lab1实验总结

    软件构造Lab1实验总结 1 实验目标概述 本次实验通过求解四个问题,训练基本 Java 编程技能,能够利用 Java OO 开 发基本的功能模块,能够阅读理解已有代码框架并根据功能需求补全代码,能够 ...

  2. 软件构造lab2 - 实验报告

    软件构造lab2 - 实验报告 1.实验目标概述 2.环境配置 3.实验过程 3.1Poetic Walks 3.1.1Get the code and prepare Git repository ...

  3. [HITSC]哈工大2020春软件构造Lab3实验报告

    Github地址 1 实验目标概述 本次实验覆盖课程第 3.4.5 章的内容,目标是编写具有可复用性和可维护 性的软件,主要使用以下软件构造技术: 子类型.泛型.多态.重写.重载 继承.代理.组合 常 ...

  4. HIT 软件构造 lab3实验报告

    2020年春季学期 计算机学院<软件构造>课程 Lab 3实验报告 姓名 赵旭东 学号 1180300223 班号 1803002 电子邮件 1264887178@qq.com 手机号码 ...

  5. 【软件构造】实验一的心得体会

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录 前言` 一.Magic Squares 1.任务要求 2.isLegalMagicSquare() 1.BufferedRe ...

  6. 哈工大软件构造Lab1实验报告

    2020年春季学期 计算机学院<软件构造>课程 Lab 1实验报告 目录 1 实验目标概述... 1 2 实验环境配置... 1 3 实验过程... 1 3.1 Magic Squares ...

  7. 哈工大2020软件构造Lab2实验报告

    本项目于3.17日实验课验收,请放心参考 参考时文中有给出一些建议,请查看 基本更新完成 2020春计算机学院<软件构造>课程Lab2实验报告 Software Construction ...

  8. HIT 软件构造 lab2实验报告

    2020年春季学期 计算机学院<软件构造>课程 Lab 2实验报告 学号 1180300223 班号 1803002 目录 1 实验目标概述 1 2 实验环境配置 1 3 实验过程 1 3 ...

  9. 软件构造 Lab2 实验报告

    2021年春季学期 计算学部<软件构造>课程 Lab 2实验报告 姓名 王雨宁 学号 1190201118 班号 1903006 电子邮件 1756840811@qq.com 手机号码 1 ...

  10. 【软件构造】实验笔记（一）Lab1-Fundamental Java Programming and Testing

    一.前言 <软件构造>课程是我校根据MIT.CMU等计算机领域名校的相关课程近年来开展的软件开发相关的课程.课程的实验和课件都很大程度上参考了上述学校. 本笔记对在课程实验练习进行中遇到的 ...

最新文章

  1. [BZOJ1602] [Usaco2008 Oct] 牧场行走 (LCA)
  2. 【Android 逆向】Android 逆向通用工具开发 ( Windows 平台运行的控制台应用程序类型 | 编译 Windows 平台运行的 Android 逆向程序 )
  3. 对象的继承关系在数据库中的实现方式和PowerDesigner设计
  4. Django(part14)--模板的继承
  5. 盘点18个免费的WordPress主题后台选项开发框架
  6. Java_WEB项目OOM(OutOfMemError内存溢出) MyEclipse配置Jvm内存
  7. 斯坦福所倡导的设计思维_针对高科技项目的有效开发商倡导
  8. JVM性能优化之CPU负载过高
  9. 拳王公社：没钱没资源没人脉！网络创业凭副业年赚20W+！
  10. Servlet-ServletConfig对象
  11. 初学css常用属性整理
  12. 仿微信打飞机小游戏GamePlane(1)----概述
  13. 为什么高斯滤波器被广泛用于图像处理？
  14. Shapley Values
  15. html返回的状态值,iradon函数返回的是什么值
  16. 信号指示RSSI与显示格数关系
  17. java编程实现；猜单词游戏
  18. 神秘AI变脸软件风靡全球，让你秒变身迪士尼在逃主角
  19. Google推出拼音输入法了！
  20. 在计算机中 汉字系统把一个汉字表示为,计算机问题汉字系统在计算机内把一个汉字表示 – 手机爱问...

热门文章

  1. Android开发中需要注意的坑
  2. 与游戏结合的建材网店
  3. 两台电脑通过交叉网线连接一台做为服务器一台做为客户端的配置方法
  4. 基于JavaWeb技术实现宿舍管理系统
  5. 软考高频考点——项目中标了以后该怎么做？
  6. 微信小程序地图获取地点信息（打卡签到功能为例）-2020-7-26
  7. leetcode解题常见思路
  8. redis未授权访问致远程植入挖矿脚本
  9. GitHub 人脸属性编辑神器横空出世！
  10. 分子筛（合成沸石）-硅铝酸盐多微孔晶体