学号: 15477228
系统分析与设计
实验报告
实验题目：实验五解释器模式
学生姓名：
学院：专业班级：
指导教师：
时间： 2018 年 5 月 13 日
AbstractNode
{abstract}
+Interpret ()
...
: string
DirectionNode
-direction: string
+ +DirectionNode (string direction)
Interpret ()
...
: string
AndNode
-
-
left
right
: AbstractNode
: AbstractNode
+
+
AndNode (AbstractNode left,
AbstractNode right)
Interpret ()
...
: string
ActionNode
-action: string
+
+
ActionNode (string action)
Interpret ()
...
: string
DistanceNode
-distance: string
+
+
DistanceNode (string distance)
Interpret ()
...
: string
InstructionHandler
-node: AbstractNode
+ +Handle (string instruction)
Output ()
...
: void
: void
SentenceNode
-
-
-
direction
action
distance
: AbstractNode
: AbstractNode
: AbstractNode
+
+
SentenceNode (AbstractNode direction,
AbstractNode action,
AbstractNode distance)
Interpret ()
...
: string
【实验目的】
掌握解释器模式的定义、结构及实现方式。
【实验内容】
某软件公司要开发一套机器人控制程序，在该机器人控制程序中包含一些简单的英文控制指令，每一个指令对应一个表达式(expression)，该表达式可以是简单表达式也可以是复合表达式。每一个简单表达式由移动方向(direction)，移动方式(action)和移动距离(distance)三部分组成，其中，移动方向包括向上(up)、向下(down)、向左(left)、向右(right)；移动方式包括移动(move)和快速移动(run)；移动距离为一个正整数。两个表达式之间可以通过与(and)连接，形成复合(composite)表达式。
用户通过对图形化的设置界面进行操作可以创建一个机器人控制指令，机器人在收到指令后将按照指令的设置进行移动，例如输入控制指令“up move 5”将“向上移动5个单位”；输入控制指令“down run 10 and left move 20”将“向下快速移动10个单位再向左移动20个单位”。
现使用解释器模式来设计该程序并模拟实现。
REF
解释器模式包含以下4个角色：
AbstractExpression（抽象表达式）
TerminalExpression（终结符表达式）
NonterminalExpression（非终结符表达式）
Context（环境类）
namespace InterpreterSample
abstract class AbstractNode
{
public abstract string Interpret();
}
}
//AndNode.cs
namespace InterpreterSample
{
class AndNode : AbstractNode
{
private AbstractNode left;
private AbstractNode right;
public AndNode(AbstractNode left, AbstractNode right)
{
this.left = left;
this.right = right;
}
public override string Interpret()
{
return left.Interpret() + "再" + right.Interpret();
}
}
}
//SentenceNode.cs
namespace InterpreterSample
{
class SentenceNode : AbstractNode
{
private AbstractNode direction;
private AbstractNode action;
private AbstractNode distance;
public SentenceNode(AbstractNode direction,AbstractNode action,AbstractNode distance)
{
this.direction = direction;
this.action = action;
this.distance = distance;
}
public override string Interpret()
{
return direction.Interpret() + action.Interpret() + distance.Interpret();
}
}
}
//DirectionNode.cs
namespace InterpreterSample
{
class DirectionNode : AbstractNode
{ private string direction;
public DirectionNode(string direction)
{
this.direction = direction;
}
public override string Interpret()
{
if (direction.Equals("up"))
{
return "向上";
}
else if (direction.Equals("down"))
{
return "向下";
}
else if (direction.Equals("left"))
{
return "向左";
}
else if (direction.Equals("right"))
{
return "向右";
}
else
{
return "无效指令";
}
}
}
}
//ActionNode.cs
namespace InterpreterSample
{
class ActionNode : AbstractNode
{
private string action;
public ActionNode(string action)
{
this.action = action;
}
public override string Interpret()
{
if (action.Equals("move"))
{
return "移动";
}
else if (action.Equals("run"))
{
return "快速移动";
}
else
{
return "无效指令";
}
}
}
}
//DistanceNode.cs
namespace InterpreterSample
{
class DistanceNode : AbstractNode
{
private string distance;
public DistanceNode(string distance)
{this.distance = distance;}
public override string Interpret()
{ return this.distance; }
}
}
//InstructionHandler.cs
namespace InterpreterSample
class InstructionHandler
{
private AbstractNode node;
public void Handle(string instruction)
{ AbstractNode left = null, right = null;
AbstractNode direction = null, action = null, distance = null;
Stack stack = new Stack();
string[] words = instruction.Split(' ');
for (int i = 0; i < words.Length; i++)
{
if (words[i].Equals("and"))
{
left = (AbstractNode)stack.Pop();
string word1= words[++i];
direction = new DirectionNode(word1);
string word2 = words[++i];
action = new ActionNode(word2);
string word3 = words[++i];
distance = new DistanceNode(word3);
right = new SentenceNode(direction,action,distance);
stack.Push(new AndNode(left,right));
}
else
{ string word1 = words[i];
direction = new DirectionNode(word1);
string word2 = words[++i];
action = new ActionNode(word2);
string word3 = words[++i];
distance = new DistanceNode(word3);
left = new SentenceNode(direction,action,distance);
stack.Push(left); }
}
this.node = (AbstractNode)stack.Pop();
}
public string Output()
{ string result = node.Interpret();
return result; }
}
}
//Program.cs
namespace InterpreterSample
class Program
{
static void Main(string[] args)
{ string instruction = "down run 10 and left move 20";
string instruction = "up move 5 and down run 10 and left move 5";
InstructionHandler handler = new InstructionHandler();
handler.Handle(instruction);
string outString;
outString = handler.Output();
Console.WriteLine(outString);
Console.Read(); }
}
}
运行结果：
【实验总结】
经过本次的解释器模式的实验，它是易于改变和扩展文法，可以很方便的实现一个简单的语言。其缺点是对于复杂的文法难以维护，并且执行效率较低。在增加新的解释表达式也较为方便。
一、口算（共20题，每题1分，共20分） 72－45= 360－85= 50×50= 32×30= 17×5= 22×30= 6×201= 25×40= 4500÷900= 254+99= 150×20= 170+90= 4800÷40= 4200÷20= 62+18= 125×4= 3000+200= 420÷35÷2= 720÷9÷4= 22×8×5= 二、简便计算(带☆的写出运算定律6分/题,带*的为附加题10分,其他4分/题) 169-(69+27) ☆208+(92+39) ☆25×(59×4) 6300÷(63×5) ☆145+169+31+255 ☆34×49+51×34 125×64×25 5700÷25÷4 59×101-59 679－79－142－48 672-98 104×25 *5÷(7÷11) ÷(11÷16) ÷(16÷35) 三、列式计算（共4题，每题6分） 1、725加上475的和除以50和25的差，商是多少？ 2、185乘97与53的差，积是多少？ 3、870除以5的商,加上30与23的积,和是多少? 4、784加上128除以8再乘23,和是多少? 第一节消化系统解剖与生理
1.小儿，2岁。体温升高达39℃，口唇及颊黏膜出现成簇的小疱疹。经医生检查确诊为疱疹性口腔炎。疱疹性口腔炎黏膜损伤特点为 A.黄白色纤维素性渗出物 B.潮红、可有渗血 C.有灰白色假膜 D.白色片状物 E.充血、红绒状 2.小儿，10个月。因反复腹泻而致轻度营养不良。近日其母喂小儿喝水时发现口腔黏膜表面有不易擦去的白色点状乳凝块样物，经医生检查诊为鹅口疮。鹅口疮的病原体是 A.金黄色葡萄球菌 B.柯萨奇病毒 C.埃可病毒 D.单纯疱疹病毒 E.白色念珠菌 3.鹅口疮的临床表现，错误的是 A.无全身症状 B.齿龈颊部等处均有乳凝块附着 C.病变可影响消化道呼吸道等 D.均有发热 E.口腔黏膜无红肿不影响喂奶 4.不符合疱疹性口腔炎特点的是 A.病初可有上呼吸道感染症状 B.起病时高热达38～40℃ C.无传染性 D.口腔疼痛较剧烈影响进食 E.常有颌下淋巴结肿大 5.9个月的小儿，因哭闹、拒食就诊。体格检查：体温38.0℃，见口腔内溃疡，覆以黄白色膜状物，周围绕以红晕。可能诊断为 A.单纯性口腔炎 B.疱疹性口腔炎 C.溃疡性口腔炎 D.齿龈炎 E.鹅口疮 6.小兰，女，10个月。因食欲下降就诊，体检发现口腔颊黏膜多处有白色乳凝块样物，不易擦掉，强行擦去下面有红色创面。清洁该患儿口腔应选择的清洁液是 A.3%过氧化氢 B.0.1%依沙吖啶 C.制霉菌素溶液 D.2%碳酸氢钠 E.1%高锰酸钾 7.新生儿，15天。其母喂奶时发现口腔黏膜表面有白色点状乳凝块样物，不易擦去。经护士家庭访视时确诊为鹅口疮。治疗鹅口疮的药物是
工厂系列模式的优缺点： 1.让用户的代码和某个特定类的子类的代码解耦 用户不必知道它所使用的对象是怎样创建的，只需知道该对象有哪些方法 2.抽象工厂模式可以为用户创建一系列相关的对象，使用户和创建这些对象的类脱耦 MVC模式是不是一种设计模式？为什么 MVC不是设计模式，应该是框架/架构模式，因为它的定义是抽象的，没有足够的细节描述使你直接去实现，而只能根据MVC的概念和思想，用几个设计模式组合实现。 举出一个生活中使用装饰者模式的例子，用程序实现思路 举个生活中的例子，俗话说“人在衣着马在鞍”，把这就话用装饰者模式的语境翻译一下，“人通过漂亮的衣服装饰后，男人变帅了，女人变漂亮了；”。对应上面的类图，这里人对应于ConcreteComponent,而漂亮衣服则对应于ConcreteDecorator； 设计模式如何分类，每一个类别都有什么特征？ 设计模式分为3类，分别是：创建型模式、行为型模式、结构型模式。 创建型特点：避免用户直接使用new运算符创建对象。 行为型特点：怎样合理的设计对象之间的交互通信，以及怎样合理的为对象分配职 结构型特点：主要用于处理类或对象的组合 Java jdk中使用了哪些设计模式 1.单例 2.静态工厂 3.工厂方法 4.抽象工厂 5.构造者 6.原型 7.适配器8桥接9.组合10.装饰器11.外观12.享元 页脚内容1
14.代理15.迭代器16.观察者17.协调者18.模板方法19.策略20.责任链21.命令22.空对象25.解释器 面向对象的设计原则有哪些？ 开闭原则、面向抽象的原则（依赖倒转原则）、多用组合少用继承原则、高内聚-低耦合原则。 观察者模式的推拉有什么不同？使用场景 推，具体主题将变化后的数据全部交给具体观察者。场景：当具体主题认为具体观察者需要这些变换后的数据时，往往采用推数据方式； 拉，具体主题不将变化后的数据交给具体观察者，而是提供获得这些数据的方法。场景：当具体主题不知道具体观察者是否需要这些变换后的数据时，往往采用拉数据的方式。 策略模式和工厂模式有什么不同？ 策略模式定义了一系列算法，将他们一个个封装，并且他们之间可以相互替换； 工厂模式定义一个创建对象的接口，让子类决定实例化哪一个类 5观察者模式的推拉有什么不同？适用场景 现在要说的分歧在这里： “推”的方式是指，Subject维护一份观察者的列表，每当有更新发生，Subject会把更新消息主动推送到各个Observer去。 “拉”的方式是指，各个Observer维护各自所关心的Subject列表，自行决定在合适的时间去Subject获取相应的更新数据。 “推”的好处包括： 页脚内容2
一.创建型模式(Creational): 简单工厂模式(simpleFactory)发音:['simpl] ['f?kt(?)r?] 定义: 提供一个创建对象实例的功能,而无须关心其具体实现.被创建实例的类型可以是接口,抽象类,也可以是具体的类. 1.抽象工厂(AbstractFactory)发音: ['?bstr?kt] 定义: 提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类. 使用场合: 1.如果希望一个系统独立于它的产品的创建,组合和表示的时候,换句话书,希望一个系统只是知道产品的接口,而不关心实现的时候. 2.如果一个系统要由多个产品系列中的一个来配置的时候.换句话说,就是可以,就是可以动态地切换产品簇的时候. 3.如果强调一系列相关产品的接口,以便联合使用他们的时候 2.建造者模式(Builder)发音: ['b?ld?] 定义: 将复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 使用场合: 1.如果创建对象的算法,应该独立于该对象的组成部分以及它们的装配方式时 2.如果同一个构建过程有着不同的表示时 3.工厂方法模式(Factory Method) 定义: 为创建对象定义一个接口,让子类决定实例化哪个类.工厂方法让一个类的实例化延迟到了子类. 使用场景: 1.客户类不关心使用哪个具体类,只关心该接口所提供的功能. 2.创建过程比较复杂,例如需要初始化其他关联的资源类,读取配置文件等. 3.接口有很多具体实现或者抽象类有很多具体子类时, 4.不希望给客户程序暴露过多的此类的内部结构,隐藏这些细节可以降低耦合度. 5.优化性能,比如缓存大对象或者初始化比较耗时的对象. 4.原型模式(Prototype Method)发音: ['pr??t?ta?p] 定义: 使用原形实例指定将要创建的对象类型,通过复制这个实例创建新的对象. 应用场合: 1.如果一个系统想要独立于它想要使用的对象时,可以使用原型模式,让系统只面向接口编程,在系统需要新的对象的时候,可以通过克隆原型来得到. 2.如果需要实例化的类是在运行时刻动态指定时,可以使用原型模式,通过克隆原型来得到需要的实例.
java设计模式———享元模式 享元模式的结构 享元模式采用一个共享来避免大量拥有相同内容对象的开销。这种开销最常见、最直观的就是内存的损耗。享元对象能做到共享的关键是区分内蕴状态(Internal State)和 外蕴状态(External State)。 一个内蕴状态是存储在享元对象内部的，并且是不会随环境的改变而有所不同。因此，一个享元可以具有内蕴状态并可以共享。 一个外蕴状态是随环境的改变而改变的、不可以共享的。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外蕴状态不可以影响享元对象的内蕴状态，它们是相互独立的。 享元模式的优点：减少对象数量，节省内存空间。 享元模式的缺点：维护共享对象，需要额外的开销（用一个线程来维护垃圾回收）。 享元模式的本质：分离与共享 何时使用享元模式：如果一个应用程序使用了大量的细粒度对象，可以使用享元模式来减少对象数量。
如果使用大量的对象，造成很大的存储开销，可以使用享元模式来减少对象数量，并节约内存。 如果对象的大多数状态都可以转变为外部状态，可以使用享元对象来实现外部状态与内部状态的分离。享元模式可以分成单纯享元模式和复合享元模式两种形式。 单纯享元模式 在单纯的享元模式中，所有的享元对象都是可以共享的。 单纯享元模式所涉及到的角色如下： 抽象享元(Flyweight)角色：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的 时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象
《JAVA设计模式》复习资料 一、单项选择题 1．设计模式起源于（） A、机械设计 B、建筑工程设计 C、水利工程设计 D、工业电力化设计 2．“不要和陌生人说话”是（）原则的通俗表述。 A、接口隔离 B、里氏替换 C、依赖倒置 D、迪米特 3．目前常见的设计模式主要有（）种。 A、23 B、21 C、32 D、28 4．以下关于单一职责原则的叙述不正确的是（）。 A、单一职责原则的英文名称是Single Responsibility Principle. B、单一职责原则要求一个类只有一个职责 C、单一职责原则有利于对象的稳定，降低类的复杂性 D、单一职责原则提高了类之间的耦合性 5．以下关于依赖倒置原则的叙述不正确的是（） A、依赖倒置原则的简称是DIP B、高层模块不依赖于低层模块，低层模块依赖于高层模块 C、依赖倒置原则中高层模块和低层模块都依赖于抽象 D、依赖倒置原则实现模块间的松耦合 6．下面关于单例模式说法错误的是（） A、单例模式是指一个类只有一个实例 B、单例类从实现方式上分为懒汉式和饿汉式 C、单例类从功能上分为状态单例类和无状态单例类 D、可以通过继承的方式对单例类进行扩展得到功能更丰富的单例类 7．下面关于工厂方法模式说法错误的是（）。 A、工厂方法模式使一个类是实例化延迟到其子类中 B、工厂方法模式中具有抽象工厂、具体工厂、抽象产品和具体产品4个角色 C、工厂方法模式可以处理多个产品的多个等级结构 D、工厂方法模式可以屏蔽产品类 8．在以下情况不适合使用责任职责链模式（） A、有多个对象可以处理请求，哪个对象处理该请求在运行时刻自动确定。 B、在需要用比较通用和复杂的对象指针代替简单的指针的时候。 C、你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 D、一个请求需要一系列的处理工作。 9．当我们想创建一个具体的对象而又不希望指定具体的类时，可以使用（）模式 A、结构型 B、创建型 C、行为型 D、以上都可以 10．以下用来描述适配器模式的是（） A、表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 B、定义一个用于创建对象的接口，让子类决定实例化哪一个类。
【关键字】模式 一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下： 二、设计模式的六大原则 总原则：开闭原则（Open Close Principle） 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类等，后面的具体设计中我们会提到这点。 1、单一职责原则 不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。 2、里氏替换原则（Liskov Substitution Principle） 里氏代换原则(Liskov Substitution Principle LSP)面向东西设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科 历史替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。 3、依赖倒转原则（Dependence Inversion Principle） 这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。 4、接口隔离原则（Interface Segregation Principle） 这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。 5、迪米特法则（最少知道原则）（Demeter Principle）
第1章软件体系结构概述 ?SEI软件体系结构讨论群定义如下：一个程序/系统构件的结构，它们之间的相互关系，以及在设计和交付的整个过程中的原则和指导方针。 ?Mary Shaw和David Garlan认为软件体系结构包括构成系统的设计元素的描述，设计元素的交互，设计元素组合的模式，以及在这些模式中的约束。 ?软件体系结构包括构件(Component)、连接件(Connector)和约束(Constrain)或配置(Configuration)三大要素。 ?国内普遍接受的定义：软件体系结构包括构件、连接件和约束，它是可预制和可重构的软件框架结构。 ?构件是可预制和可重用的软件部件，是组成体系结构的基本计算单 元或数据存储单元 ?连接件也是可预制和可重用的软件部件，是构件之间的连接单元 ?构件和连接件之间的关系用约束来描述 ?软件体系结构= 构件+ 连接件+ 约束 软件体系结构的优势容易理解、重用、控制成本、可分析性 第2章软件体系结构风格 ?软件体系结构风格是描述某一特定应用领域中系统组织方式的惯用模式。 ?体系结构风格定义了一个系统家族，即一个体系结构定义一个词汇表和一组约束。 词汇表中包含一些构件和连接件类型，而这组约束指出系统是如何将这些构件和连接件组合起来的。 ?体系结构风格反映了领域中众多系统所共有的结构和语义特性，并指导如何将各个模块和子系统有效地组织成一个完整的系统。 ?数据流风格: 批处理序列; 管道/过滤器。 ?调用/返回风格：主程序/子程序；面向对象风格；层次结构。 ?独立构件风格：进程通讯；事件系统。 ?虚拟机风格：解释器；基于规则的系统。 ?仓库风格：数据库系统；超文本系统；黑板系统。 ?过程控制环路 ?C/S风格体系结构有三个主要组成部分：数据库服务器、客户应用程序和网络。 ?B/S风格浏览器/Web服务器/数据库服务器。 优点：C/S体系结构具有强大的数据操作和事务处理能力，模型思想简单，易于人们理解和接受。将大的应用处理任务分布到许多通过网络连接的低成本计算机上，以节约大量费用。缺点：开发成本较高、客户端程序设计复杂、信息内容和形式单一、用户界面风格不一，使用繁杂不利于推广使用、软件移植困难、软件维护和升级困难、新技术不能轻易应用 优点：基于B/S体系结构的软件，系统安装、修改和维护全在服务器端解决。 缺点：B/S体系结构缺乏对动态页面的支持能力，没有集成有效的数据库处理功能。 B/S体系结构的系统扩展能力差，安全性难以控制。 采用B/S体系结构的应用系统，在数据查询等响应速度上，要远远低于C/S体系结构。 B/S体系结构的数据提交一般以页面为单位，数据的动态交互性不强，不利于在线事务处理(OLTP)应用。 第3章软件需求与架构 ?需求的基本概念 ?IEEE (1997) ?(1) 用户解决问题或达到目标所需的条件或能力
（1） 50×160÷40 （2） 120+144÷18 （3）347+45×20 （1)444-(387+344) （2）25×32×125 （3）797+401 （4）510-80×2 （5） 205×6-150÷6 （6）102×13+42 （7）108-24×3+62 （8）（32-18）×96÷８（9）236+720÷（44+36）（10）(240+36)÷(22-18) （11）(33-18)×(24+34) （12）54÷18+41×３（13）640+360÷60+40（14）16×5－80÷16（15）5×（825－115÷23）（16）21×（376－376÷8）（17）5×（825－115÷23）（18）（143+429÷13）×24（19）396+126÷18－19 （20）240－240÷15×４（21）（7225-104×15）÷55（22）78×50－1440÷12（23）3856÷16+85×16（24）4000÷（16+832÷13）（25）（326+95×25）÷37（26）（7236÷18-228）×28（27）（4275－24×75）÷25（28）50＋160÷40（29）120-144÷18+35 （30）（58+37）÷（64-9×5）（31）95÷（64-45）（32）178-145÷5×6+42 （33）120-36×4÷18+35 （34）85+14×（14+208÷26）（35）21+(327-23)÷19（36）539-513÷(378÷14)（37）34-3094÷17÷13（38）19+(253-22)÷21（39）50+20×28-42 （40）(23+23)×24-597 （41）(110-10)÷10-10 （42）45-24+14×14 （43）304-275÷(275÷25)（44）(70+10)÷(18-10) （45）120÷12×18-54 （46）44+16×15-32 （47）(10-100÷10)×11（48）(53-588÷21)×36（49）(60+10)÷(17-10) （50） 17+(233-43)÷10（51）100÷10×10-60 （52）424-475÷19×16（53）22+(374-10)÷26（54）(245-11)÷18-11 （55） 22-(10+100÷10)（56）(252-14)÷17-10（57）35-13+10×15 （58）(346-10)÷16-12 （59）215-198÷(121÷11) （60）(45-651÷21)×33 （61）19+192÷12-10 （62）14+(21-19)×１4 （63）18-(13+15)÷262（64）14+(21-19)×14（65）18-(13+15)÷262（66）736÷(43-20)×23（67）(227+11)÷(31-14)（68）36+19×14-23 （69）828÷23×12-48 （70）18-15+10×18（71）(31-154÷11)×12（72）(1369-37)÷37-32（73）160÷(22-12)×22(74)357÷21×13-213 (75) 50＋160÷40 （76）（58+370）÷（64-45）（77）120-144÷18+35 （78）45×２-4160÷52 （79）（58+37）÷（64-9×5）（80）95÷（64-45）（81）178-145÷5+42 （82）64×21÷28 （83）812-700÷（9+31×11）（84）2940÷28×21 （85）920-1680÷40÷7 （86）690+47×52-398（87）148+3328÷64-75 （88）360×24÷32+730（89）2100-94+48×54（90)（247+18）×27÷25（91）36-720÷（360÷18）（92）814-（278+322）÷15 （93）1406+735×9÷45 （94）796-5040÷（630÷7）（95）285+（3000-372）÷36（96）546×（210-195）÷30（97）12.45－1.35－0.65 (98)120-36×4÷18+35 （99）128+35×３ （100）700-125×３（101）330÷5+46×７（102）104×９-72÷8 （103） 145-150÷2+23 （104）984÷6×３（105）18×5+522÷3 （106）48×3+240×2 （107）89×2+86（108）450÷5+29×6 （109）784÷8+105×４（110）252÷9÷（11-4）（111）560÷４-630÷7 （112）(210+630)÷7 （113）522÷(328-319）+42（114）(42+18)×（56-26）
《J A V A设计模式》复习资料 一、单项选择题 1．设计模式起源于（） A、机械设计 B、建筑工程设计 C、水利工程设计 D、工业电力化设计 2．“不要和陌生人说话”是（）原则的通俗表述。 A、接口隔离 B、里氏替换 C、依赖倒置 D、迪米特3．目前常见的设计模式主要有（）种。 A、23 B、21 C、32 D、28 4．以下关于单一职责原则的叙述不正确的是（）。 A、单一职责原则的英文名称是SingleResponsibilityPrinciple. B、单一职责原则要求一个类只有一个职责 C、单一职责原则有利于对象的稳定，降低类的复杂性 D、单一职责原则提高了类之间的耦合性 5．以下关于依赖倒置原则的叙述不正确的是（） A、依赖倒置原则的简称是DIP B、高层模块不依赖于低层模块，低层模块依赖于高层模块 C、依赖倒置原则中高层模块和低层模块都依赖于抽象 D、依赖倒置原则实现模块间的松耦合 6．下面关于单例模式说法错误的是（） A、单例模式是指一个类只有一个实例 B、单例类从实现方式上分为懒汉式和饿汉式 C、单例类从功能上分为状态单例类和无状态单例类 D、可以通过继承的方式对单例类进行扩展得到功能更丰富的单例类7．下面关于工厂方法模式说法错误的是（）。 A、工厂方法模式使一个类是实例化延迟到其子类中 B、工厂方法模式中具有抽象工厂、具体工厂、抽象产品和具体产品4个角色 C、工厂方法模式可以处理多个产品的多个等级结构 D、工厂方法模式可以屏蔽产品类 8．在以下情况不适合使用责任职责链模式（） A、有多个对象可以处理请求，哪个对象处理该请求在运行时刻自动确定。 B、在需要用比较通用和复杂的对象指针代替简单的指针的时候。 C、你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 D、一个请求需要一系列的处理工作。 9．当我们想创建一个具体的对象而又不希望指定具体的类时，可以使用（）模式 A、结构型 B、创建型 C、行为型 D、以上都可以 10．以下用来描述适配器模式的是（）
23种设计模式的通俗理解【转】 1、FACTORY 工厂方法 追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、BUILDER 抽象工厂 MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱 你”builder。（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。 3、FACTORY METHOD 建造者模式 请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE 原型模式 跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。 5、SINGLETON 单态模式 俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事) 单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。[b:9ceca65206]结构型模式[/b:9ceca65206] 6、ADAPTER 适配器模式 在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我) 适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，
教案过程 一、复习预习 1.换位学习 让学生以“老师的口吻”为老师讲解已学过的运算定律 2.学生与老师交流（运算中怎样简便？）：讨论“我的想法对不对？” 二、知识讲解 考点/易错点1 两个数相加，交换加数的位置，和不变。这叫做加法交换律。 考点/易错点2 三个数相加，先把前两个数相加，再加第三个数。或者先把后两个数相加，再加第数，和不变。这叫做加法结合律。 考点/易错点3 乘法运算中交换两个因数的位置，积不变。这叫做乘法交换律。
考点/易错点4 乘法运算中，先乘前两个数，或者先乘后两个数，积不变。这叫做乘法结合律。 考点/ 易错点5 两个数的和与一个数相乘，可以先把它们与这个数分别相乘，再相加。这叫做乘法分配律。 考点/ 易错点6 1.要想运用运算定律做好简便运算，要仔细观察算式，如果只有加法，一般用到加法交换和结合律，如果算式里只有乘法，一般用到乘法交换和结合律，如果既有加又有乘，一般用到乘法分配律。当然要注意一些变式。 2. 还要观察算式里面的特殊数字，如25 和4,125 和8,2 和5 等，有时101 可以变成（100+1），想想如何利用好这些特殊数字。 三、例题精析 例题1】 题干】357＋288＋143 答案】788 解读】357＋288＋143 =357＋143＋288 =500+288 =788 例题2】 【题干】138 ＋293＋62＋107 【答案】600 【解读】138＋293＋62＋107 = （138＋62）＋（293＋107） =200+400 =600
例题3】 【题干】25X 17X 4 答案】1700 【解读】25X 17X 4 =25 X 4X 17 =100 X 17 =1700 例题4】 题干】（25X125）X（8X4）答案】100000 解读】（25X125）X（8X4） 25X 4）X（8X 125）=100 X 1000 =100000 例题5】 题干】25 X（40＋4） 答案】1100 解读】25 X（40＋4） = 25 X 40＋25X 4 =1000+100 =1100 例题6】 题干】125 X 64
Java上市公司笔试题目及答案分析 一、选择题（不定项选题） 1下面说法正确的是（ C ） A．Java中包的主要作用是实现跨平台功能 B．package语句只能放在import语句后 C．包（package）是由一组类（class) 和接口（inter'face)组成 D．无 2不能用来修饰interface的有（ACD ） Aprivate Bpublic Cprotected Dstatic 3在Java语言中,下列关于字符编码和国际化的叙述，哪些是正确的（CD） A每个中文字符占用2个字节，每个英文字符占用1个字节 B假设数据库中的字符是以GBK编码的，那么显示数据库数据的网页也必须是GBK编码的。 CJava的char类型，通常以UTF-16 Big Endian的方式保存一个字符。 D实现国际化应用常用的手段是利用ResourceBundle类 解析： 1.不同的编码格式，字符所占用的字节数是不一样的。如GBK中每个中文占用2个字 节，UTF-8中则是变长编码，可能占用3个字节或者4个字节。因此A不正确。 2.不同的编码方式之间是可以转换的，如果数据库GBK编码，页面上可以使用任意 支持汉字编码的编码方式显示都可以，只要在向页面传输的数据过程中进行编码的转换即可。如：数据库是GBK，页面上是UTF-8,那么可以这样转换：实例代码以java语法编写 4下面代码的执行结果是（C ） public class TestDemo { public static void main(String[] args) { System.out.println(test1());
四则运算与简便运算 一、计算下列各题能简算的简算。（易错题） (1)1200－624－76 2100-728-772 576-285+85 825-657+57 (2)168＋74＋32＋16 25＋75－25＋75 23×4×5 13+7×5 (3)32×25×125 148－111÷37 600＋400÷50 120－20÷4 (4)135+26－135+26 45÷5+40×6 25×4÷25×4280－80÷4 (5)86－16×5＋15 12×6÷12×6 98×101 168＋32÷8 (6)125×（8×20） 125×（8+20） 7000÷8÷125 4×72×125 (7)(35+49)÷7 36÷(3＋9) 15－15÷5 373＋27×16＋68
二、根据运算顺序添上小括号或中括号。 （1） 32 × 800 － 400 ÷ 25 先减再乘最后除 （2） 32 × 800 － 400 ÷ 25 先除再减最后乘 （3） 32 × 800 － 400 ÷ 25 先减再除最后乘 三、解决问题，列综合算式计算。 1．某工厂积极开展植树活动。第一车间45人共植树315棵；第二车间42人，平均每人植 树8棵。两个车间一共植树多少棵？ 2．妈妈买回来苹果和梨各8千克，每千克苹果4元，每千克梨3元，共花去多少元？(用两种方法解答) 3.一台磨面机每小时磨面200千克，照这样计算，6台磨面机5小时能磨面粉多少千克？ 4. 3台磨面机4小时磨面1200千克，照这样计算，6台磨面机5小时能磨面粉多少千克？ 5．师傅每天加工200个零件，徒弟5天的工作量等于师傅4天的工作量．徒弟单独工作要多少天才能完成1120个零件？ 6．冬冬体重38千克，表弟体重是他的一半，而爸爸体重是表弟的4倍。爸爸体重是多少 千克？ 7.买中国象棋和围棋一共用去了96元，平均每副围棋多少元? 8.每个茶杯6元,茶壶的价钱是1个茶杯价钱的5倍。买右图这样一套茶具，一共要用多少钱？ 9．春芽饲养场星期一收的鸡蛋和鸭蛋共重480千克，每15千克装一箱，鸡蛋装了20箱。 再准备10个箱子装鸭蛋够吗？ 10.某编织厂的工人每天能编50个中国结，一周按5天计算，7周能编1800个中国结吗？（列式计算并说明理由） ※11.小亮和爸爸坐出租车去天河公园玩，3千米以内计价8元，超过3千米，每千米加价2元，下车时，爸爸付了18元，他们坐出租车行了多少千米？
Factory Singleton(单态) Builder Prototype(原型) Flyweight Bridge Decorator(油漆工) Composite(组合) Adapter(适配器) Proxy(代理) Facade(外观总管Manager) Visitor Observer 1、FACTORY?追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、BUILDER?MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM 我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。 3、FACTORY METHOD?请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE?跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。 5、SINGLETON?俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事) 单
一、引子 其实没有什么好的例子引入解释器模式，因为它描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发编译器中；在实际应用中，我们可能很少碰到去构造一个语言的文法的情况。 虽然你几乎用不到这个模式，但是看一看还是能受到一定的启发的。 二、定义与结构 解释器模式的定义如下：定义语言的文法，并且建立一个解释器来解释该语言中的句子。它属于类的行为模式。这里的语言意思是使用规定格式和语法的代码。 在GOF的书中指出：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。而且当文法简单、效率不是关键问题的时候效果最好。 这也就是解释器模式应用的环境了。 让我们来看看神秘的解释器模式是由什么来组成的吧。 1) 抽象表达式角色：声明一个抽象的解释操作，这个接口为所有具体表达式角色（抽象语法树中的节点）都要实现的。 什么叫做抽象语法树呢？《java与模式》中给的解释为：抽象语法树的每一个节点都代表一个语句，而在每个节点上都可以执行解释方法。这个解释方法的执行就代表这个语句被解释。由于每一个语句都代表这个语句被解释。由于每一个语句都代表一个常见的问题的实例，因此每一个节点上的解释操作都代表对一个问题实例的解答。 2) 终结符表达式角色：具体表达式。 a) 实现与文法中的终结符相关联的解释操作 b) 而且句子中的每个终结符需要该类的一个实例与之对应 3) 非终结符表达式角色：具体表达式。 a) 文法中的每条规则R::=R1R2…Rn都需要一个非终结符表带式角色 b) 对于从R1到Rn的每个符号都维护一个抽象表达式角色的实例变量 c) 实现解释操作，解释一般要递归地调用表示从R1到Rn的那些对象的解释操作 4) 上下文（环境）角色：包含解释器之外的一些全局信息。 5) 客户角色： a) 构建（或者被给定）表示该文法定义的语言中的一个特定的句子的抽象语法树
一、填空 1．在一个算式里，如果只有加减法，要（）计算，如果只有乘除法，要（）计算。 2．在一个算式里，如果含有加、减、乘、除四种运算，要先算（），再算（）。3．在一个算式里如果含有小括号，要先算（）。 二、口算 36 ÷ 3 100 － 62 24 － 8 ＋ 10 75 ×30 371 － 371 5 ＋ 24 － 12 200 ÷ 40 84 ÷ 4 48 ÷ 8 × 9 93÷100= 159+61= 600÷20= 78+222= 405-60= 1000÷8= 17×11= 7600÷400= 480÷120= 695-75= 25×17×4= 225-99= 640÷40= 468+199= 620-340= 3200÷80= 三、比一比，算一算 49 ＋ 17 － 25 240 ÷ 40 × 5 300 － 50 × 2 49 －（17 ＋ 25）240 ＋ 40 × 5 300 － 50 × 20 × 0 四、把下面几个分步式改写成综合算式． （1）960÷15=64 64-28=36 综合算式___________________. （2）75×24=1800 9000-1800=7200 综合算式___________ ______ （3）810-19=791 791×2=1582 1582+216=1798 综合算式_____________ （4）96×5=480 480+20=500 500÷4=125 综合算式_____________ 五、计算下面各题 121 － 111 ÷ 37 （121 － 111 ÷ 37）× 5 280 ＋ 650 ÷ 13 45 × 20 × 3 1000 －（280 ＋ 650 ÷ 13）（95 － 19 × 5 ）÷74
武汉轻工大学 数学与计算机学院 2018-2019学年第二学期 JAVA大作业 指导老师： ***** 专业：信息管理与信息系统 班级：信管1602班 学号： ********** 姓名： **** 2019年6月5日
Java设计模式学习体会 1、策略模式： 策略模式就是将能够通用的算法，封装成不同的组件，实现同一个接口，使之可以互换。 例子：SpringMVC的9大组件，都采用策略模式。比如HandlerMethodArgumentResolver，有非常多不同的实现类，这些实现类都可以互相替换来处理不同类型的参数，这就是策略模式。 我们知道一件事可能会有很多种方式来实现它，但是其中总有一种最高效的方式，在软件开发的世界里面同样如此，我们也有很多中方法来实现一个功能，但是我们需要一种简单、高效的方式来实现它，使得系统能够非常灵活，这就是策略模式。 所以策略模式就是定义了算法族，分别封装起来，让他们之前可以互相转换，此模式然该算法的变化独立于使用算法的客户。 在策略模式中它将这些解决问题的方法定义成一个算法群，每一个方法都对应着一个具体的算法，这里的一个算法我就称之为一个策略。虽然策略模式定义了算法，但是它并不提供算法的选择，即什么算法对于什么问题最合适这是策略模式所不关心的，所以对于策略的选择还是要客户端来做。客户必须要清楚的知道每个算法之间的区别和在什么时候什么地方使用什么策略是最合适的，这样就增加客户端的负担。 同时策略模式也非常完美的符合了“开闭原则”，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。但是一个策略对应一个类将会是系统产生很多的策略类。 策略模式与模板方法模式的区别：比如一个抽象类有一个抽象方法，每个实现该抽象方法的具体实现都不同，就是模板方法模式，一般在抽象类中会有逻辑处理，只是用到了抽象的模板方法时，交给具体的子类去不同实现。 如果一个模板方法，被子类实现时，实现方式大都相同，比如模板方法为处理字符（10个子类可能只有两种实现，一种是处理为UTF-8，一种是处理成GBK），那么这个模板方法就应该使用策略模式。 2、观察者模式： 观察者模式就是将“观察者”注册给“被观察者”，当被观察者发生改变时，能够及时的通知所有观察者。 例子：比如listener或者事件触发等，都是观察者模式