实验一 软件设计模式之工厂模式实验 

一、实验目的

掌握软件设计模式中的工厂模式，能够用工厂模式编写程序，解决实际问题。

二、实验内容与要求

内容：使用工厂模式写一个简单的计算器，能实现加减乘除运算。要求输入两个数，选择运算符，程序便能够计算出结果。程序设计语言可自由选择。

要求：需要用“文字+代码+截图”的形式对实验的主要代码和运行结果进行展示和描述。

三、实验方法

1. 创建一个工厂窗口类（factoryPatternDemo.java）和工厂类（countFactory.java），通过工厂窗口类发出的需求，调用工厂类。

2.创建加减乘除四种功能类，方便接口的调用。

3. 创建接口（count.java），工厂类通过接口调用加减乘除等子类函数，实现操作，很好的隐藏了加减乘除的具体细节。

四 、实验代码以及结果

//factoryPatternDemo.java
package homework;

import java.util.Scanner;

public class factoryPatternDemo {
    public static  void main(String [] args){
          countFactory countFactory1= new countFactory();
          System.out.println("请你输入要进行计算的运算符：如'add' 'sub' ' mul' 'div' : ");
          Scanner sc= new Scanner(System.in);
          String name= sc.nextLine();
          System.out.println("请输入要计算的两个数字（中间以空格隔开）：");
          Scanner sc1= new Scanner(System.in);
          double a= sc1.nextDouble();
          double b= sc1.nextDouble();

          if(name.equalsIgnoreCase("add")){
              count cout1=countFactory1.getcount("add");
              cout1.calculate(a , b);
          }else  if(name.equalsIgnoreCase("sub")){
              count cout1=countFactory1.getcount("sub");
              cout1.calculate( a, b);
          }else if(name.equalsIgnoreCase("mul")){
              count cout1=countFactory1.getcount("mul");
              cout1.calculate( a, b);
          }else if(name.equalsIgnoreCase("div")){
              count cout1=countFactory1.getcount("div");
              cout1.calculate( a, b);
          }
    }
}

countFactory.java
package homework;

public class countFactory {
    public  count  getcount(String countType){
        if(countType ==null ){
            return null;
        }
        if(countType.equalsIgnoreCase("add")) {
            return new addDemo();
        } else
            if(countType.equalsIgnoreCase("sub")){
            return new subDemo();
            } else
                if(countType.equalsIgnoreCase("div")){
                return new divDemo();
                } else
                    if(countType.equalsIgnoreCase("mul")){
                    return new mulDemo();
                    }
                    return null;
    }
}
//接口类count.java
package homework;

public interface count {
    void calculate(double x,double y );
}
//addDemo.java
package homework;
public class addDemo implements count {
    @Override
    public void calculate(double x, double y) {
        double z;
        z=x+y;
        System.out.println("两数相加的结果是："+z);

    }
}



//divDemo.java

package homework;
public class divDemo implements count  {
    @Override
    public void calculate(double x,double y) {
        double z;
        z=x/y;
        System.out.println( "两数相除的结果是："+ z);
    }
}
//mulDemo.Java
package homework;
public class mulDemo implements count  {
    @Override
    public void calculate(double x, double y) {
        double z;
        z=x*y;
        System.out.println( "两数相乘的结果是："+ z);
    }
}

//subDemo.Java
package homework;
public class subDemo implements count  {
    @Override
    public void calculate(double x, double y ) {
        double z;
        z=x-y;
        System.out.println( "两数相减的结果是："+ z);
    }
}

结果截图：








 

 

 

 

 

 

实验 软件设计模式之适配器模式实验
一、实验目的
掌握软件设计模式中的适配器模式，能够用适配器模式编写程序，解决实际问题。

二、实验内容与要求
内容：举一个现实生活中的适配器的例子，并用适配器模式对其进行模拟，程序设计语言可自由选择。

要求：需要用“文字+代码+截图”的形式对实验的主要代码和运行结果进行展示和描述。

三、实验方法

举例：配器模式是23中设计模式之一，它的主要作用是在新接口和老接口之间进行适配。它非常像我们出国旅行时带的电源转换器。我们国家的电器使用普通的扁平两项或三项插头，而去外国的话，使用的标准就不一样了，怎样解决这个问题呢？只要使用一个电源转化器就行了。
代码中有两个接口，分别为德标接口和国标接口，分别命名为DBSocketInterface和GBSocketInterface，此外还有两个实现类，分别为德国插座和中国插座，分别为DBSocket和GBSocket。为了提供两套接口之间的适配，我们提供了一个适配器，叫做SocketAdapter。除此之外，还有一个客户端，比如是我们去德国旅游时住的一家宾馆，叫Hotel，在这个德国旅馆中使用德国接口。

德标接口：

public interface  DBSocketInterface {
    /**
     * 这个方法的名字叫做：使用两项圆头的插口供电
     */
    void powerWithTwoRound();
}


德国插座实现德标接口

/**
 * 德国插座
 */
ublic class DBSocket implements DBSocketInterface{     
    ublic void  powerWithTwoRound(){
        System.out.println("使用两项圆头的插孔供电");
    }
} 


德国旅馆是一个客户端，它里面有德标的接口，可以使用这个德标接口给手机充电：

/**
 * 德国宾馆
 */
public class  Hotel {
    //旅馆中有一个德标的插口
    private DBSocketInterface dbSocket;
    public Hotel(){}
    public Hotel(DBSocketInterface dbSocket) {
        this.dbSocket = dbSocket;
    }
    public void  setSocket (DBSocketInterface dbSocket){
        this.dbSocket = dbSocket;
    }
    //旅馆中有一个充电的功能
    public void  charge(){        
        //使用德标插口充电
        dbSocket.powerWithTwoRound();
    }
}


现在写一段代码进行测试：

public class  Test {
    public static  void  main(String[] args) {
        //初始化一个德国插座对象， 用一个德标接口引用它
        DBSocketInterface dbSoket = new DBSocket();
        //创建一个旅馆对象
        Hotel hotel = new Hotel(dbSoket);
 //在旅馆中给手机充电
        hotel.charge();
    }
}

打印出以下结果： 使用两项圆头的插孔供电

6. 上面的Hotel类，DBSocket类，DBSocketInterface接口都是不可变的（由德国的客户提供），如果我想使用这一套API，那么只能自己写代码解决。

下面是国标接口和中国插座的代码。

国标接口：
/**
 * 国标接口
 */
public interface  GBSocketInterface {
    /**
     * 这个方法的名字叫做：使用三项扁头的插口供电
     */
    void powerWithThreeFlat();
}
中国插座实现国标接口：
/**
 * 中国插座
 */
public class  GBSocket implements
GBSocketInterface{
    public void  powerWithThreeFlat() {
        System.out.println("使用三项扁头插孔供电");
    }
}

7.下面给出适配器类的实现：
public class  SocketAdapter 
        implements DBSocketInterface{   //实现旧接口
 
    //组合新接口
    private GBSocketInterface gbSocket;
     
    /**
     * 在创建适配器对象时，必须传入一个新街口的实现类
     * @param gbSocket
     */
    public SocketAdapter(GBSocketInterface gbSocket) {
        this.gbSocket = gbSocket;
    }
    /**
     * 将对就接口的调用适配到新接口
     */
    @Override
    public void  powerWithTwoRound() {
        gbSocket.powerWithThreeFlat();
    }
}

8.测试代码：
public class  TestAdapter {
    public static  void  main(String[] args) {
        GBSocketInterface gbSocket = new GBSocket();
        Hotel hotel = new Hotel();
        SocketAdapter socketAdapter = new SocketAdapter(gbSocket);
        hotel.setSocket(socketAdapter);
        hotel.charge();
    }
}

打印出以下结果：

使用两项圆头的插孔供电
四	、实验结果

测试结果1:


适配器测试结果：


适配器模式将一个类的接口转换成客户期望的另一个接口，让原本不兼容的接口可以合作无间。

这个适配器必须满足以下条件：

1，必须符合德国标准的接口，否则的话还是没办法插到德国插座中。

2,，在调用上面实现的德标接口进行充电时，提供一种机制，将这个调用转到对国标接口的调用。
这就要求：
1，适配器必须实现原有的旧的接口。

2，适配器对象中持有对新接口的引用，当调用旧接口时，将这个调用委托给实现新接口的对象来处理，也就是在适配器对象中组合一个新接口。

软件设计模式之组合模式实验
一、实验目的
掌握软件设计模式中的组合模式，能够用组合模式编写程序，解决实际问题。
二、实验内容与要求
内容：以学校的部门结构为场景，用组合模式进行模拟，程序设计语言可自由选择。

要求：需要用“文字+代码+截图”的形式对实验的主要代码和运行结果进行展示和描述。
三、实验方法
需求：一个学校包含多个学院，一个学院包含多个部门，部门是最下面一级，不能包含其他子节点，即部门是叶子节点，我们需要展示学校的整个组织架构树结构；

抽象构建类

package com.combined.java;
/**
 * 
 * @Description
 * @author ChuanShun.Wang   Email:2045064682@qq.com
 * @version
 * @date 2020年3月24日下午8:43:30
 *
 */
public abstract class SchoolSectorStructure{
    private String name;
    public SchoolSectorStructure (String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    protected void add(SchoolSectorStructure component) {
    }
    protected void delete(SchoolSectorStructure component) {
    }
    public abstract void print();
}


子容器类：学校类

package com.combined.java;
import java.util.ArrayList;
import java.util.List;
public class School extends SchoolSectorStructure {
    private List< SchoolSectorStructure > components = new ArrayList<>();
    public School(String name) {
        super(name);
    }
    @Override
    protected void add(SchoolSectorStructure component) {
        components.add(component);
    }
    @Override
    protected void delete(SchoolSectorStructure component) {
        components.remove(component);
    }
    //输出学校里面的所有学院
    @Override
    public void print() {
        for (SchoolSectorStructure component : components) {
            component.print();
        }
    }
}


子容器：学院类

package com.combined.java;
import java.util.ArrayList;
import java.util.List;
public class College extends SchoolSectorStructure {
    /**
     * 存在部门信息
     */
    private List< SchoolSectorStructure > components = new ArrayList<>();
 
    public College(String name) {
        super(name);
    }
    @Override
    protected void add(SchoolSectorStructure component) {
        components.add(component);
    }
    @Override
    protected void delete(SchoolSectorStructure component) {
        components.remove(component);
    }
    @Override
    public void print() {
        for (SchoolSectorStructure t : components) {
            t.print();
        }
    }
}

4.叶子节点：部门类
package com.combined.java;
public class Department extends SchoolSectorStructure {
    public Department(String name) {
        super(name);
    }
    @Override
    protected void add(SchoolSectorStructure component) {
        System.out.println("不支持该方法...");
    }
    @Override
    protected void delete(SchoolSectorStructure component) {
        System.out.println("不支持该方法...");
    }
    @Override
    public void print() {
        System.out.println(getName());
    }
}

5.客户端类
package com.combined.java;
public class Client {
    public static void main(String[] args) {
        //学校
        SchoolSectorStructure university = new School("信阳师范学院"); 
        //学院里面添加多个部门
        SchoolSectorStructure college1 = new College("计算机学院");
        college1.add(new Department("计算机与信息技术专业"));
        college1.add(new Department("软件工程专业"));
 
        SchoolSectorStructure college2 = new College("数学院");
        college2.add(new Department("应用数学专业"));
        college2.add(new Department("统计学专业"));
 
        //学校里面添加多个学院
        university.add(college1);
        university.add(college2);
 
        System.out.println("====" + university.getName() + "====");
        university.print();
        System.out.println("====" + college1.getName() + "====");
        college1.print();
        System.out.println("====" + college2.getName() + "====");
        college2.print();
    }
}

四	、实验结果


结果展示




客户端使用的时候不需要区分当前是子容器对象还是叶子节点，都采用一致的方式调用，这样极大地方便客户端的调用。


增加新的子容器节点和叶子节点都挺方便，不需要对原有代码进行改造，符合开闭原则。


通过叶子节点和子容器节点的递归组合可以形成复杂的树形结构数据，但对于树形结构的控制却很简单。


如果叶子节点和子容器之间差异比较大，那么不太适合使用组合模式。

软件设计模式之中介者模式实验
一、实验目的
掌握软件设计模式中的中介者模式，能够用中介者模式编写程序，解决实际问题。
二、实验内容与要求
内容：有个租房中介为房主和租赁人提供租房服务，请用中介者模式对租房中介的工作进行模拟，程序设计语言可自由选择。

要求：需要用“文字+代码+截图”的形式对实验的主要代码和运行结果进行展示和描述。
三、实验方法

抽象中介者：定义了同事对象到中介者对象的接口

package com.middleman.java;

public abstract class Mediator {
    /**
     * 注册同事方法
     */
    public abstract void register(String key, Colleague colleague);
    /**
     * 发送消息
     */
    public abstract void sendMessage(String key);
}


抽象同事类

package com.middleman.java;

public abstract class Colleague {
    /**
     * 发送消息
     */
    public abstract void sendMessage();
    /**
     * 接收消息
     */
    public abstract void receiveMessage();
}


具体同事类：持有抽象中介者角色引用

房东类：

package com.middleman.java;

public class Landlord extends Colleague {
    private static final String USER_A_REGISTER_KEY = "userA";
    private static final String USER_B_REGISTER_KEY = "userB";
    /**
     * 持有一个抽象中介者对象引用
     */
    private Mediator mediator;
 
    public Landlord(Mediator mediator) {
        this.mediator = mediator;
        mediator.register(USER_A_REGISTER_KEY, this);
    }
 
    @Override
    public void sendMessage() {
        System.out.println("房东向中介发出出租和房间的具体情况信息");
        mediator.sendMessage(USER_B_REGISTER_KEY);
    }
 
    @Override
    public void receiveMessage() {
        System.out.println("房东从中介收到租客发出的比较匹配的租房信息");
    }
}

租客类：
package com.middleman.java;

public class Renter extends Colleague {
    /**
     * 持有一个抽象中介者对象引用
     */
    private Mediator mediator;
    private static final String USER_A_REGISTER_KEY = "userA";
    private static final String USER_B_REGISTER_KEY = "userB";
 
    public Renter(Mediator mediator) {
        this.mediator = mediator;
        mediator.register(USER_B_REGISTER_KEY, this);
    }
 
    @Override
    public void sendMessage() {
        System.out.println("租客向中介发出租房信息和具体要求");
        mediator.sendMessage(USER_A_REGISTER_KEY);
    }
 
    @Override
    public void receiveMessage() {
        System.out.println("租客从中介收到符合条件的房东出租信息");
    }
}


具体中介者

package com.middleman.java;

import java.util.HashMap;
import java.util.Map;

public class Institution extends Mediator {
	 
    /**
     * 具体中介者类持有多个同事类对象引用
     * 这里使用Map保存，当然也可以使用List或者其他集合进行保存
     */
    private Map<String, Colleague> colleagueMap = new HashMap<>();
 
    @Override
    public void register(String key, Colleague colleague) {
        colleagueMap.put(key, colleague);
    }
 
    @Override
    public void sendMessage(String key) {
        Colleague colleague = colleagueMap.get(key);
        if (null != colleague) {
            colleague.receiveMessage();
        }
    }
}


客户端

package com.middleman.java;

public class Client {
    public static void main(String[] args) {
        Mediator qqServer = new Institution();
        Colleague userA = new Landlord(qqServer);
        Colleague userB = new Renter(qqServer);
        //房东向中介发出出租消息
        userA.sendMessage();
 
        System.out.println("***************************");
 
        //租客向中介发出租房消息
        userB.sendMessage();
    }
}

四	、实验结果


实验截图：




实验中把房产中介当做中介者，通过具体中介者对象，解耦了各个同事类之间相互依赖的场景，使同事类直接都与中介者对象发生关联。


中介者模式虽然降低了对象之间的耦合性，使得对象易于独立地被复用，并且将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。


但是，我认为具体中介者角色承担了较多的职责，其他对象都通过中介者来进行关联，一旦中介者出现了问题，整个系统将会受到重大的影响，还是要具体情况具体分析，中介者模式不一定适用于所有场景。