您的当前位置：首页软件设计模式与体系结构

软件设计模式与体系结构

来源：欧得旅游网

软件设计模式与体系结构

计算机科学与技术学院

《软件设计模式与体系结构》

课程作业（一）

（2016/2017学年第二学期）

学生姓名：雷君学生专业：软件工程学生班级：142601 学生学号：201426170108 指导教师：王飞

实验一1

工厂方法模式——汽车保险1 抽象工厂方法模式——房屋信息3

实验二7

组合模式——空军指挥系统7 适配器模式——客户信息验证9

实验三14

桥接模式——几何立体体积14

访问者模式——计算机部件销售软件20

实验四24

策略模式——整数排序24

状态模式——交通信号灯错误!未定义书签。

实验五2

MVC软件体系结构2

实验一

工厂方法模式——汽车保险

【实验内容】

在例的汽车保险管理应用程序实例上添加一个名为LuxuryCarInsurance的类，并且，该类要与其他的类一样能执行相应的功能。

【添加代码】

1、添加LuxuryCarInsurance类：

public {

class LuxuryCarInsurance

implements AutoInsurance

private String description; public getInsuranceDescription() {

description = \" LuxuryCarInsurance:

medical wages,

\\n\\nLuxuryCarInsurance coverage pays for bills\" +

lost

rehabilitation, treatment and/or\" +

\" funeral costs for anyone injured or killed \" +

String

\" by your car. Such \" pain and suffering \" party successfully return description;

coverage will also pay for\" + damages when a third \" + sues. \"; } }

2、添加LuxuryCarPolicyProducer类：

public class LuxuryCarPolicyProducer implements PolicyProducer {

public

getPolicyObj() //Fruit factory() { return LuxuryCarInsurance(); } }

3、添加GUI：

AutoInsurance

new

（1）public static final String LUXURYCAR = \"LuxuryCar Insurance\";

（2）

cmbInsuranceType.addItem(LUXURYCAR); （3）if (type.equals(LUXURYCAR)) { pp=new LuxuryCarPolicyProducer(); }

【实验结果】【实验小结】

使用工厂方法访问并且初始化合适的类的对象，简化了应用程序，应用程序本身不再含有大量的条件语句判定何时选取哪个类。其次，工厂方法实现了一些特殊的某个类的机制，尤其是层次结构不同的类需要不同的初始化方法的时候。

抽象工厂方法模式——房屋信息

【实验内容】

在例中设计并且实现了豪华（Super）和中等（Medum）别墅（House）和公寓（Condo）的查询。要求在该设计的基础上，增加一个新的类SemiDetacher（半式楼宇），并且编写代码实现相应的查询功能。

【添加代码】

1、添加SemiDetacher类：

public interface SemiDetacher {

public String getSemiDetacherInfo(); public String getSemiDetacherFeatures(); }

2、添加SuperSemiDetacher类：

public class SuperSemiDetacher implements SemiDetacher {

private String name;

public SuperSemiDetacher(String cName) {

name = cName; }

public String getSemiDetacherInfo() {

return \"superSemiDetacher.html\"; }

public String getSemiDetacherFeatures() {

return \"Super SemiDetacher \"; } }

3、添加MediumSemiDetacher类：

public class MediumSemiDetacher

implements SemiDetacher {

private String name;

public MediumSemiDetacher(String cName) {

name = cName; }

public String getSemiDetacherInfo() {

return \"MediumSemiDetacher.html\"; }

public String getSemiDetacherFeatures() {

return \"Medium SemiDetacher \"; } }

4、添加BuildingFactory：

public abstract SemiDetacher getSemiDetacher();

5、添加MediumBuildingFactory

：

public SemiDetacher getSemiDetacher() {

return new

MediumSemiDetacher(\"Medium SemiDetacher\"); }

6、添加SuperBuildingFactory：

public SemiDetacher getSemiDetacher() {

return new

SuperSemiDetacher(\"Super SemiDetacher\"); }

7、添加GUI：

（1）public static final String SEMIDETACHER = \"SemiDetacher\"; （2）

cmbHouseType.addItem(SEMIDETACHER); （3）if

(type.equals(AbstractFactoryGUI.SEMIDETACHER)) {

SemiDetacher cd = bf.getSemiDetacher(); String fileNm = cd.getSemiDetacherInfo();

putHouseInfoToScreen(fileNm); }

【实验结果】【实验小结】

当客户对象要从一个相关的产品组中创建一个对象，而没有必要知道到底要创建哪个对象时，可以使用抽象工厂模式。如果不使用抽象工厂模式，创建对象的条件语句将会出现在客户程序的许多地方，程序的克维护性差。抽象工厂模式帮助程序员避免了以上所述的重复的、复杂的条件语句，提供必要的创建对象的接口。

实验二

组合模式——空军指挥系统

【实验内容】

在例的设计中，添加一个空军大队（Wing）类，该类与Squadron、Group类是平行的，因此应该继承了AirUnit类。该类的写法与Squadron或者Group类是类似的，所不同的是一个Wing有216中类型的飞机。

【添加代码】

1、添加Wing类：

public class Wing extends AirUnit{

public static final String FEATURES = \"A Wing with 216 aircrafts\"; Airforce[] Airforce[162]; Airforce[] Airforce[18];

fighters bombers

= =

new new

Airforce[] Airforce[18]; Airforce[] Airforce[18];

transporters= eAircrafts

new new

public Wing(){

for(int k=0;k<162;k++){ // need 162 fighters }

for(int k=0;k<18;k++){ // need 18 bombers }

for(int k=0;k<18;k++){ // need 18 transporters }

for(int k=0;k<18;k++){ // need 18 eAirplanes } }

public String getDescription(){ return FEATURES; }

public String fight(){

return super.fight(); } }

2、添加GUI：

（1）private String[] AirForceUnit = {\"SQUADRON\（2）add(1, 6, airCheckBox[13]);

（3）else if ((m==13) && (ckBoxStates[13] == SELECTED)){ unit = new Wing(); airUnits.attach(unit);

unitInfo = unit.getDescription(); }

【实验结果】【实验小结】

我们这样来简单的理解组合模式，组合模式就是把一些现有的对象或者元素，经过组合后组成新的对象，新的对象提供内部方法，可以让我们很方便的完成这些元素或者内部对象的访问和操作。我们也可以把组合对象理解成一个容器，容器提供各种访问其内部对象或者元素的API，我们只需要使用这些方法就可以操作它了。

适配器模式——客户信息验证

【实验内容】

关于例的用于验证客户信息的离架产品类CusInfo Validation的功能扩展问题。要求使用适配器模式。

【添加代码】

1、添加InformationAdapter：

public

boolean isValid=true; int a=0; int b=0;

boolean

isValidEmailAddr(String EmailAddr){

String ns = EmailAddr.trim(); String nStr = ns.replaceAll(\"\\\\s{1,}\ int len = nStr.length(); if

( (((nStr.charAt(0) >='A')&&(nStr.charAt(0) >='Z'))||

((nStr.charAt(0) >='a')&&(nStr.charAt(0) >='z'))) && (len>=5) ) {

for(int m=0; mif( (Character.isLetter(nStr.charAt(m))==true)&&

( Character.isDigit(nStr.charAt(m))==true) ){

isValid=false; }

if(nStr.charAt(m)=='@'){ a++; }

if(nStr.charAt(m)>='0'&&nStr.charAt(m)<='9'){ b++; }

if((m==0)&&(Character.isLetter(nStr.charAt(m))==false)){ isValid=false; } }

if(a!=1){ isValid=false; } if(b==0){ isValid=false; }

return isValid;

} else{ return false; } }

2、添加CusInfoValidator：

public

3、添加GUI：

abstract boolean

isValidEmailAddr(String EmailAddr);

（1）private JTextField txtCustomerName, txtAddress,txtZip,txtCellPhone,txtSSN, txtEmailAddr;

（2）private JLabel lblCustomerName, lblAddress,lblZip, lblCellphone, lblSSN, lblEmailAddr;

（3）txtEmailAddr=new JTextField(20); （

）

lblEmailAddr=

new

JLabel(\"EmailAddr :\");

（5）UIPanel.add(lblEmailAddr); UIPanel.add(txtEmailAddr);

（6）gridbag.setConstraints(lblEmailAddr, gbc);

gbc.gridx = 1;

gbc.gridy = 5;

gridbag.setConstraints(txtEmailAddr, gbc);

gbc.gridx = 0; gbc.gridy = 6;

（7）public String getEmailAddr(){ return txtEmailAddr.getText(); }

（8）String emailaddr = getEmailAddr(); （{

dataTextArea.append(\"\\nWrong EmailAddr.\"); } else{

dataTextArea.append(\"\\nCorrect EmailAddr.\"); }

【实验结果】

9）

if(cusInfo.isValidEmailAddr(emailaddr)==false)

format of

【实验小结】

通过适配器，客户端可以调用同一接口，因而对客户端来说是透明的。这样做更简单、更直接、更紧凑；复用了现存的类，解决了现存类和复用环境要求不一致的问题；将目标类和适配者类解耦，通过引入一个适配器类重用现有的适配者类，而无需修改原有代码；一个对象适配器可以把多个不同的适配者类适配到同一个目标，也就是说，同一个适配器可以把适配者类和它的子类都适配到目标接口。对于对象适配器来说，更换适配器的实现过程比较复杂。

实验三

桥接模式——几何立体体积

【实验内容】

在例中的设计实验层次类部分中，添加Ellipsoid（椭球）类，并且实现针对椭球体积的计算。

【添加代码】

1、添加椭球类：

public GeoForm{

class Ellipsoid implements

private double aRadius; private double bRadius;

private double cRadius;

public Ellipsoid (double aRadius, double bRadius, double cRadius){

this.aRadius = aRadius; this.bRadius = bRadius; this.cRadius = cRadius; }

public double computeVolume(){ double 1.3333333*3.1415926* cRadius;

return volume; } }

2、添加GUI：

volume aRadius*

bRadius*

（1）private JTextField

txtEllipsoidRadius_a;

private JTextField txtEllipsoidRadius_b; private JTextField txtEllipsoidRadius_c; （2）public static final String

ELLIPSOID = \"Ellipsoid\";

（

3）

cmbGeoForm.addItem(ELLIPSOID);

（ String String String

）a_radius b_radius c_radius

else = = = =

if(selection.equals(ELLIPSOID) ){ txtEllipsoidRadius_a.getText(); txtEllipsoidRadius_b.getText(); txtEllipsoidRadius_c.getText();

double Double.valueOf(a_radius);

double b =Double.valueOf(b_radius); double Double.valueOf(c_radius);

form = new Ellipsoid(a, b, c); } （

displayNewGUI( getTypePanel(ELLIPSOID));

（6）else if(type.equals(ELLIPSOID)){ JLabel

c =

5）else

if(selection.equals(ELLIPSOID) )

lblRadius_a

= new

JLabel(\"Input Radius a\");

JLabel JLabel

lblRadius_b lblRadius_c

= = = = = =

new new new new new new

JLabel(\"Input Radius b\"); JLabel(\"Input Radius c\");

txtEllipsoidRadius_a JTextField(8);

txtEllipsoidRadius_b JTextField(8);

txtEllipsoidRadius_c JTextField(8);

GridBagLayout GridBagLayout();

typePanel.setLayout(gridbag); GridBagConstraints GridBagConstraints();

typePanel.add(lblRadius_a); typePanel.add(lblRadius_b); typePanel.add(lblRadius_c); typePanel.add(txtEllipsoidRadius_a); typePanel.add(txtEllipsoidRadius_b); typePanel.add(txtEllipsoidRadius_c);

gridbag

gbc = new

typePanel.add(lblMeasure);

typePanel.add(cmbMeasure); gbc.insets.top = 5; gbc.insets.bottom = 5; gbc.insets.left = 1; gbc.insets.right = 8; gbc.anchor GridBagConstraints.WEST;

gbc.gridx = 0; gbc.gridy = 0;

gridbag.setConstraints(lblRadius_a, gbc); gbc.gridx = 1; gbc.gridy = 0;

gridbag.setConstraints(txtEllipsoidRadius_a, gbc);

gbc.gridx = 0; gbc.gridy = 1;

gridbag.setConstraints(lblRadius_b, gbc); gbc.gridx = 1; gbc.gridy = 1;

gridbag.setConstraints(txtEllipsoidRadius_

b, gbc);

gbc.gridx = 0; gbc.gridy = 2;

gridbag.setConstraints(lblRadius_c, gbc);

gbc.gridx = 1; gbc.gridy = 2;

gridbag.setConstraints(txtEllipsoidRadius_c, gbc);

gbc.gridx = 0; gbc.gridy = 3;

gridbag.setConstraints(lblMeasure, gbc); gbc.gridx = 1; gbc.gridy = 3;

gridbag.setConstraints(cmbMeasure, gbc); }

【实验结果】【实验小结】

通过这次实验我们大概理解了桥接模式，通过关联“抽象层次类”与“具体层次类”这一桥梁，将表示两个维度的层类（数据结构）粘贴在一起，形成更大的数据结构，而这种变化又不会对现有的类产生影响，这种思路的终极想法是将软件设计的抽象部分与实现部分分离，使它们都可以的变化。

访问者模式——计算机部件销售软件

【实验内容】

在例的设计中添加一个类SoundBox。该类实现接口ComputerParts，并且其他的计算机部件的类的结构类似。

【添加代码】

1、添加SoundBox类：

public class SoundBox implements ComputerParts{

public static final String NAME = \"SoundBox\";

private final double PRICE = 127.00; public static final String FEATURES = \"SoundBox. X3K\";

public String getName(){ return NAME; }

public double getPrice(){ return PRICE; }

public String getDescription(){ return FEATURES; }

public void accept(Visitor v){

System.out.println(\"SoundBox has been visited.\");

v.visitSoundBox (this); } }

2、添加GUI:

（1）String[]

compParts={ \"Case\ocessor\

\"DriveController\rSupply\

\"HardDiskDrive\nitor\

\"Keyboard\\"WholePC\

（2）for(int k=11; k<17; k++) add(0, k, cParts[k]); （3）else if (source == cParts[14]) states[14] = state;

else if (source == cParts[15]){ if(state == SELECTED){ cParts[1].setSelected(true); cParts[8].setSelected(true); }

else if (state == DESELECTED){ cParts[1].setSelected(false); cParts[8].setSelected(false); }

states[15]=state; }

else if (source == cParts[16]){ if(state == SELECTED){ cParts[0].setSelected(true); for(int k=11; k<15; k++) cParts[k].setSelected(true); }

else if (state == DESELECTED){ cParts[0].setSelected(false); for(int k=11; k<15; k++)

cParts[k].setSelected(false); }

states[16]=state; }

（4）else if ((m==14) && (states[14] == SELECTED)) {

part = new SoundBox(); msg.add(\"SoundBox\"); }

3、添加Visitor：

public abstract void visitSoundBox (SoundBox e);

4、添加PriceVisitor：

public void visitSoundBox (SoundBox e){

price = e.getPrice();

partsPrices.add(new Double(price)); total += price; }

5、添加PartsInfoVisitor：

public void visitSoundBox (SoundBox e){

partInfo = e.getDescription(); allOders = allOders + \"\\n \" + partInfo; }

【实验结果】

【实验小结】

通过此次实验让我们更加深刻的理解了访问者模式，它在处理数据结构较稳定，但是作用于其上的操作需要经常变化的问题时时非常有效的，因此可以在不改变该结构体中的类的基础上定义一个新的操作，这个实验就是如此，我们只需要添加新的类，然后调用accept(pv)方法就可以。

实验四

策略模式——整数排序

【实验内容】

在的设计中的排序策略部分，添加一个类BidirectionaBubbleSort，进行“双向冒泡法排序”，以便扩展该排序系统的功能。为了实现扩展功能，需要相应地修改Context类与客户图形界面类StrategyGUI。

【添加代码】

1、添加BidirBubbleSort类： public class BidirBubbleSort implements SortAlgorithm {

public int[] sort(int[] nums,Context ct)

{

ct.startExecution(); int j;

int limit = nums.length; int st = -1;

while(st < limit) {

boolean flipped = false; st++; limit--;

for(j = st; j < limit; j++) {

if(nums[j] > nums[j + 1]) {

int T = nums[j]; nums[j] = nums[j + 1]; nums[j + 1] = T; flipped = true; } }

if(!flipped) {

ct.endExecution(); return nums; }

for(j = limit; --j >= st;) {

if(nums[j] > nums[j + 1]) {

int T = nums[j]; nums[j] = nums[j + 1]; nums[j + 1] = T; flipped = true; } }

if(!flipped) {

ct.endExecution(); return nums; } }

ct.endExecution(); return nums; } } 2、添加GUI：

（1）public static final String BidirBubble= \"BidirBubbleSort\";

（2）cmbAlgorithm.addItem(BidirBubble);

}

public void performTask() { Surveillance.takePictures(); Surveillance.doStatistics(); changeState(); }

public void changeState(){ state = RED;

TrafficLight stateObj = new cxt.setStateObj(stateObj); }

RedLight();

}

2、添加TrafficLight：

protected final String BLUE = \"Blue\"; 3、添加YellowLight： state = BLUE;

TrafficLight stateObj = new BlueLight();

【实验结果】【实验小结】

通过此次实验让我们理解了策略模式和状态模式的区别与联系，联系是将控制状态变化的类单独分装在一个类中，把它们出来，不要和那些不需要变化的代码混合在一起，这和策略模式相似。不同的是状态模式考虑的是状态的变

化，状态迁移是一个核心内容；然而，在选择策略时，迁移与此毫无关系。另外，策略模式允许一个客户选择或提供一种策略，而这种思想在状态模式中完全没有，等等。

实验五

MVC软件体系结构

【实验内容】

在例6.25中，在类CarModel中添加拍价验证功能，即一旦给出一个竞拍价，则下一个出价只能高于这个竞拍价为有效拍价。【添加代码】

private String currentBitPrices=\"0\"; private String preBitPrices=\"0\"; publicvoid setBitPrice(String bPrice){ bitPrice = \"\";

bitPrice = bitPrice + bPrice; currentBitPrices=bPrice;

} {

{bitPrice = \"\"; }

publicvoid validateAuctionPrice()

if(currentBitPrices.compareTo(preBitPrices)<0) bitPrice=\"illegal bit price\"; elsepreBitPrices=currentBitPrices;

【实验结果】

【实验小结】

通过这次MVC的实验，了解到无论是在层次体系结构中，还是在MVC体系结构中，都可以在应用层与显示层之间或者在Model与View之间使用观察者模式，将应用层或者Model作为被观察者，将显示层或者View作为观察者。其目的是一旦应用层或者是Model的状态改变的时候，及时通知作为观察者的显示层或View，以便及时刷新用户图形界面。

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文