精华内容
下载资源
问答
  • 武汉科技大学软件设计模式实验报告完整版
  • 很多应用项目都有配置文件,这些配置文件里面定义一些应用需要的参数数据。 通常客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的...用C#控制台应用程序实现该单例模式。绘制该模式的UML图。
  • 实验题目 1.策略模式的运用 2.装饰者模式的运用 实验目的 1.策略模式的运用:策略模式定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。在熟悉策略模式相关理论知识...

     

     

    • 实验题目

    1.策略模式的运用

    2.装饰者模式的运用

    • 实验目的

    1.策略模式的运用:策略模式定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。在熟悉策略模式相关理论知识的基础上,使用策略模式实现一个小游戏。

    2.装饰者模式的运用:装饰者模式动态地将责任附加到对象上,若要扩展功能,装饰者提供了比继承更有弹性的替代方案。在熟悉装饰者模式相关理论知识的基础上,使用装设者模式实现米线店结账小程序。

    • 实验内容

    策略模式的运用:

    要求如下:

    1. 游戏中有三个角色:和尚,侠女,忍者;
    2. 每个角色都有生命值和魔法值,但各角色不同。
    3. 各角色外观不同。
    4. 每个角色具有魔法攻击和物理攻击;
    5. 物理攻击有三种:用刀、用剑、用手;
    6. 魔法攻击也有三种:火系魔法、金系魔法、水系魔法;
    7. 各角色可以动态更换物理、魔法攻击方式,也可以动态选择攻击方法。

    装饰者模式的运用:

    要求如下:

    1. 米线有三种,干浆、酸浆和水米线。
    2. 配料有三种,豆腐、鸡蛋、牛肉,今后还会更多。
    3. 客户可疑随心所欲的要各种米线搭配各种配料,配料可以加同一种加多份,或者不同种加多份。
    • 实验实现

    策略模式类图:

    1

    Table of Contents

     


    .1创建一个名为Role的抽象类

    
     package fire;
    
    public abstract class Role {
    	WuliGong wuliGong;
    	MofaGong mofaGong;
    	
    	public Role() {
    		
    	}
    	
    	public void setWuliGong(WuliGong wg) {
    		wuliGong = wg;
    	}
    	public void setMofaGong(MofaGong mg) {
    		mofaGong = mg;
    	}
    	
    	public abstract void display();
    	
    	public void performWuli() {
    		wuliGong.wuli();
    	}
    	public void performMofa() {
    		mofaGong.mofa();
    	}
    	
    	public void waiguan() {
    		System.out.println("每个角色外观不一样!");
    	}
    
    }
    1. 创建RoleHe类继承了Role类
       package edu.ccut.Dao;
      
      public class RoleHe extends Role{
      	public RoleHe() {
      		wuliGong = new WuliDao();
      		mofaGong = new MofaJin();
      	}
      	public void display() {
      		System.out.println("我是和尚");
      	}
      }

       

    1. 创建RoleMo类继承了Role类
      package edu.ccut.Dao;
      
      public class RoleMo extends Role{
      	public RoleMo() {
      		wuliGong = new WuliShou();
      		mofaGong = new MofaHuo();
      	}
      	public void display() {
      		System.out.println("我是魔女");
      	}

       

    2. 创建RoleRen类继承了Role类
      package edu.ccut.Dao;
      
      public class RoleRen extends Role{
      	public RoleRen() {
      		wuliGong = new WuliJian();
      		mofaGong = new MofaShui();
      	}
      	public void display() {
      		System.out.println("我是和尚");
      	}
      }

       

    1. 创建MofaGong接口
       package edu.ccut.Dao;
      
      public interface MofaGong {
      	public void mofa();
      
      }

       

    2. 创建MofaHuo类实现MofaGon
       package edu.ccut.Dao;
      
      public class MofaHuo implements MofaGong{
      	public void mofa() {
      		System.out.println("正在使用火系魔法攻击对方");
      	}
      
      }

       

    3. 创建MofaJin类实现MofaGong
       package edu.ccut.Dao;
      
      public class MofaJin implements MofaGong{
      	public void mofa() {
      		System.out.println("正在使用金系魔法攻击对方");
      	}
      
      }

       

    4. 创建MofaShui类ofaGong
      package edu.ccut.Dao;
      
      public class MofaShui implements MofaGong{
      	public void mofa() {
      		System.out.println("正在使用水系魔法攻击对方");
      	}
      
      }
    9.创建WuliGong接口
     package edu.ccut.Dao;
    
    public interface WuliGong {
    	public void wuli();
    
    }
    10.创建WuliDao类实现WuliGong
     package edu.ccut.Dao;
    
    public class WuliDao implements WuliGong {
    	public void wuli() {
    		System.out.println("正在使用刀攻击对方");
    	}
    
    }
    11.创建WuliJian类实现WuliGong
     package edu.ccut.Dao;
    
    public class WuliJian implements WuliGong {
    	public void wuli() {
    		System.out.println("正在使用剑攻击对方");
    	}
    
    }
    12.创建WuliShou类实现WuliGong
     package edu.ccut.Dao;
    
    public class WuliShou implements WuliGong {
    	public void wuli() {
    		System.out.println("正在使用手攻击对方");
    	}
    
    }
    13.创建Test测试类
     package edu.ccut.Dao;
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Role he = new RoleHe();
    		he.display();
    		he.performMofa();
    		he.performWuli();
    		
    		Role mo = new RoleMo();
    		mo.display();
    		mo.performMofa();
    		mo.performWuli();
    		
    		Role ren = new RoleRen();
    		ren.display();
    		ren.performMofa();
    		ren.performWuli();
    
    	}
    
    }
    

     

     

    展开全文
  • 软件体系结构实验报告设计模式):包含策略模式,代理模式,观察者模式,外观模式,组合模式,抽象工厂,单例,工厂方法,简单工厂,适配器模式,附有代码实例和类图
  • 软件设计模式概述 2GoF 的 23 种设计模式 3UML中的类图及类图之间的关系 4开闭原则 5里氏替换原则 6依赖倒置原则 7单一职责原则 8接口隔离原则 9迪米特法则 10合成复用原则 11创建型模式的特点和分类 12单例模式 13...
  • 熟练使用JAVA实现装饰模式,理解设计模式的模式动机,掌握模式结构,学习如何使用代码实现这些模式。 二、实验内容 实验1 购买咖啡时,也可以要求在其中加入各种调料 例如: 蒸奶(Steamed Milk) 豆浆(Soy)...

    实验三:装饰模式的应用
    一、实验目的
    熟练使用JAVA实现装饰模式,理解设计模式的模式动机,掌握模式结构,学习如何使用代码实现这些模式。

    二、实验内容
    实验1
    购买咖啡时,也可以要求在其中加入各种调料
    例如:
    蒸奶(Steamed Milk)
    豆浆(Soy)、
    摩卡(Mocha,也就是巧克力风味)
    调料3、调料4、调料5 ……
    于是咖啡有加奶咖啡,加调料n咖啡……
    实验2
    某软件公司基于面向对象技术开发一套图形界面构件库VisualComponent,该构件库提供了大量的的基本构件,如窗体,文本框,列表框等,由于在使用该构件库什用户经常要求定制一些特殊的显示效果,如带滚动条的窗体,带黑色边框的文本框,既带滚动条又带黑色边框的列表框等,因此经常需要时对该构件库进行扩展,以增强其功能。用装饰模式来设计该图形界面构件库。
    三、实验步骤
    第一个实验
    1.实例类图

    2.实例代码
    coffe1.java

    package a.decorate.coffee;
    
    public class coffe1 extends coffee{
    	public double cost() {
    		System.out.println("coffee1");
    		return 1.0;
    	}
    }
    

    coffe2.java

    package a.decorate.coffee;
    
    public class coffe2 extends coffee{
    	public double cost() {
    		System.out.println("coffee2");
    		return 2.0;
    	}
    }
    

    Coffee.java

    package a.decorate.coffee;
    
    public abstract class coffee {
    	String description;
    
    public abstract double cost();
    
    }
    

    Milk.java

    package a=.decorate.coffee;
    
    public class Milk extends Peiliao{
    	public Milk(coffee c) {
    		super(c);
    		System.out.println("Milk");
    		
    	}
    	public double cost() {
    		return 0.1+c.cost();
    	}
    }
    

    Peiliao.java

    package a.decorate.coffee;
    
    public abstract class Peiliao extends coffee{
    	String name;
    	coffee c;
    	public Peiliao(coffee c){
    		this.c=c;
    		
    	}
    	public abstract double cost();
    }
    

    Soy.java

    package a.decorate.coffee;
    
    public class Soy extends Peiliao{
    	public Soy(coffee c) {
    		super(c);
    		System.out.println("Soy");
    	}
    	public double cost() {
    		return 0.2+c.cost();
    	}
    }
    

    Test.java

    package a.decorate.coffee;
    
    public class Test {
    	public static void main (String[] args) {
    		coffee c1 = new coffe1();
    		Milk mc = new Milk(c1);
    		Milk mcc = new Milk(mc);
    		Soy s = new Soy(mcc);
    		System.out.println("总计:$"+s.cost());
    	}
    }
    

    3.运行结果:

    第二个实验:
    1.实例类图

    2.实例代码
    BlackBorderDecorator.java

    package a.decorate.VisualComponent;
    
    public class BlackBorderDecorator extends ComponentDecorator{
    	public BlackBorderDecorator(Component component) {
    		super(component);
    	}
    	public void display() {
    		this.setBlackBorder();
    		super.display();
    	}
    	public void setBlackBorder() {
    		System.out.println("为构件增加黑色边框!");
    	}
    }
    

    Client.java

    package a.decorate.VisualComponent;
    
    public class Client {
    	public static void main(String args[]) {
    		Component component,componentSB,componentBB;
    		component = new Window();
    		componentSB = new ScrollBarDecorator(component);
    		componentBB = new BlackBorderDecorator(componentSB);
    		componentBB.display();
    	}
    }
    

    Component.java

    package a.decorate.VisualComponent;
    
    public abstract class Component {
    	public abstract void display();
    }
    

    ComponentDecorator.java

    package a.decorate.VisualComponent;
    
    public class ComponentDecorator extends Component{
    	private Component component;
    	public ComponentDecorator(Component component) {
    		this.component=component;
    	}
    	public void display() {
    		component.display();
    	}
    }
    

    ListBox.java

    package a.decorate.VisualComponent;
    
    public class ListBox extends Component{
    	public void display(){
    		System.out.println("显示列表框!");
    	}
    }
    

    ScrollBarDecorator.java

    package a.decorate.VisualComponent;
    
    public class ScrollBarDecorator extends ComponentDecorator{
    	public ScrollBarDecorator(Component component) {
    		super(component);
    	}
    	public void display() {
    		this.setScrollBar();
    		super.display();
    	}
    	public void setScrollBar() {
    		System.out.println("为构件增加滚动条!");
    	}
    }
    

    TextBox.java

    package a.decorate.VisualComponent;
    
    public class TextBox extends Component{
    	public void display() {
    		System.out.println("显示文本框!");
    	}
    }
    

    Window.java

    package a.decorate.VisualComponent;
    
    public class Window extends Component{
    	public void display() {
    		System.out.println("显示窗体!");
    	}
    }
    

    3.运行结果:

    四、实验结果分析
    1 装饰模式的设计意图
    装饰模式降低了系统的耦合度,可以动态增加或删除对象的职责,并使需要装饰的具体构建和具体装饰的可以独立变化,以便增加新的具体构建和具体装饰的使用装饰模式,可以带来减少子类的个数,按系统扩展起来更加方便,更加可以维护。
    2 装饰模式的结构

    3 装饰模式的优点
    1、对于拓展一个对象的功能,装饰模式比距城更加灵活,不会导致类的个数急剧增加。
    2、可以通过一种动态的方式来扩展一个对象的功能,通过配置文件可以在运行时选择不同的具体装修类,从而实现不同的行为。
    3、可以对一个对象进行多次装饰,通过使用不同的具体装饰的一级,这些装饰类的排列组合,可以创造出很多不同行为的组合,得到功能更加强大的对象。
    4、具体构件内与具体装室内可以独立变化。用户可以根据需要增加新的具体构建内核构件,装饰类。原有内裤代码无需改变,符合开闭原则。
    4 装饰模式的缺点
    1、在使用装饰模式进行系统设计时将产生很多小对象。这些对象的区别在于它们之间的相互连接的方式有所不同。那不是他们的类或者属性值有所不同,大量小对象的产生,势必会占有更多的系统资源,在一定程度上影响程序的性能。
    2、装饰模式提供了一种比距城更加灵活机动的解决方案,但同时也意味着比距成更加男一女出错,排座椅面困难,对于多次装饰的对象,在调试时寻找错误,可能需要逐级排查,较为繁琐。

    欢迎您关注我的微信公众号:学习微站(studysth)在这里插入图片描述

    展开全文
  • 四个实验(两学时):策略模式、装饰者模式、抽象工厂模式、命令模式【没做GUI界面,只满足最简要求】 本文对你有用的话,记得点赞哦!以下是教科书&参考书 策略模式 Strategy Pattern 策略模式定义了...

    四个实验(两学时):策略模式、装饰者模式、抽象工厂模式、命令模式【没做GUI界面,只满足最简要求】

    本文对你有用的话,记得点赞哦!以下是教科书&参考书 

    策略模式 Strategy Pattern

           策略模式定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户。在熟悉策略模式相关理论知识的基础上,使用策略模式实现一个小游戏。

    一、基本要求

           使用策略模式实现一个小游戏,要求如下:

    1. 游戏中有三个角色:和尚,侠女,忍者;
    2. 每个角色都有生命值和魔法值,但各角色不同。
    3. 各角色外观不同。
    4. 每个角色具有魔法攻击和物理攻击;
    5. 物理攻击有三种:用刀、用剑、用手;
    6. 魔法攻击也有三种:火系魔法、金系魔法、水系魔法;

           各角色可以动态更换物理、魔法攻击方式,也可以动态选择攻击方法。

           笔者推荐参考https://blog.csdn.net/qq_42685588/article/details/103576562

    二、实验内容

           1. 设计并绘制该程序的类图;

           2. 依照设计的类图使用Java语言编写代码,并实现该程序;

           3. 除了核心的模式相关类实现外,提供测试环境,按照难度高低,分别是:

                  a)控制台程序,Client硬编码初始化模式和测试环境,运行结果文本输出;

                  b)控制台程序,Client初始化测试环境,并根据用户输入运算,运行结果文本输出;

                  c)设计并实现用户UI,Client初始化测试环境,并根据用户在UI控件上的输入运算,运行结果文本输出;

    三、实验提示

           1. 策略模式的结构和组件

    • Strategy:定义所有支持算法的公共接口,Context使用该接口调用某ConcreteStrategy定义的算法;
    • ConcreteStrategy:以Strategy接口实现某具体算法;
    • Context:用一个ConcreteStrategy对象来配置,维护一个对Strategy对象的引用,可定义一个接口来让Strategy访问它的数据;

           2. 策略模式代码提示 【出自《Head First设计模式》一书

           SimUDuck范例:将duck的行为理解为 “一组行为”,并使用策略模式的“一族算法”来进行实现。

            Duck基类

    public abstract class Duck {
    	FlyBehavior flyBehavior;
    	QuackBehavior quackBehavior;
     
    	public Duck() {
    	}
     
    	public void setFlyBehavior (FlyBehavior fb) {
    		flyBehavior = fb;
    	}
     
    	public void setQuackBehavior(QuackBehavior qb) {
    		quackBehavior = qb;
    	}
     
    	abstract void display();
     
    	public void performFly() {
    		flyBehavior.fly();
    	}
     
    	public void performQuack() {
    		quackBehavior.quack();
    	}
     
    	public void swim() {
    		System.out.println("All ducks float, even decoys!");
    	}
    }

            FlyBehavior和QuackBehavior接口

    public interface QuackBehavior {
    	public void quack();
    }
    
    public interface FlyBehavior {
    	public void fly();
    }

           FlyWithWings具体行为

    public class FlyWithWings implements FlyBehavior {
    	public void fly() {
    		System.out.println("I'm flying!!");
    	}
    }

            MiniDuckSimulator测试环境

    public class MiniDuckSimulator {
     
    	public static void main(String[] args) {
     
    		MallardDuck	mallard = new MallardDuck();
    		RubberDuck rubberDuckie = new RubberDuck();
    		DecoyDuck decoy = new DecoyDuck();
    
    		ModelDuck model = new ModelDuck();
    
    		mallard.performQuack();
    		rubberDuckie.performQuack();
    		decoy.performQuack();
       
    		model.performFly();	
    		model.setFlyBehavior(new FlyRocketPowered());
    		model.performFly();
    	}
    }
    

     四、实验原理(算法或图)

                                                                                   图1 策略模式类图 

    五、源代码

    Role(基类)

    public abstract class Role {
    	Magic magic;
    	Physics physics;
    	
    	public Role(Magic magic, Physics physics) {
    		setMagic(magic);
    		setPhysics(physics);
    	};
    	
    	public abstract void display();
    	
    	public void performMagic() {
    		magic.magicAttack();
    	}
    	
    	public void performPhysics() {
    		physics.physicsAttack();
    	}
    	
    	public void setMagic(Magic magic) {
    		this.magic = magic;
    	}
    	
    	public void setPhysics(Physics physics) {
    		this.physics = physics;
    	}
    }

    Monk和尚、Heroine侠女、Ninja忍者(子类)

    public class Monk extends Role {
    	public Monk(Magic magic, Physics physics) {
    		super(magic, physics);
    	}
    
    	@Override
    	public void display() {
    		System.out.println("我外貌像个和尚");
    	}
    }
    public class Heroine extends Role {
    	public Heroine(Magic magic, Physics physics) {
    		super(magic, physics);
    	}
    
    	@Override
    	public void display() {
    		System.out.println("我外貌像个侠女");
    	}
    }
    public class Ninja extends Role {
    	public Ninja(Magic magic, Physics physics) {
    		super(magic, physics);
    	}
    
    	@Override
    	public void display() {
    		System.out.println("我外貌像个忍者");
    	}
    }

    Magic接口 

    public interface Magic {
    	public void magicAttack() ;
    }

    实现Magic的类

    public class MagicFire implements Magic {
    	@Override
    	public void magicAttack() {
    		System.out.println("正在使用火系魔法攻击");
    	}
    }
    public class MagicGold implements Magic {
    	@Override
    	public void magicAttack() {
    		System.out.println("正在使用金系魔法攻击");
    	}
    }
    public class MagicWater implements Magic {
    	@Override
    	public void magicAttack() {
    		System.out.println("正在使用水系魔法攻击");
    	}
    }

    Physics接口

    public interface Physics {
    	public void physicsAttack() ;
    }

    实现Physics的类

    public class PhysicsHand implements Physics {
    	@Override
    	public void physicsAttack() {
    		System.out.println("正在使用手进行物理攻击");
    	}
    }
    public class PhysicsKnife implements Physics {
    	@Override
    	public void physicsAttack() {
    		System.out.println("正在使用刀进行物理攻击");
    	}
    }
    public class PhysicsSword  implements Physics {
    	@Override
    	public void physicsAttack() {
    		System.out.println("正在使用剑进行物理攻击");
    	}
    }

    Test类

    public class Test {
    	public static void main(String[] args) {
    		Monk monk = new Monk(new MagicGold(), new PhysicsHand());
    		monk.display();
    		monk.performPhysics();
    		monk.performMagic();
    		
    		Heroine heroine  =new Heroine(new MagicWater(), new PhysicsSword());
    		heroine.display();
    		heroine.performPhysics();
    		heroine.performMagic();
    		
    		Ninja ninja = new Ninja(new MagicFire(), new PhysicsSword());
    		ninja.display();
    		ninja.performPhysics();
    		ninja.performMagic();
    	}
    }

     六、运行结果

     装饰者模式 Decorator Pattern

            装饰者模式动态地将责任附加到对象上,若要扩展功能,装饰者提供了比继承更有弹性的替代方案。在熟悉装饰者模式相关理论知识的基础上,使用装设者模式实现米线店结账小程序。

    一、基本要求

            使用装饰者模式实现米线店结账程序,要求如下:

    1. 米线有三种,干浆、酸浆和水米线。
    2. 配料有三种,豆腐、鸡蛋、牛肉,今后还会更多。
    3. 客户可疑随心所欲的要各种米线搭配各种配料,配料可以加同一种加多份,或者不同种加多份。

    二、实验内容

            1. 设计并绘制该程序的类图;

            2. 依照设计的类图使用Java语言编写代码,并实现该程序;

            3. 除了核心的模式相关类实现外,提供测试环境,按照难度高低,分别是:

                  a)控制台程序,Client硬编码初始化模式和测试环境,运行结果文本输出;

                  b)控制台程序,Client初始化测试环境,并根据用户输入运算,运行结果文本输出;

                  c)设计并实现用户UI,Client初始化测试环境,并根据用户在UI控件上的输入运算,运行结果文本输出;

    三、实验提示

            1. 装饰者模式的结构和组件

    • Component:对象接口,可以给对象动态地添加职责;
    • Concrete Component:具体对象;
    • Decorator:维持一个指向Component对象的指针,并定义一个与Component接口一致的接口;
    • ConcreteDecorator:向组件添加职责;
    • Decorator将请求转发给它的Component对象,并有可能在转发请求前后执行一些附加的动作;

            2. 装饰者模式代码提示

            Starbuzz范例:以饮料为主体,然后在运行时以调料来“装饰”饮料。

            Beverage 基类

    public abstract class Beverage {
    	String description = "Unknown Beverage";
      
    	public String getDescription() {
    		return description;
    	}
     
    	public abstract double cost();
    }

            HouseBlend 具体饮料类

    public class HouseBlend extends Beverage {
    	public HouseBlend() {
    		description = "House Blend Coffee";
    	}
     
    	public double cost() {
    		return .89;
    	}
    }

            CondimentDecorator 调料基类

    public abstract class CondimentDecorator extends Beverage {
    	public abstract String getDescription();
    }

            Soy 具体调料类

    public class Soy extends CondimentDecorator {
    	Beverage beverage;
    
    	public Soy(Beverage beverage) {
    		this.beverage = beverage;
    	}
    
    	public String getDescription() {
    		return beverage.getDescription() + ", Soy";
    	}
    
    	public double cost() {
    		return .15 + beverage.cost();
    	}
    }

            StarbuzzCoffee 测试环境

    public class StarbuzzCoffee {
     
    	public static void main(String args[]) {
    		Beverage beverage = new Espresso();
    		System.out.println(beverage.getDescription() + " $" + beverage.cost());
     
    		Beverage beverage2 = new DarkRoast();
    		beverage2 = new Mocha(beverage2);
    		beverage2 = new Mocha(beverage2);
    		beverage2 = new Whip(beverage2);
    		System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
     
    		Beverage beverage3 = new HouseBlend();
    		beverage3 = new Soy(beverage3);
    		beverage3 = new Mocha(beverage3);
    		beverage3 = new Whip(beverage3);
    		System.out.println(beverage3.getDescription() + " $" + beverage3.cost());
    	}
    }

    四、实验原理(算法或图)

     五、源码

    Noodles基类

    public abstract class Noodles {
    	private String description = null;
    	
    	public String getDescription() {
    	 	return description;
    	}
    
    	public void setDescription(String description) {
    	 	this.description = description;
    	}
    
    	public abstract double cost();
    }

     继承Noodles的类

    public class NoodlesAcid extends Noodles {
    	public NoodlesAcid() {
        	String description="酸浆米线";
    		setDescription(description);
        }
    	
    	@Override
    	public double cost() {
    		return 3;
    	}
    }
    public class NoodlesDry extends Noodles {
    	public NoodlesDry() {
    		String description="干浆米线";
    		setDescription(description);
    	}
    	
    	@Override
    	public double cost() {
    		return 2;
    	}
    }
    public class NoodlesWater extends Noodles {
    	public NoodlesWater() {
        	String description="水米线";
    		setDescription(description);
        }
    	
    	@Override
    	public double cost() {
    		return 2;
    	}
    }

    Ingredients基类

    public abstract class Ingredients extends Noodles {
    	public abstract String getDescription();
    		
    	@Override
    	public double cost() {
    		return 0;
    	}	
    }

     继承Ingredients的类

    public class Beef extends Ingredients{
    	private Noodles noodles=null;
        
    	public Beef(Noodles noodles){
    		this.noodles = noodles;
    	}
    	
    	@Override
    	public String getDescription() {
    		String str = noodles.getDescription();
    		
    		if(str.indexOf("牛肉") != -1){
    			return str;
    		}else{
    			return "牛肉" + noodles.getDescription();
    		}
    	}
    	
    	public double cost(){
    		return 5 + noodles.cost();
    	}
    }
    public class Egg extends Ingredients {
    	private Noodles noodles=null;
        
    	public Egg(Noodles noodles){
    		this.noodles = noodles;
    	}
    	
    	@Override
    	public String getDescription() {
    		String str = noodles.getDescription();
    		
    		if(str.indexOf("鸡蛋") != -1){
    			return str;
    		}else{
    			return "鸡蛋" + noodles.getDescription();
    		}
    	}
    	
    	public double cost(){
    		return 2 + noodles.cost();
    	}
    }
    public class Tofu extends Ingredients{
    	private Noodles noodles=null;
        
    	public Tofu(Noodles noodles){
    		this.noodles = noodles;
    	}
    	
    	@Override
    	public String getDescription() {
    		String str = noodles.getDescription();
    		
    		if(str.indexOf("豆腐") != -1){
    			return str;
    		}else{
    			return "豆腐" + noodles.getDescription();
    		}
    	}
    	
    	public double cost(){
    		return 2.5 + noodles.cost();
    	}
    }

    Test类

    public class Test {
    	public static void main(String[] args) {
    	    Noodles noodles1 = new NoodlesDry();
    	    noodles1 = new Egg(noodles1);
    	    noodles1 = new Beef(noodles1);
    	    System.out.println(noodles1.getDescription() + noodles1.cost());
    	    
    	    Noodles noodles2 = new NoodlesAcid();
    	    noodles2 = new Tofu(noodles2);
    	    noodles2 = new Beef(noodles2);
    	    System.out.println(noodles2.getDescription() + noodles2.cost());
    	}
    }

    六、实验结果

     抽象工厂模式 Abstract Factory Pattern

            抽象工厂模式提供一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。在熟悉抽象工厂模式相关理论知识的基础上,使用抽象工厂模式实现“电脑配置商店”程序。 

    一、基本要求

    使用抽象工厂模式实现“电脑配置商店”,要求如下:

    1. 电脑由CPU、主板、显卡、内存、硬盘等配件组合而成。现电脑配置有两种配置方案。
    2. 根据配置方案可以显示具体配置信息。
    3. 根据配置方案可以显示价格。

    二、实验内容

            1. 设计并绘制该程序的类图;

            2. 依照设计的类图使用Java语言编写代码,并实现该程序;

            3. 除了核心的模式相关类实现外,提供测试环境,按照难度高低,分别是:

                    a)控制台程序,Client硬编码初始化模式和测试环境,运行结果文本输出;

                    b)控制台程序,Client初始化测试环境,并根据用户输入运算,运行结果文本输出;

                    c)设计并实现用户UI,Client初始化测试环境,并根据用户在UI控件上的输入运算,运行结果文本输出;

    三、实验提示

            1. 抽象工厂模式的结构和组件

    • Abstract Factory:声明创建抽象产品对象的操作接口;
    • ConcreteFactory:实现创建具体对象的操作;
    • Abstract Product:为一类产品对象声明一个接口;
    • ConcreteProduct:定义一个被具体工厂创建的产品对象;

            2. 抽象工厂模式代码提示

            PizzaStore范例:抽象工厂允许客户使用抽象的接口来创建一组相关的产品,而不需要知道实际产出的具体产品是什么,这样一来,客户就从具体的产品中被解耦。

            PizzaIngredientFactory 接口

    public interface PizzaIngredientFactory {
     
    	public Dough createDough();
    	public Sauce createSauce();
    	public Cheese createCheese();
    	public Veggies[] createVeggies();
    	public Pepperoni createPepperoni();
    	public Clams createClam();
    }

            ChicagoPizzaIngredientFactory 具体实现类

    public class ChicagoPizzaIngredientFactory 
    	implements PizzaIngredientFactory 
    {
    
    	public Dough createDough() {
    		return new ThickCrustDough();
    	}
    
    	public Sauce createSauce() {
    		return new PlumTomatoSauce();
    	}
    
    	public Cheese createCheese() {
    		return new MozzarellaCheese();
    	}
    
    	public Veggies[] createVeggies() {
    		Veggies veggies[] = { new BlackOlives(), 
    		                      new Spinach(), 
    		                      new Eggplant() };
    		return veggies;
    	}
    
    	public Pepperoni createPepperoni() {
    		return new SlicedPepperoni();
    	}
    
    	public Clams createClam() {
    		return new FrozenClams();
    	}
    }

            Pizza 基类

    public abstract class Pizza {
    	String name;
    
    	Dough dough;
    	Sauce sauce;
    	Veggies veggies[];
    	Cheese cheese;
    	Pepperoni pepperoni;
    	Clams clam;
    
    	abstract void prepare();
    
    	void bake() {
    		System.out.println("Bake for 25 minutes at 350");
    	}
    
    	void cut() {
    		System.out.println("Cutting the pizza into diagonal slices");
    	}
    
    	void box() {
    		System.out.println("Place pizza in official PizzaStore box");
    	}
    
    	void setName(String name) {
    		this.name = name;
    	}
    
    	String getName() {
    		return name;
    	}
    
    	public String toString() {
    		StringBuffer result = new StringBuffer();
    		result.append("---- " + name + " ----\n");
    		if (dough != null) {
    			result.append(dough);
    			result.append("\n");
    		}
    		if (sauce != null) {
    			result.append(sauce);
    			result.append("\n");
    		}
    		if (cheese != null) {
    			result.append(cheese);
    			result.append("\n");
    		}
    		if (veggies != null) {
    			for (int i = 0; i < veggies.length; i++) {
    				result.append(veggies[i]);
    				if (i < veggies.length-1) {
    					result.append(", ");
    				}
    			}
    			result.append("\n");
    		}
    		if (clam != null) {
    			result.append(clam);
    			result.append("\n");
    		}
    		if (pepperoni != null) {
    			result.append(pepperoni);
    			result.append("\n");
    		}
    		return result.toString();
    	}
    }

            Dough 接口及实现

    public interface Dough {
    	public String toString();
    }
    
    public class ThickCrustDough implements Dough {
    	public String toString() {
    		return "ThickCrust style extra thick crust dough";
    	}
    }

             PizzaTestDrive 测试环境

    public class PizzaTestDrive {
     
    	public static void main(String[] args) {
    		PizzaStore nyStore = new NYPizzaStore();
    		PizzaStore chicagoStore = new ChicagoPizzaStore();
     
    		Pizza pizza = nyStore.orderPizza("cheese");
    		System.out.println("Ethan ordered a " + pizza + "\n");
     
    		pizza = chicagoStore.orderPizza("cheese");
    		System.out.println("Joel ordered a " + pizza + "\n");
    
    		pizza = nyStore.orderPizza("clam");
    		System.out.println("Ethan ordered a " + pizza + "\n");
     
    		pizza = chicagoStore.orderPizza("clam");
    		System.out.println("Joel ordered a " + pizza + "\n");
    
    		pizza = nyStore.orderPizza("pepperoni");
    		System.out.println("Ethan ordered a " + pizza + "\n");
     
    		pizza = chicagoStore.orderPizza("pepperoni");
    		System.out.println("Joel ordered a " + pizza + "\n");
    
    		pizza = nyStore.orderPizza("veggie");
    		System.out.println("Ethan ordered a " + pizza + "\n");
     
    		pizza = chicagoStore.orderPizza("veggie");
    		System.out.println("Joel ordered a " + pizza + "\n");
    	}
    }

    四、实验原理

    五、源码

    ComputerStore类

    public abstract class ComputerStore {
    	ComputerFactory computer;
    	public abstract ComputerFactory createComputer(String type) ;
    }

    继承ComputerStore的类

    public class Computer extends ComputerStore{
    	public  ComputerFactory createComputer(String type){
    		ComputerFactory computer=null;
    		if(type.equals("A")){
    			computer=new AFactory();
    		}
    		else if(type.equals("B")){
    			computer=new BFactory();
    		}
    		
    		computer.createCpu();
    		computer.createGraphicsCard();
    		computer.createHarddisk();
    		computer.createMainboard();
    		computer.createRam();
    		computer.displayPrice();
    		return computer;
    	}
    }

     ComputerFactory接口

    public interface ComputerFactory {
    	public Cpu createCpu(); 
    	public Mainboard createMainboard(); 
    	public GraphicsCard createGraphicsCard();
    	public Ram createRam();  
    	public Harddisk createHarddisk(); 
    	public void displayPrice();
    }

    实现ComputerFactory的类

    public class AFactory implements ComputerFactory{
    	public AFactory(){
    		System.out.println("\n方案A:");
    	}
    	
    	public Cpu createCpu() {
    		return new ACpu();
    	}
    	
    	public Mainboard createMainboard() {
    		return new AMainboard();
    	}
    	
    	public GraphicsCard createGraphicsCard() {
    		return new AGraphicsCard();
    	}
    	
    	public Ram createRam() {
    		return new ARam();
    	}
    	
    	public Harddisk createHarddisk() {
    		return new AHarddisk();
    	}
    	
    	public void displayPrice() {
    		System.out.println("RMB:4000");
    	}	
    }
    public class BFactory implements ComputerFactory{
    	public BFactory(){
    		System.out.println("\n方案B:");
    	}
    	public Cpu createCpu() {
    		return new BCpu();
    	}
    	public Mainboard createMainboard() {
    		return new BMainboard();
    	}
    	public GraphicsCard createGraphicsCard() {
    		return new BGraphicsCard();
    	}
    	public Ram createRam() {
    		return new BRam();
    	}
    	public Harddisk createHarddisk() {
    		return new BHarddisk();
    	}
    	public void displayPrice() {
    		System.out.println("RMB:8000");
    	}
    }

     Cpu接口

    public interface Cpu {
    	String Cpu=new String();
    }

    实现Cpu的类

    public class ACpu implements Cpu {
    	String Cpu = new String();
    	
    	public ACpu(){
    		Cpu="Intel i5";
    		System.out.println("Cpu:" + Cpu);
    	}
    }
    public class BCpu implements Cpu {
    	String Cpu = new String();
    	
    	public BCpu(){
    		Cpu="Intel i7";
    		System.out.println("Cpu:" + Cpu);
    	}
    }

     GraphicsCard接口

    public interface GraphicsCard {
    	String GraphicsCard=new String(); 
    }

    实现GraphicsCard的类

    public class AGraphicsCard implements GraphicsCard{
    	String GraphicsCard=new String();
    	
    	public AGraphicsCard(){
    		GraphicsCard="GTX 1050";
    		System.out.println("GraphicsCard:"+GraphicsCard);
    	}
    }
    public class BGraphicsCard implements GraphicsCard{
    	String GraphicsCard = new String();
    	
    	public BGraphicsCard(){
    		GraphicsCard="GTX 1050Ti";
    		System.out.println("GraphicsCard:"+GraphicsCard);
    	}
    }

     Harddisk接口

    public interface Harddisk {
    	String Harddisk=new String();
    }

    实现Harddisk的类

    public class AHarddisk implements Harddisk{
    	String Harddisk=new String();
    	
    	public AHarddisk(){
    		Harddisk="HDD 1T";
    		System.out.println("Harddisk:"+Harddisk);
    	}
    }
    public class BHarddisk implements Harddisk {
    	String Harddisk=new String();
    	
    	public BHarddisk(){
    		Harddisk="SSD 1T";
    		System.out.println("Harddisk:"+Harddisk);
    	}
    }

     Mianboard接口

    public interface Mainboard {
    	String Mainboard=new String();
    }

    继承Mianboard的类

    public class AMainboard implements Mainboard{
    	String Mainboard=new String();
    	
    	public AMainboard(){
    		Mainboard="ASUS";
    		System.out.println("Mainboard:"+Mainboard);
    	}
    }
    public class BGraphicsCard implements GraphicsCard{
    	String GraphicsCard = new String();
    	
    	public BGraphicsCard(){
    		GraphicsCard="GTX 1050Ti";
    		System.out.println("GraphicsCard:"+GraphicsCard);
    	}
    }

     Ram接口

    public interface Ram {
    	String Ram =new String();
    }

    实现Ram的类

    public class ARam implements Ram{
    	String Ram=new String();
    	
    	public ARam(){
    		Ram="4g";
    		System.out.println("Ram:"+Ram);
    	}
    }
    public class BRam implements Ram{
    	String Ram=new String();
    
    	public BRam(){
    		Ram="8g";
    		System.out.println("Ram:"+Ram);
    	}
    }

    Test类

    import java.util.Scanner;
    
    public class Test {
    	public static void main(String[] args) {
    		Computer computer=new Computer ();
    		Scanner sc = new Scanner(System.in);
    		System.out.println("选项选择电脑配置方案 (A or B)");
        	String k = sc.nextLine();
        	sc.close();
        	switch(k){
        	case "A": case "a":
        		computer.createComputer("A");
        		break;
        	case "B": case "b":
        		computer.createComputer("B");
        		break;
        	default:
        		System.out.println("不存在所选择方案");
        		break;
        	}
    	}
    }
    

     六、实验结果

    命令模式 Command Pattern

            命令模式将“请求”封装成对象,以便使用不同的请求、队列或者日志来参数化其他对象,命令模式也支持可撤销的操作。在熟悉命令模式相关理论知识的基础上,使用命令模式实现图片处理程序。

    一、基本要求

            使用命令模式实现图片处理程序,要求如下:

    1. 图片处理程序要有3张图片。
    2. 每张图片至少有3种操作。
    3. 实现类似遥控器的菜单,动态的选择对图片进行的处理。
    4. 要有“撤消操作”,撤消操作要可以撤销至最后一步。

    二、 实验内容

            1. 设计并绘制该程序的类图;

            2. 依照设计的类图使用Java语言编写代码,并实现该程序;

            3. 除了核心的模式相关类实现外,提供测试环境,按照难度高低,分别是:

                    a)控制台程序,Client硬编码初始化模式和测试环境,运行结果文本输出;

                    b)控制台程序,Client初始化测试环境,并根据用户输入运算,运行结果文本输出;

                    c)设计并实现用户UI,Client初始化测试环境,并根据用户在UI控件上的输入运算,运行结果文本输出;

    三、实验提示

            1. 命令模式的结构和组件

    • Command:声明执行操作的接口;
    • ConcreteCommand:将一个接收者对象绑定于一个动作,调用接收者相应的操作;
    • Client(Application):创建一个具体命令对象并设定其接收者;
    • Invoker(MenuItem):要求命令执行请求;
    • Receiver(Document,Application):知道如何实施与执行一个请求相关的操作;

             2. 命令模式代码提示

            RemoteControl范例:命令对象将动作和接收者包进对象中。这个对象只暴露出一个execute()方法,当此方法调用的时候,接收者就会进行这些动作。

             RemoteControl类

    public class RemoteControl {
    	Command[] onCommands;
    	Command[] offCommands;
     
    	public RemoteControl() {
    		onCommands = new Command[7];
    		offCommands = new Command[7];
     
    		Command noCommand = new NoCommand();
    		for (int i = 0; i < 7; i++) {
    			onCommands[i] = noCommand;
    			offCommands[i] = noCommand;
    		}
    	}
      
    	public void setCommand(int slot, Command onCommand, Command offCommand) {
    		onCommands[slot] = onCommand;
    		offCommands[slot] = offCommand;
    	}
     
    	public void onButtonWasPushed(int slot) {
    		onCommands[slot].execute();
    	}
     
    	public void offButtonWasPushed(int slot) {
    		offCommands[slot].execute();
    	}
      
    	public String toString() {
    		StringBuffer stringBuff = new StringBuffer();
    		stringBuff.append("\n------ Remote Control -------\n");
    		for (int i = 0; i < onCommands.length; i++) {
    			stringBuff.append("[slot " + i + "] " + onCommands[i].getClass().getName()
    				+ "    " + offCommands[i].getClass().getName() + "\n");
    		}
    		return stringBuff.toString();
    	}
    }

             Command类

    public interface Command {
    	public void execute();
    }

             Light类

    public class Light {
    	String location = "";
    
    	public Light(String location) {
    		this.location = location;
    	}
    
    	public void on() {
    		System.out.println(location + " light is on");
    	}
    
    	public void off() {
    		System.out.println(location + " light is off");
    	}
    }

             LightOnCommand类

    public class LightOnCommand implements Command {
    	Light light;
    
    	public LightOnCommand(Light light) {
    		this.light = light;
    	}
    
    	public void execute() {
    		light.on();
    	}
    }

             测试环境RemoteLoader

    public class RemoteLoader {
     
    	public static void main(String[] args) {
    		RemoteControl remoteControl = new RemoteControl();
     
    		Light livingRoomLight = new Light("Living Room");
    		Light kitchenLight = new Light("Kitchen");
    		CeilingFan ceilingFan= new CeilingFan("Living Room");
    		GarageDoor garageDoor = new GarageDoor("");
    		Stereo stereo = new Stereo("Living Room");
      
    		LightOnCommand livingRoomLightOn = 
    				new LightOnCommand(livingRoomLight);
    		LightOffCommand livingRoomLightOff = 
    				new LightOffCommand(livingRoomLight);
    		LightOnCommand kitchenLightOn = 
    				new LightOnCommand(kitchenLight);
    		LightOffCommand kitchenLightOff = 
    				new LightOffCommand(kitchenLight);
      
    		CeilingFanOnCommand ceilingFanOn = 
    				new CeilingFanOnCommand(ceilingFan);
    		CeilingFanOffCommand ceilingFanOff = 
    				new CeilingFanOffCommand(ceilingFan);
     
    		GarageDoorUpCommand garageDoorUp =
    				new GarageDoorUpCommand(garageDoor);
    		GarageDoorDownCommand garageDoorDown =
    				new GarageDoorDownCommand(garageDoor);
     
    		StereoOnWithCDCommand stereoOnWithCD =
    				new StereoOnWithCDCommand(stereo);
    		StereoOffCommand  stereoOff =
    				new StereoOffCommand(stereo);
     
    		remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
    		remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
    		remoteControl.setCommand(2, ceilingFanOn, ceilingFanOff);
    		remoteControl.setCommand(3, stereoOnWithCD, stereoOff);
      
    		System.out.println(remoteControl);
     
    		remoteControl.onButtonWasPushed(0);
    		remoteControl.offButtonWasPushed(0);
    		remoteControl.onButtonWasPushed(1);
    		remoteControl.offButtonWasPushed(1);
    		remoteControl.onButtonWasPushed(2);
    		remoteControl.offButtonWasPushed(2);
    		remoteControl.onButtonWasPushed(3);
    		remoteControl.offButtonWasPushed(3);
    	}
    }

    四、实验原理

    五、源码

    图片类

    public class Picture1 {
    	public String rotate(){
    		 return "Picture1旋转";
    	}
    	
    	public String cut(){
    		return "Picture1剪切";
    	}
    
    	public String mirror(){
    		return "Picture1镜像";
    	}
    }
    public class Picture2 {
    	public String adjustContrast(){
    		return "picture2调节对比度";
    	}
    	
    	public String adjustBrightness(){
    		return "picture2调节亮度";
    	}
    	
    	public String adjustSaturation(){
    		return "picture2调节饱和度";
    	}
    }
    public class Picture3 {
    	public String zoomIn(){
    		return "Picture3放大";
    	}
    
    	public String zoomOut(){
    		return "Picture3缩小";
    	}
    
    	public String warping(){
    		return "Picture3扭曲";
    	}
    }

    Command接口

    public interface Command {
    	public String execute();
    }

    实现Command的类 

    public class CommandCut implements Command {
    	Picture1 picture = null;
    	
        public CommandCut(Picture1 picture){
        	this.picture = picture;
        }
        
    	@Override
    	public String execute() {
    		return picture.cut();
    	}
    }
    public class CommandMirror implements Command {
    	Picture1 picture = null;
    	
        public CommandMirror(Picture1 picture){
        	this.picture = picture;
        }
        
    	@Override
    	public String execute() {
    		return picture.mirror();
    	}
    }
    public class CommandRotate implements Command {
    	Picture1 picture = null;
    	
        public CommandRotate(Picture1 picture){
        	this.picture = picture;
        }
        
    	@Override
    	public String execute() {
    		return picture.rotate();
    	}
    }
    public class CommandWarping implements Command {
    	Picture3 picture = null;
    	
        public CommandWarping(Picture3 picture){
        	this.picture = picture;
        }
        
    	@Override
    	public String execute() {
    		return picture.warping();
    	}
    }
    public class CommandZoomIn implements Command {
    	Picture3 picture = null;
    	
        public CommandZoomIn(Picture3 picture){
        	this.picture = picture;
        }
        
    	@Override
    	public String execute() {
    		return picture.zoomIn();
    	}
    }
    public class CommandZoomOut implements Command {
    	Picture3 picture = null;
    	
        public CommandZoomOut(Picture3 picture){
        	this.picture = picture;
        }
        
    	@Override
    	public String execute() {
    		return picture.zoomOut();
    	}
    }
    public class CommandNo implements Command{
    	@Override
    	public String execute() {
    		return null;
    	}
    }
    public class CommandRevoke implements Command {
    	Command command = null;
    	
        public CommandRevoke(Command command){
        	this.command = command;
        }
        
    	@Override
    	public String execute() {
    		return "已撤销上一步:" + command.execute();
    	}
    }

     Test类

    public class Test {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		Command command = null;
    		while(true) {
    			System.out.println("选择要处理的图片:\n1)图片1;2)图片2;3)图片3;0)撤销");
    	    	String k = sc.nextLine();
    	    	switch(k) {
    	    	case "1":
    	    		Picture1 picture1 = new Picture1();
    	    		System.out.println("选择处理方式:\n1)旋转;2)剪切;3)镜像");
    	    		String key1 = sc.nextLine();
    	    		switch(key1) {
    	    		case "1": command = new CommandRotate(picture1); break;
    	    		case "2": command = new CommandCut(picture1); break;
    	    		case "3": command = new CommandMirror(picture1); break;
    	    		default: command = new CommandNo(); break;
    	    		}
    	    		break;
    	    	case "2":
    	    		Picture2 picture2 = new Picture2();
    	    		System.out.println("选择处理方式:\n1)调节对比度;2)调节亮度;3)调节饱和度");
    	    		String key2 = sc.nextLine();
    	    		switch(key2) {
    	    		case "1": command = new CommandAdjustContrast(picture2); break;
    	    		case "2": command = new CommandAdjustBrightness(picture2); break;
    	    		case "3": command = new CommandAdjustSaturation(picture2); break;
    	    		default: command = new CommandNo(); break;
    	    		}
    	    		break;
    	    	case "3":
    	    		Picture3 picture3 = new Picture3();
    	    		System.out.println("选择处理方式:\n1)放大;2)缩小;3)扭曲");
    	    		String key3 = sc.nextLine();
    	    		switch(key3) {
    	    		case "1": command = new CommandZoomIn(picture3); break;
    	    		case "2": command = new CommandZoomOut(picture3); break;
    	    		case "3": command = new CommandWarping(picture3); break;
    	    		default: command = new CommandNo(); break;
    	    		}
    	    		break;
    	    	case "0":
    	    		command = new CommandRevoke(command);
    	    		break;
    	    	}
    	    	System.out.println(command.execute());
    		}
    	}
    }

    六、实验结果

    展开全文
  • 实 验 报 告 题    目     命令模式 课    程     设计模式 专    业     软件工程 班    级  ...

    实 验 报 告

    题    目     命令模式
    课    程     设计模式
    专    业     软件工程
    班    级     软件1814班
    姓    名     你猜
    学    号     20188888888

    一、实验名称

    创建型设计模式实验

    二、实验目的

    1、熟悉命令模式的概念。
    2、掌握命令模式的类图。
    3、根据命令模式类图编写代码。

    三、实验内容与结果分析

    1、程序UML类图
    在这里插入图片描述
    2、运行效果
    在这里插入图片描述
    3、Order.java程序代码

    package CommandPattern_Book;
    
    public interface Order {
        void doExecute();
        void undoExecute();
    }
    

    4、Light.java程序代码

    package CommandPattern_Book;
    
    import javafx.scene.image.Image;
    import javafx.scene.image.ImageView;
    
    class Light extends ImageView{
        private Image image1 = new Image("/CommandPattern_Book/ex_01.png");
        private Image image2 = new Image("/CommandPattern_Book/ex_02.png");
    
        void on() {
            this.setImage(image1);
            this.setSmooth(true);
            this.setCache(true);
            this.setFitHeight(200);
            this.setFitWidth(200);
        }
    
        void off() {
            this.setImage(image2);
            this.setSmooth(true);
            this.setCache(true);
            this.setFitHeight(200);
            this.setFitWidth(200);
        }
    
    }
    

    5、Camera.java程序代码

    package CommandPattern_Book;
    
    import javafx.scene.image.Image;
    import javafx.scene.image.ImageView;
    
    class Camera extends ImageView {
        private Image image1 = new Image("/CommandPattern_Book/ex_03.png");
        private Image image2 = new Image("/CommandPattern_Book/ex_04.png");
    
        void on() {
            this.setImage(image1);
            this.setSmooth(true);
            this.setCache(true);
            this.setFitHeight(200);
            this.setFitWidth(200);
        }
    
        void off() {
            this.setImage(image2);
            this.setSmooth(true);
            this.setCache(true);
            this.setFitHeight(200);
            this.setFitWidth(200);
        }
    }
    

    6、Operation.java程序代码

    package CommandPattern_Book;
    
    public enum Operation {
        OnLight,
        OffLight,
        OnCamera,
        OffCamera
    }
    

    7、OffCameraOrder.java程序代码

    package CommandPattern_Book;
    
    public class OffCameraOrder implements  Order {
        private Camera camera;
    
        OffCameraOrder(Camera camera) {
            this.camera = camera;
        }
    
        @Override
        public void doExecute() {
            camera.off();
        }
    
        @Override
        public void undoExecute() {
            camera.on();
        }
    }
    

    8、OffLightOrder.java程序代码

    package CommandPattern_Book;
    
    public class OffLightOrder implements Order {
        private Light light;
    
        OffLightOrder(Light light) {
            this.light = light;
        }
    
        @Override
        public void doExecute() {
            light.off();
        }
    
        @Override
        public void undoExecute() {
            light.on();
        }
    }
    

    9、OnCameraOrder.java程序代码

    package CommandPattern_Book;
    
    public class OnCameraOrder implements Order {
        private Camera camera;
    
        OnCameraOrder(Camera camera) {
            this.camera = camera;
        }
    
        @Override
        public void doExecute() {
            camera.on();
        }
    
        @Override
        public void undoExecute() {
            camera.off();
        }
    }
    

    10、OnLightOrder.java程序代码

    package CommandPattern_Book;
    
    public class OnLightOrder implements Order {
        private Light light;
    
        OnLightOrder(Light light) {
            this.light = light;
        }
    
        @Override
        public void doExecute() {
            light.on();
        }
    
        @Override
        public void undoExecute() {
            light.off();
        }
    }
    

    11、Pane.java程序代码

    package CommandPattern_Book;
    
    import javafx.event.ActionEvent;
    import javafx.fxml.Initializable;
    import javafx.scene.control.Button;
    import javafx.scene.image.Image;
    import javafx.scene.image.ImageView;
    import javafx.scene.input.MouseEvent;
    import javafx.scene.layout.AnchorPane;
    
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.ResourceBundle;
    
    public class Pane implements Initializable {
        public AnchorPane LightView;
        public AnchorPane CameraView;
        public AnchorPane Undo;
    
        private ArrayList<Operation> arrayList = new ArrayList<>();
        private Operation LightStatus = Operation.OffLight;
        private Operation CameraStatus = Operation.OffCamera;
    
        @Override
        public void initialize(URL location, ResourceBundle resources) {
            CameraView.getChildren().add(camera);
            LightView.getChildren().add(light);
    
            ImageView imageView = new ImageView(new Image("/CommandPattern_Book/myUndo.png"));
            imageView.setFitHeight(50);
            imageView.setFitWidth(50);
            imageView.setSmooth(true);
            imageView.setCache(true);
            Undo.getChildren().add(imageView);
            isShow();
        }
    
        private void isShow(){
            if (arrayList == null){
                Undo.setVisible(false);
                return;
            }
            if (arrayList.size() == 0) {
                Undo.setVisible(false);
                return;
            }
            if (!Undo.isVisible()) {
                Undo.setVisible(true);
            }
        }
    
        private Light light = new Light();
        private Camera camera = new Camera();
    
        private Order onLightOrder = new OnLightOrder(light);
        private Order offLightOrder = new OffLightOrder(light);
        private Order onCameraOrder = new OnCameraOrder(camera);
        private Order offCameraOrder = new OffCameraOrder(camera);
    
        public void CameraOn(ActionEvent actionEvent) {
            if (CameraStatus == Operation.OnCamera) {
                return;
            }
            onCameraOrder.doExecute();
            arrayList.add(Operation.OnCamera);
            CameraStatus = Operation.OnCamera;
            isShow();
        }
    
        public void CameraOff(ActionEvent actionEvent) {
            if (CameraStatus == Operation.OffCamera) {
                return;
            }
            offCameraOrder.doExecute();
            arrayList.add(Operation.OffCamera);
            CameraStatus = Operation.OffCamera;
            isShow();
        }
    
        public void LightOn(ActionEvent actionEvent) {
    
            if (LightStatus == Operation.OnLight) {
                return;
            }
            onLightOrder.doExecute();
            arrayList.add(Operation.OnLight);
            LightStatus = Operation.OnLight;
            isShow();
        }
    
        public void LightOff(ActionEvent actionEvent) {
            if (LightStatus == Operation.OffLight) {
                return;
            }
            offLightOrder.doExecute();
            arrayList.add(Operation.OffLight);
            LightStatus = Operation.OffLight;
            isShow();
        }
    
        public void UndoClicked(MouseEvent mouseEvent) {
            Operation operation = arrayList.get(arrayList.size() - 1);
            switch (operation){
                case OnLight: onLightOrder.undoExecute(); LightStatus = Operation.OffLight; break;
                case OffLight: offLightOrder.undoExecute(); LightStatus = Operation.OnLight; break;
                case OnCamera: onCameraOrder.undoExecute(); CameraStatus = Operation.OffCamera; break;
                case OffCamera: offCameraOrder.undoExecute(); CameraStatus = Operation.OnCamera; break;
            }
            arrayList.remove(arrayList.size() - 1);
            isShow();
        }
    
    }
    

    12、Main.java程序代码

    package CommandPattern_Book;
    
    import javafx.application.Application;
    import javafx.fxml.FXMLLoader;
    import javafx.scene.Parent;
    import javafx.scene.Scene;
    import javafx.stage.Stage;
    
    import java.io.IOException;
    
    public class Main extends Application {
    
        @Override
        public void start(Stage primaryStage) throws IOException {
            Parent parent = FXMLLoader.load(Main.class.getResource("./Pane.fxml"));
            primaryStage.setScene(new Scene(parent, 400, 400));
            primaryStage.setResizable(false);
            primaryStage.show();
        }
    
        public static void main(String[] args) {
            launch();
        }
    }
    

    13、Pane.fxml 程序代码

    <?xml version="1.0" encoding="UTF-8"?>
    
    <?import javafx.scene.control.Button?>
    <?import javafx.scene.layout.AnchorPane?>
    <?import javafx.scene.layout.ColumnConstraints?>
    <?import javafx.scene.layout.GridPane?>
    <?import javafx.scene.layout.HBox?>
    <?import javafx.scene.layout.RowConstraints?>
    <?import javafx.scene.layout.VBox?>
    
    <AnchorPane maxHeight="500.0" maxWidth="500.0" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/8.0.131" xmlns:fx="http://javafx.com/fxml/1" fx:controller="CommandPattern_Book.Pane">
       <children>
          <VBox prefHeight="200.0" prefWidth="100.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
             <children>
                <AnchorPane prefHeight="200.0" prefWidth="200.0">
                   <children>
                      <HBox prefHeight="100.0" prefWidth="200.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
                         <children>
                            <AnchorPane fx:id="LightView" HBox.hgrow="ALWAYS" />
                            <AnchorPane fx:id="CameraView" HBox.hgrow="ALWAYS" />
                         </children>
                      </HBox>
                   </children>
                </AnchorPane>
                <AnchorPane VBox.vgrow="ALWAYS">
                   <children>
                      <GridPane AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
                        <columnConstraints>
                          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                          <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                        </columnConstraints>
                        <rowConstraints>
                          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                        </rowConstraints>
                         <children>
                            <Button mnemonicParsing="false" onAction="#LightOff" prefHeight="500.0" prefWidth="500.0" styleClass="bto" stylesheets="/CommandPattern_Book/tpye.css" text="LightOff" GridPane.hgrow="ALWAYS" GridPane.rowIndex="1" GridPane.vgrow="ALWAYS" />
                            <Button mnemonicParsing="false" onAction="#CameraOn" prefHeight="500.0" prefWidth="500.0" styleClass="bto" stylesheets="/CommandPattern_Book/tpye.css" text="CameraOn" GridPane.columnIndex="1" GridPane.hgrow="ALWAYS" GridPane.vgrow="ALWAYS" />
                            <Button mnemonicParsing="false" onAction="#CameraOff" prefHeight="500.0" prefWidth="500.0" styleClass="bto" stylesheets="/CommandPattern_Book/tpye.css" text="CameraOff" GridPane.columnIndex="1" GridPane.hgrow="ALWAYS" GridPane.rowIndex="1" GridPane.vgrow="ALWAYS" />
                            <Button mnemonicParsing="false" onAction="#LightOn" prefHeight="500.0" prefWidth="500.0" styleClass="bto" stylesheets="/CommandPattern_Book/tpye.css" text="LightOn" GridPane.hgrow="ALWAYS" GridPane.vgrow="ALWAYS"/>
                         </children>
                      </GridPane>
                   </children>
                </AnchorPane>
             </children>
          </VBox>
          <AnchorPane fx:id="Undo" onMouseClicked="#UndoClicked" prefHeight="68.0" prefWidth="71.0" />
       </children>
    </AnchorPane>
    

    14、tpye.css 程序代码

    .bto {
        -fx-font-size: 25;
        /*-fx-base: lightgreen;*/
        -fx-font-weight: lighter;
        -fx-text-fill: rgb(50, 50, 50);
        /*-fx-effect: innershadow(three-pass-box, #72b9da, 20, 0.2, 0, 0);*/
        /*-fx-effect: innershadow( three-pass-box , rgba(195,255,0,0.5) , 50, 0.1 , 0 , 2 );*/
    }
    .bto :hover {
        -fx-font-size: 25;
        /*-fx-base: lightgreen;*/
        -fx-font-weight: bold;
        /*-fx-text-fill: rgb(50, 50, 50);*/
        /*-fx-effect: innershadow(three-pass-box, #72b9da, 20, 0.2, 0, 0);*/
        -fx-effect: innershadow( three-pass-box , rgba(195,255,0,0.5) , 50, 0.1 , 0 , 2 );
    
    }
    

    15、ex_01.png资源
    在这里插入图片描述
    16、ex_02.png资源
    在这里插入图片描述
    17、ex_03.png资源
    在这里插入图片描述
    18、ex_04.png资源
    在这里插入图片描述
    19、myUndo.png资源
    在这里插入图片描述
    20、github
    https://github.com/Rsslosc/javafx-team

    四、心得体会

    通过这次实验,我学会了如何使用命令模式,如何通过命令模式来进行一系列的操作,不用深入程序内部,只需要调用相关的代码就可以实现灯泡的开关,摄像头的开关,对于面向对象思想有了更深入的理解。

    展开全文
  • 了解常用软件设计模式; 将实验过程中形成的图形、文字内容插入本文档。 二、实验内容 1、当前Web前端最经典的软件体系结构模式是MVC模式(Model-View-Controller),其中的三个组成部分为: V即View视图是指...
  • Singleton、Composite、decorator、Builder模式的实现,最后设计模式组合实现赌场管理系统。ps:sk的设计模式课,平时有测验,一共四次实验,想拿高分最后一次实验得答辩。最后总评98,本资源仅供学习交流
  • 实验名称 中介者模式的应用 日期 2019年 04 月9 日 ...某软件公司要开发一套CRM系统,其中包含一个客户信息管理模块,所设计的“客户信息管理窗口”界面效果图如下图所示: 用JAVA语言...
  • 实验名称 迭代器模式的应用 日期 2018年 04 月2 日 ...某软件公司为某商场开发了一套销售管理系统,在对该系统进行分析和设计时,开发人员发现经常需要对系统中的商品数据、客户数据等进行遍历,为了复用这些遍...
  • 2) 分析具体问题,使用外观模式进行设计。 某软件公司要开发一个可应用于多个软件的文件加密模块,该模块可以对文件中的数据进行加密并将加密之后的数据存储在一个新文件中,具体的流程包括3个部分,分别是读取源...
  • 实验名称 桥接模式的应用 ...2) 分析具体问题,使用桥接模式进行设计。 某软件公司要开发一个跨平台图像浏览系统,要求该系统能够显示BMP、JPG、GIF、PNG等多种格式的文件,并且能够在Windows、Linux、UNIX等...
  • 资源名字是软件体系结构课需要的实验代码,内容是设计模式,所以不要怀疑资源有误,内容详尽,包含文档,代码,与uml类图
  • 实验名称 抽象工厂模式的应用 日期 2019年 03 月25...2) 分析具体问题,使用抽象工厂模式进行设计 麦当劳(McDonalds)和肯德基(KFC)快餐店都经营汉堡(Hamburg)和可乐(Cole),用JAVA语言实现(C#控制台应用...
  • 2) 分析具体问题,使用建造者模式进行设计。 实例:KFC套餐 建造者模式可以用于描述KFC如何创建套餐:套餐是一个复杂对象,它一般包含主食(如汉堡、鸡肉卷等)和饮料(如果汁、可乐等)等组成部分,不同的套餐....
  • 2) 分析具体问题,使用工厂模式进行设计。 有一个OEM制造商代理做HP笔记本电脑(Laptop),后来该制造商得到了更多的品牌笔记本电脑的订单Acer,Lenovo,Dell,该OEM商发现,如果一次同时做很多...
  • 2) 分析具体问题,使用单例模式进行设计。 在操作系统中,打印池(Print Spooler)是一个用于管理打印任务的应用程序,通过打印池用户可以删除、中止或者改变打印任务的优先级,在一个系统中只允许运...
  • 2) 分析具体问题,使用组合模式进行设计。 文件浏览 文件有不同类型,不同类型的文件其浏览方式有所区别,如文本文件和图片文件的浏览方式就不相同。对文件夹的浏览实际上就是对其中所包含文件的浏览,而客户端...
  • 2) 分析具体问题,使用访问者模式进行设计。 某公司OA系统中包含一个员工信息管理子系统,该公司员工包括正式员工和临时工,每周人力资源部和财务部等部门需要对员工数据进行汇总,汇总数据包括员工工...
  • 2) 分析具体问题,使用命令模式进行设计。 开发人员为公司内部OA系统开发了一个桌面版应用程序,该应用程序为用户提供了一系列自定义功能键,用户可以通过这些功能键来实现一些快捷操作。为了让用户能够灵活地进....
  • 2) 分析具体问题,使用适配器模式进行设计。 加密适配器 某系统需要提供一个加密模块,将用户信息(如密码等机密信息)加密之后再存储在数据库中,系统已经定义好了数据库操作类。为了提高开发效率,现需要重用...
  • 软件工程包括下列领域:软件需求分析、软件设计、软件构建、软件测试和软件维护。敏捷开发(Agile Development)是一种以人为核心、迭代、循序渐进的开发方法。敏捷开发包括很多模式:一项实践在XP环境中成功使用的...
  • 云南大学软件学院实 验 报 告姓名: 周坤 学号: 20121120256 专业:实验二 装饰者模式的运用一、实验目的:装饰者模式动态地将责任附加到对象上,若要扩展功能,装饰者提供了比继承更有弹性的替代方案。在熟悉装饰...
  • 软件测试实验报告含四个实验

    热门讨论 2010-12-26 12:56:50
    实验三 基于缺陷模式软件测试 一.实验内容:C++语言、Java语言缺陷模式测试 二.实验要求:给出测试用例和测试结果 实验四 系统测试 一.实验内容:数据库应用系统性能测试 二.实验要求:给出响应时间、吞吐量...
  • 软件构造lab3-实验报告1. 实验目标概述2. 实验环境配置3. 实验过程3.1 待开发的三个应用场景3.2 面向可复用性和可维护性的设计:PlanningEntry3.2.1 PlanningEntry的共性操作3.2.2 局部共性特征的设计方案3.2.3 面向...
  • 软件工程包括下列领域:软件需求分析、软件设计、软件构建、软件测试和软件维护。 敏捷开发(Agile Development)是一种以人为核心、迭代、循序渐进的开发方法。敏捷开发包括很多模式: 一项实践在XP环境中成...
  • 开课实验室:开课时间: 2016年**月**日 实验报告: 年 月 日 学院名称 年级、专业、班 学号 姓名 同组姓名 课程名称 软件架构 实验...
  • ⚫常见的OO设计模式 ⚫语法驱动的编程、正则表达式 ⚫基于状态的编程 ⚫API设计、API复用 本次实验给定了五个具体应用(径赛方案编排、太阳系行星模拟、原子结构可视化、个人移动App生态系...

空空如也

空空如也

1 2 3 4 5
收藏数 92
精华内容 36
关键字:

软件设计模式实验报告