软件设计与体系结构 实验指导书 2014
实验一经典软件体系结构风格(一) (1)
实验目的 (1)
实验内容 (1)
1．管道-过滤器软件体系结构 (1)
2．数据抽象和面向对象软件体系结构 (2)
思考与提高 (4)
实验二经典软件体系结构风格(二) (5)
实验目的 (5)
实现内容 (5)
1．基于事件的隐式调用风格 (5)
2．层次软件体系结构 (6)
实验三分布式软件体系结构风格 (13)
实验目的 (13)
实验内容 (13)
C/S体系结构风格 (13)
思考与提高 (14)
实验四MVC风格 (15)
实验目的 (15)
实验内容 (15)
MVC的应用和编程实现 (15)
实验五软件设计的目标 (23)
实验目的 (23)
实验内容 (23)
1．用Java语言实现一个计算器程序 (23)
2．健壮性 (23)
3．可维护性——基于面向对象技术的计算器程序 (24)
4．基于简单工厂模式的计算器程序 (25)
5．基于工厂方法模式的计算器程序 (27)
实验六软件设计——面向对象方法 (29)
实验目的 (29)
实验内容 (29)
1．问题域部分的设计——对多重继承的调整 (29)
2．数据管理部分的设计 (30)
实验七设计原则 (35)
实验目的 (35)
实验内容 (35)
1．里氏代换原则 (35)
2．合成/聚合复用原则 (35)
3．依赖倒转原则 (36)
4．迪米特法则 (37)
5．接口隔离原则 (37)
实验八设计模式 (38)
实验目的 (38)
实验内容 (38)
1．单例模式 (38)
2．观察者模式 (38)
实验一经典软件体系结构风格(一)
实验目的
（1）理解管道-过滤器软件体系结构、面向对象软件体系结构的原理
（2）掌握管道-过滤器软件体系结构、面向对象软件体系结构的实例
（3）管道-过滤器软件体系结构、面向对象软件体系结构的编程实现
实验内容
1．管道-过滤器软件体系结构
（1）在dos提示符下输入下面的命令：
dir | more
使得当前目录列表在屏幕上逐屏显示。
dir的输出的是整个目录列表，它不出现在屏幕上而是由于符号“|”的规定，成为下一个命令more的输入，more命令则将其输入一屏一屏地显示，成为命令行的输出。
（2）Java I/O流中的管道流类PipedInputStream和PipedOutputStream可以方便地实现管道-过滤器体系结构，这两个类的实例对象要通过connect方法连接。
下面程序的功能是sender发送“Hello,receiver! I`m sender”给receiver，然后receiver 接受后显示出来并且在前面加上“the following is from sender”的信息。管道流内部在实现时还有大量的对同步数据的处理，管道输出流和管道输入流执行时不能互相阻塞，所以一般要开启独立线程分别执行，顺便复习了多线程操作。
import java.io.*;
import java.util.*;
public class TestPiped{
public static void main(String [] args){
sender s = new sender();
receiver r = new receiver();
PipedOutputStream out = s.getOut();
PipedInputStream in = r.getIn();
try{
in.connect(out);
s.start();
r.start();
}catch(Exception e){
e.printStackTrace();
}
}
}
class sender extends Thread {
PipedOutputStream out = new PipedOutputStream();
public PipedOutputStream getOut(){
return out;
}
public void run() {
String str = "Hello,receiver ! I`m sender\n";
try {
out.write(str.getBytes());
out.close();
} catch(Exception e) {
e.printStackTrace();
}
}
class receiver extends Thread {
PipedInputStream in = new PipedInputStream();
public PipedInputStream getIn() {
return in;
}
public void run(){
byte [] buf = new byte[1024];
try {
int len = in.read(buf);
System.out.println("the following is from sender:\n"+new String(buf,0,len));
in.close();
}catch(Exception e) {
e.printStackTrace();
}
}
}
程序的执行结果：
the following is from sender:
Hello,receiver ! I`m sender
2．数据抽象和面向对象软件体系结构
有一个已知的二维坐标系，在坐标系中定义了若干种规则的图形：圆、正方形、矩形和椭圆。使用Java语言进行面向对象的程序设计：（1）首先考虑数据封装性，（2）考虑继承性，（3）考虑抽象类。
abstract class Graph{
protected double x,y; // x,y是规则图形的中心点坐标
public Graph(double x,double y){ // 构造函数初始化中心点坐标
this.x=x;
this.y=y;
}
protected void changeX(double x){ // 修改横坐标
this.x=x;
}
protected void changeY(double y){ // 修改纵坐标
this.y=y;
}
public abstract double area(); // 计算面积的抽象方法
}
class MySquare extends Graph{
private double length;
public MySquare(double x,double y,double length){
super(x,y);
this.length=length;
}
protected void changLength(double length){ // 修改边长length
this.length=length;
}
public double area(){
return length*length;
}
class MyCircle extends Graph{
private double radius;
public MyCircle(double x,double y,double radius){
super(x,y);
this.radius=radius;
}
protected void changRadius(double radius){ // 修改半径radius this.radius=radius;
}
public double area(){
return 3.1416*radius*radius;
}
}
class MyRectangle extends Graph{
private double a,b;
public MyRectangle(double x,double y,double a,double b){ super(x,y);
this.a=a;
this.b=b;
}
protected void changLength(double length){ // 修改长length a=length;
}
protected void changWidth(double width){ // 修改宽width b=width;
}
public double area(){
return a*b;
}
}
class MyEllipse extends Graph{
private double a,b;
public MyEllipse (double x,double y,double a,double b){
super(x,y);
this.a=a;
this.b=b;
}
protected void changA(double a){ // 修改长轴a
this.a=a;
}
protected void changB(double b){ // 修改短轴b
this.b=b;
}
public double area(){
return 3.1416*a*b;
}
}
public class Area{
public static void main (String arg[]){
MyCircle c=new MyCircle(1,1,3);
MySquare s=new MySquare(2,2,4);
MyRectangle r=new MyRectangle(12,9,1,2);
MyEllipse e=new MyEllipse(2,-1,3,2);
System.out.println("圆c的面积是"+c.area());
System.out.println("正方形s的面积是"+s.area());
System.out.println("矩形r的面积是"+r.area());
System.out.println("椭圆e的面积是"+e.area());
}
}
该程序的运行结果为：圆c的面积是28.2744
正方形s的面积是16.0
矩形r的面积是2.0
椭圆e的面积是18.8496
思考与提高
1、管道-过滤器软件体系结构与批处理软件体系结构的区别和联系是什么？
2、面向对象软件体系结构与主程序-子程序软件体系结构的区别和联系是什么？
实验二经典软件体系结构风格(二)
实验目的
（1）理解基于事件的隐式调用软件体系结构、层次软件体系结构的原理
（2）掌握事件的隐式调用软件体系结构、层次软件体系结构的实例
（3）事件的隐式调用软件体系结构、层次软件体系结构的编程实现
实现内容
1．基于事件的隐式调用风格
常用控制组件的事件——按钮与动作事件（ActionEvent），参见下例。
按钮与动作事件运行结果
import java.awt.*;
import java.awt.event.*; //引入java.awt.event包处理事件
class BtnLabelAction extends Frame implements ActionListener{
//声明窗口类（BtnLabelAction）并实现动作事件接口（ActionListener）
Label prompt;
Button btn;
void CreateWindow(){ //自定义方法
setTitle("MyButton");
prompt = new Label("你好"); //创建标签对象
btn = new Button("操作"); //创建按钮对象
setLayout(new FlowLayout()); //布局设计，用于安排按钮、标签的位置
add(prompt); //将标签放入容器
add(btn); //将按钮放入容器
btn.addActionListener(this); //将监听器（窗体对象本身）注册给按钮对象
setSize(300,100);
setVisible(true);
}
public void actionPerformed(ActionEvent e){//接口ActionListener的事件处理方法
if(e.getSource()==btn) //判断动作事件是否是由按钮btn引发的
if(prompt.getText()=="你好")
prompt.setText("再见");
else
prompt.setText("你好");
}
}
public class BtnTest{
public static void main (String args[]){
BtnLabelAction bla=new BtnLabelAction();
bla.CreateWindow();
}
}
2．层次软件体系结构
基于层次软件体系结构的软件测试系统。
第一层为用户图形界面层
import java.awt.*;
import java.util.*;
import javax.swing.*;
import java.awt.event.*;
import com.sun.java.swing.plaf.windows.*;
public class TestingGUI extends JPanel{
private JTextArea txtTestInfo, txtTestcase;
private JLabel lblTestcases;
private JPanel buttonPanel;
private JComboBox cmbTestcases;
private static final String CASE_BUBBLE= "TC1-Test Bubble Sort";
private static final String CASE_HEAP= "TC2-Test Heap Sort";
private static final String CASE_INSERTION= "TC3-Test Insertion Sort";
private static final String EXECUTE = "Execute";
private static final String EXIT = "Exit";
public TestingGUI(){
txtTestInfo=new JTextArea("Test output from source shown here\n", 6, 20);
txtTestInfo.setLineWrap(true);
txtTestcase = new JTextArea("Testcase info and test validation shown here\n", 4, 15);
txtTestcase.setLineWrap(true);
buildUpScrollGUI();
}
private void buildUpScrollGUI(){
setUpButtonPanel();
JScrollPane btnPane = new JScrollPane(buttonPanel);
JScrollPane textPane = new JScrollPane(txtTestcase);
textPane.setMinimumSize(new Dimension(250, 150));
JScrollPane testDataPane = new JScrollPane(txtTestInfo);
JSplitPane upSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
upSplitPane.setLeftComponent(btnPane);
upSplitPane.setRightComponent(testDataPane);
JScrollPane downPane = new JScrollPane(textPane);
Dimension minimumSize = new Dimension(130, 100);
btnPane.setMinimumSize(minimumSize);
textPane.setMinimumSize(new Dimension(100, 100));
upSplitPane.setDividerLocation(270);
upSplitPane.setPreferredSize(new Dimension(500, 300));
JSplitPane bigSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, upSplitPane, downPane);
bigSplitPane.setDividerLocation(190);
add(bigSplitPane);
setSize(new Dimension(500, 400));
setVisible(true);
}
private void setUpButtonPanel(){
lblTestcases = new JLabel("Test Cases:");
cmbTestcases = new JComboBox();
cmbTestcases.addItem(CASE_BUBBLE);
cmbTestcases.addItem(CASE_HEAP);
cmbTestcases.addItem(CASE_INSERTION);
//Create the open button
JButton executeBtn = new JButton(EXECUTE);
executeBtn.setMnemonic(KeyEvent.VK_S);
JButton exitButton = new JButton(EXIT);
exitButton.setMnemonic(KeyEvent.VK_X);
BtnListener objButtonHandler = new BtnListener();
// add action Listener
executeBtn.addActionListener(objButtonHandler);
exitButton.addActionListener(objButtonHandler);
buttonPanel = new JPanel();
GridBagLayout gridbag = new GridBagLayout();
buttonPanel.setLayout(gridbag);
GridBagConstraints gbc = new GridBagConstraints();
buttonPanel.add(lblTestcases);
buttonPanel.add(cmbTestcases);
buttonPanel.add(executeBtn);
buttonPanel.add(exitButton);
gbc.insets.top = 5;
gbc.insets.bottom = 5;
gbc.insets.left = 5;
gbc.insets.right = 5;
gbc.anchor = GridBagConstraints.EAST;
gbc.gridx = 0;
gbc.gridy = 0;
gridbag.setConstraints(lblTestcases, gbc);
gbc.anchor = GridBagConstraints.WEST;
gbc.gridx = 1;
gbc.gridy = 0;
gridbag.setConstraints(cmbTestcases, gbc);
gbc.anchor = GridBagConstraints.EAST;
gbc.insets.left = 2;
gbc.insets.right = 2;
gbc.insets.top = 25;
gbc.anchor = GridBagConstraints.EAST;
gbc.gridx = 0;
gbc.gridy = 7;
gridbag.setConstraints(executeBtn, gbc);
gbc.anchor = GridBagConstraints.WEST;
gbc.gridx = 1;
gbc.gridy = 7;
gridbag.setConstraints(exitButton, gbc);
}
public void showTestInfo(int[] str ){
txtTestInfo.setText("");
for(int n=0; n< str.length; n++)
txtTestInfo.append(""+str[n]+" ");
}
public void showErrors(String err){
txtTestcase.append(err+"\n");
}
public String getSelectedTestcase() {
return (String) cmbTestcases.getSelectedItem();
}
class BtnListener implements ActionListener{
private Testcase test;
private String selectedTestcase;
public void actionPerformed(ActionEvent e){
String searchResult = null;
int[] output=null;
if (e.getActionCommand().equals(EXIT)){
System.exit(1);
}
if (e.getActionCommand().equals(EXECUTE)){
selectedTestcase = getSelectedTestcase();
if(selectedTestcase.equals(CASE_BUBBLE))
test = new TestcaseBubble();
else if(selectedTestcase.equals(CASE_HEAP))
test = new TestcaseHeap();
else if(selectedTestcase.equals(CASE_INSERTION))
test = new TestcaseInsertion();
output = test.execute(3000);
showTestInfo(output);
}
showErrors(selectedTestcase);
boolean result = ResultVerification.isResultCorrect(output );
showErrors("No Error found = " +result);
long timeTaken = test.getTimeTaken();
showErrors("Testing Time takes = " + timeTaken+"\n");
}
} // End of class BtnListener
private static void createAndShowGUI(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Layered Architecture- Software Testing");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
TestingGUI newContentPane = new TestingGUI();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
frame.pack();
frame.setVisible(true);
}
static public void main(String argv[]) {
javax.swing.SwingUtilities.invokeLater(new Runnable() { public void run() {
createAndShowGUI();
}
});
}
}
public class ResultVerification{
static boolean flag = true;
public static boolean isResultCorrect(int[] arr){
for(int k=0; k if(arr[k] > arr[k+1]){ flag=false; System.out.println("error "+ k); //break; } } return flag; } } 第二层为测试案例层，包括软件测试工程师所编写的测试案例public interface Testcase{ public abstract int[] execute(int len); public abstract long getTimeTaken(); } class Context { SortAlgorithm alg; // Constructor public Context(SortAlgorithm alg) { this.alg = alg; } public int[] sortIntArray(int[] a) { return this.alg.sort(a); } } import java.util.Random; public class IntegerArrGenerator{ public static int[] generateInput(int len){ int[] input= new int[len]; Random r = new Random(); for(int m=0; m< len; m++){ input[m] = r.nextInt(len); } return input; } } import java.util.*; public class TestcaseBubble implements Testcase{ private long startTime; private long timeTaken=0; public int[] execute(int len) { startTime = System.currentTimeMillis(); int[] input = IntegerArrGenerator.generateInput(len); SortAlgorithm sa = new BubbleSort(); Context context = new Context(sa); int[] intArray = context.sortIntArray(input); timeTaken = System.currentTimeMillis() - startTime; return intArray; } public long getTimeTaken(){ return timeTaken; } } import java.util.*; public class TestcaseHeap implements Testcase{ //static long time; private long startTime; private long timeTaken=0; public int[] execute(int len){ startTime = System.currentTimeMillis(); int[] input = IntegerArrGenerator.generateInput(len); SortAlgorithm sa = new HeapSort(); Context context = new Context(sa); int[] intArray = context.sortIntArray(input); timeTaken = System.currentTimeMillis()-startTime; return intArray; } public long getTimeTaken(){ return timeTaken; } } import java.util.*; public class TestcaseInsertion implements Testcase{ private long startTime; private long timeTaken=0; public int[] execute(int len){ startTime = System.currentTimeMillis(); int[] input = IntegerArrGenerator.generateInput(len); SortAlgorithm sa = new InsertSort(); Context context = new Context(sa); int[] intArray = context.sortIntArray(input); timeTaken = System.currentTimeMillis()-startTime; return intArray; } public long getTimeTaken(){ return timeTaken; } } 第三层为被测试软件层（排序算法） public interface SortAlgorithm { int[] sort(int[] nums); } public class BubbleSort implements SortAlgorithm { public int[] sort(int[] nums){ for(int i = nums.length; --i >= 0;) for(int j = 0; j < i; j++){ if(nums[j] > nums[j + 1]){ //exchange nums[j+1] with nums[j] int T = nums[j]; nums[j] = nums[j + 1]; nums[j + 1] = T; } } return nums; } } public class HeapSort implements SortAlgorithm{ public int[] sort(int nums[ ]) { for(int i=nums.length; i>1; i--){ buildBinaryHeapTree(nums, i - 1); swapLeadingNodeWithLastNode(nums, i - 1); } return nums; } public void buildBinaryHeapTree(int array[], int arrayBound){ int leftChild, rightChild, biggerChild, temp; int root = (arrayBound-1)/2; // Find the bigger child index for(int i=root; i>=0; i--) { leftChild = (2*i)+1; rightChild = (2*i)+2; if((leftChild <= arrayBound) && (rightChild <= arrayBound)){ if(array[rightChild] >= array[leftChild]) biggerChild = rightChild; else biggerChild = leftChild; } else{ if(rightChild > arrayBound) biggerChild = leftChild; else biggerChild = rightChild; } //swap the integer contained in the bigger child index //with that in the current parent node if(array[i] < array[biggerChild]){ temp = array[i]; array[i] = array[biggerChild]; array[biggerChild] = temp; } } return; } public static void swapLeadingNodeWithLastNode(int array[], int arrayBound){ int temp; temp = array[0]; array[0] = array[arrayBound]; array[arrayBound] = temp; return; } } public class InsertSort implements SortAlgorithm { public int[] sort(int[] nums){ for (int i = 1; i < nums.length; i++){ int j = i; int numToBeInserted = nums[i]; while ((j > 0) && (nums[j-1] > numToBeInserted) ) { nums[j] = nums[j-1]; j--; } nums[j] = numToBeInserted; } return nums; } } 实验三分布式软件体系结构风格 实验目的 （1）理解分布式软件体系结构风格的原理 （2）掌握分布式软件体系结构风格的实例 （3）常见分布式软件体系结构风格的编程实现 实验内容 C/S体系结构风格 客户机发送数据到服务器，服务器将收到的数据返回给客户机，直到接收到字符串“end”为止，最后关闭连接。 （1）服务器端程序tcpServer.java import java.io.*; import https://www.wendangku.net/doc/a45523193.html,.*; public class tcpServer { public static final int PORT=8888; public static void main(String[] args) throws IOException{ //建立ServerSocket ServerSocket s=new ServerSocket(PORT); System.out.println("ServerSocket:"+s); try{ /*程序阻塞,等待连接。即直到有一个客户请求到达,程序方能继续执行*/ Socket ss=s.accept(); System.out.println("Socket accept:"+ss); try { //连接成功，建立相应的I/O数据流 DataInputStream dis=new DataInputStream(ss.getInputStream()); DataOutputStream dos=new DataOutputStream(ss.getOutputStream()); //在循环中，与客户机通信 while(true){ String str=dis.readUTF(); //从客户机中读数据 if(str.equals("end"))break; //当读到end时，程序终止 System.out.println(str); dos.writeUTF("Echoing:"+str); //向客户机中写数据 } dos.close(); dis.close(); }finally{ ss.close(); } }finally{ s.close(); } } } 服务器端运行结果为： ServerSocket:ServerSocket[addr=0.0.0.0/0.0.0.0,port=0,localport=8888] Socket accept:Socket[addr=/127.0.0.1,port=7312,localport=8888] 测试:0 测试:1 测试:2 测试:3 测试:4 测试:5 （2）客户机端程序tcpClient.java import java.io.*; import https://www.wendangku.net/doc/a45523193.html,.*; public class tcpClient { public static void main(String[] args) throws IOException{ //建立Socket，服务器在本机的8888端口处进行“侦听” Socket ss=new Socket("127.0.0.1",8888); System.out.println("Socket:"+ss); try{ //套接字建立成功，建立I/O流进行通信 DataInputStream dis=new DataInputStream(ss.getInputStream()); DataOutputStream dos=new DataOutputStream(ss.getOutputStream()); for(int i=0;i<6;i++){ dos.writeUTF("测试:"+i); //向服务器发数据 dos.flush(); //刷新输出缓冲区，以便立即发送 System.out.println(dis.readUTF()); //将从服务器接收的数据输出 } dos.writeUTF("end"); //向服务器发送终止标志 dos.flush(); //刷新输出缓冲区，以便立即发送 dos.close(); dis.close(); }finally{ ss.close(); } } } 客户器端运行结果为：Socket:Socket[addr=/127.0.0.1,port=8888,localport=7312] Echoing:测试:0 Echoing:测试:1 Echoing:测试:2 Echoing:测试:3 Echoing:测试:4 Echoing:测试:5 思考与提高 1. 要求服务器能同时处理多个客户机的请求，运用多线程处理机制解决这个问题的。 2．利用套接字技术实现应用程序中对数据库的访问。应用程序只是利用套接字连接向服务器发送一个查询的条件，而服务器负责对数据库的查询，然后服务器再将查询的结果利用建立的套接字返回给客户端。 实验四 MVC风格 实验目的 （1）理解MVC风格的原理 （2）掌握MVC的应用和编程实现 实验内容 MVC的应用和编程实现 采用MVC软件体系结构的二手车拍卖系统的设计与实现。 模型类CarModel封装二手车软件的业务逻辑部分，包括核心数据以及tell()方法（将状态的改变通知视图类） import java.io.*; import https://www.wendangku.net/doc/a45523193.html,.URL; import https://www.wendangku.net/doc/a45523193.html,.URI; import javax.swing.*; import java.util.*; public class CarModel{ private String[] carNameList; private URL imgURL; private URL carFileUrl; private ImageIcon imgIcon; private String carSelected; private String bitPrice; static final String CARFILES = "CarFiles/"; static final String CARIMAGES = "CarImages/"; public CarModel(){ carNameList=new String[200]; } public void setCarList(String[] cars){ carNameList = cars; } public String[] getCarList(){ return carNameList; } public void setSelectedCar(String sCar){ carSelected = sCar; } public String getSelectedCar(){ return carSelected; } public void setBitPrice(String bPrice){ bitPrice = ""; bitPrice = bitPrice + bPrice; } public String getBitPrice(){ return bitPrice; } public void setupImageIcon(){ String iconStr = CARIMAGES + carSelected+".jpg"; imgIcon = createImageIcon(iconStr); } public ImageIcon getImageIcon(){ return imgIcon; } public void setCarFileURL(){ try{ String fileURLStr = CARFILES + carSelected+ ".html"; URI uri = (new File(fileURLStr)).toURI(); carFileUrl= uri.toURL(); } catch (IOException e){ e.printStackTrace(); } } public URL getCarFileURL(){ return carFileUrl; } protected ImageIcon createImageIcon(String path){ imgURL = getClass().getResource(path); if (imgURL != null) { return new ImageIcon(imgURL); } else { System.err.println("Couldn't find file: " + path); return null; } } public void tell(View view){ view.update(); } } // End of class 视图类CararGUIView和CarBitView为图形界面类，在update()方法中自动调用CarModel 类的有关信息，并显示在图形界面上。 public interface View{ public abstract void update(); } import java.awt.*; import java.util.*; import javax.swing.*; import java.io.*; import https://www.wendangku.net/doc/a45523193.html,.URL; import java.awt.event.*; import com.sun.java.swing.plaf.windows.*; public class CarGUIView extends JFrame implements View{ private JEditorPane editorPane; private JScrollPane imagePane; private JScrollPane textPane; private JSplitPane splitPane; private JLabel imgLabel; private CarModel model; public CarGUIView(CarModel cmodel){ super("Car information- Observer 1"); model = cmodel; buildUpScrollGUI(); } private void buildUpScrollGUI(){ imgLabel = new JLabel(); imgLabel.setBackground(Color.green); imgLabel.setMinimumSize(new Dimension(250, 200)); editorPane = new JEditorPane(); editorPane.setEditable(false); imagePane = new JScrollPane(imgLabel); imagePane.getViewport().setBackground(Color.green); textPane = new JScrollPane(editorPane); textPane.setMinimumSize(new Dimension(250, 200)); splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT); splitPane.setLeftComponent(imagePane); splitPane.setRightComponent(textPane); Dimension minimumSize = new Dimension(130, 100); imagePane.setMinimumSize(minimumSize); textPane.setMinimumSize(new Dimension(100, 100)); splitPane.setDividerLocation(160); splitPane.setPreferredSize(new Dimension(500, 300)); Container contentPane = getContentPane(); contentPane.add(splitPane); setSize(400, 150); setVisible(true); } public void update(){ try{ URL url = model.getCarFileURL(); editorPane.setPage(url); System.out.println("We have been called."); } catch (IOException e){ e.printStackTrace(); } ImageIcon imIcon = model.getImageIcon(); imgLabel.setIcon(imIcon); imgLabel.validate(); } } import java.awt.*; import javax.swing.*; public class CarBitView extends JFrame implements View{ private JPanel showPanel; private JLabel bitOfferedLabel; private JTextArea bitText; private CarModel model; //public CarBitView(CarModel cmodel) throws Exception{ public CarBitView(CarModel cmodel) { super("Car Bit Info View- Observer 2"); model = cmodel; bitOfferedLabel = new JLabel("Latest bit offered:"); bitText = new JTextArea(4, 20); bitText.setFont(new Font("Serif", Font.PLAIN, 14)); bitText.setLineWrap(true); bitText.setWrapStyleWord(true); Container contentPane = getContentPane(); contentPane.add(bitOfferedLabel, BorderLayout.NORTH); contentPane.add(bitText, BorderLayout.CENTER); setSize(400, 150); setVisible(true); } public void update(){ System.out.println("Car bit has been called."); String sCar= model.getSelectedCar(); String pr = model.getBitPrice(); bitText.append("\n Bit price for "+ sCar + "="+ pr); } }// end of class 控制器Controller负责根据CarAuctionGUI对象输入的客户选择信息更新CarModel的数据。 import java.awt.event.*; import javax.swing.*; import https://www.wendangku.net/doc/a45523193.html,.URL; class Controller implements ActionListener{ private CarAuctionGUI objCarGui; private CarModel cm; private CarGUIView civ; private CarBitView cb; private String carPrice; private String[] carList; public Controller(CarAuctionGUI objCarGui,CarModel cm, CarGUIView civ,CarBitView cb){ this.objCarGui = objCarGui; this.cm=cm; this.civ=civ; 软件设计报告 ( 2014 / 2015 学年第二学期) 课程名称软件设计 指导老师赵江实习时间第十八周学生姓名学号 ____学院______专业 软件设计 课程编号：B0465011C 适用专业： 班级： 一、所涉及的课程及知识点 涉及的课程：第6学期之前的专业基础课程。 知识点：专业基础课程中所学的知识点。 二、目的与任务 目的：通过软件设计，培养学生的实践能力和创新精神，加强学生对专业基础课程的理解和掌握，加强学生高级语言编程能力、应用软件以及仿真能力。 任务：选择以下任一模块进行设计：Matlab软件仿真、C语言及应用。 软件设计的内容 题目1：如果给出两个矩阵?? ??? ?????=136782078451220124A ，????? ?????=087654321B ，执行下面的矩阵运算命令。 （1）B A *5+和I B A +-分别是多少（其中I 为单位矩阵） （2）B A *?和B A *将分别给出什么结果，它们是否相同为什么 逻辑功能程序： function [ ] = EXP1() A=[4,12,20;12,45,78;20,78,136]; B=[1,2,3;4,5,6;7,8,0]; I=eye(3); disp('A+5*B='); disp(A+5*B); disp('A-B+I=') disp(A-B+I); disp('A.*B='); disp(A.*B) disp('A*B='); disp(A*B); End 实验过程与结果 打开matlab ，在命令窗口“Command Window ”中键入edit,启动程序编辑器。输入完整程序后利用save as 储存为M 文件，文件名为EXP1。返回主界面， 软件开发过程 实验一软件需求分析 一、目的和意义 对本书第二和三章的内容做进一步的掌握，写出软件需求规格说明书。为下面的实习奠定基础。 二、实习内容 xx、确定软件题目（学生可自己拟定，也可在本书附录2中选择）； 2、分析软件需求以及人工模式下的工作流程； 3、编写需求规格说明书（需求规格说明书的编写要求参见本节模板参考）； 4、完成形式：以文档的形式完成软件的需求规格说明书。纸张型号为A4。 三、实习指导 xx、在磁盘上建立一个软件工程实习文件夹，以自己的姓名命名。 2、提交文档的格式如下： 第一页的格式为： 软件名称：文档编号 版本号 文档名称： 项目名称： 项目负责人： 编写时间 审核时间 批准时间 开发单位 第二页之后的内容为： ●编写目的：阐明编写该文档的目的，指出读者对象 ●项目背景：项目的委托单位、开发单位、该软件系统与其他系统的关系。 ●参考资料 软件需求规格说明的书写原则 ①任务概述：软硬件环境、条件和限制（软件的使用条件和限制）。 ②数据描述：输入数据、输出数据、数据库设计和建立数据词典。 ③功能需求：功能划分和功能描述 ④性能需求：数据精度、时间特性、适应性（操作方式、与其他软件的接口、开 发计划变化时，软件应具有的适应能力。）。 ⑤运行要求：用户界面、硬件接口（如：连接打印机）、软件接口（如：是否为 其他项目的子项目）、故障处理。 ⑥其他需求：可使用性、安全保密性、可维护性、可移植性等。 ●模板参考 第一页： 软件名称：教务管理软件文档编号 xxxxxx 版本号 Ver xx.xx 文档名称：需求规格说明书 项目名称：课表编排系统 项目负责人：屈艳 编写： 组 第二页之后的内容： 编写目的：编写该文档是为了分析人工状态下课表编排的工作流程，把人工模式抽象为可在计算机上处理的自动模式。便于开发小组成员对系统整体功能的认识。 项目背景：高校的课表编排一直是一个烦琐的工作，为了解决这个问题，某某高校教务处委托我们开发该软件。该软件是高校教务软件的一个子系统。该子系统与专业规划子系统和教师管理软件有一定的关系。 参 实用软件工程（第二版）北京：清华大学出版社，xxxxxx7 任务概述： 硬件环境：CPU的型号为PentiumIII以上，内存25xxM ，及其兼容机 1.面向对象编程中是如何体现封装性的？ 2.面向对象编程的重载和重写的含义是什么？ 3.什么是接口回调？其过程细节是怎样的？ 4.是举例说明什么是组合关系和依赖关系？ 5.距离说明什么是抽象类和接口，有什么区别，如何应用它 们？ 6.面向对象方法有哪些基本原则？ ①抽象类与接口②面向抽象原则③开-闭原则④“多用组 合，少用继承”原则⑤“高内聚-低耦合“原则 7.什么是设计模式？它的基本要素有哪些？ 8.什么是框架？框架与模式的区别有哪些？ 框架是针对某个领域，提供用于开发应用系统的类的集合。 区别：①层次不同②范围不同③相互关系 9.举例说明面向对象的多态性？ 10.软件体系结构有哪几种形式？ 1.概念结构：从主要设计元素（构件）及其相互关联、设 计原则和性能角度考虑的结构。 2.模块结构：根据功能分解建立模块的层次结构包括模块 接口、模块管理、模块控制和一致性等问题。 3.代码结构：描述源程序，二进制程序，库文件。在开发 环境下的组织包括系统资源配置管理，系统构造和对象嵌 入机制 OEM 等。 4.执行结构：描述系统的动态结构包括性能、调度、动态 配置和不同系统间的接口等。 11.构件之间的连接方式有哪些？ 1)过程调用: 在某一特定执行路径中传递执行指针。如普通 过程调用、远程过程调用。 2)数据流: 相互独立的处理通过数据流进行交互，在得到数 据的同时被赋予控制权限。如 UNIX 系统中的管道。 3)间接激活: 处理因事件的发生而激活，在处理间没有直接 交互。例如，事件驱动系统、自动垃圾回收等。 4)消息传递: 相互独立的处理间有明确交互，通过显式数据 传递。传递可以是同步的，也可以是异步的。如TCP/IP 。 5)共享数据: 构件通过同一数据空间进行并发操作。如多用 户数据库, 数据黑板。 12.C/S体系结构的主要组成部分有哪些？其作用是什么？ 1)服务器：负责给其他子系统提供服务。如，数据库服 务器提供数据存储和管理服务，文件服务器提供文件 管理服务，打印服务器提供打印服务等。 2)客户机：向服务器请求服务。客户机通常都是独立的 子系统，在某段时间内，可能有多个客户机程序在并 发运行。 设计模式实验指导 一、实验目的 使用合理的UML建模工具（ROSE或者Visio）和任意一种面向对象编程语言实现几种常用的设计模式，加深对这些模式的理解，包括简单工厂模式、工厂方法模 式、抽象工厂模式、单例模式、适配器模式、组合模式、装饰模式、外观模式、、命令模式、迭代器模式、观察者模式、策略模式等12种模式。 二、实验内容 根据以下的文档描述要求，使用合理的UML建模工具（ROSE或者Visio）和任意一种面向对象编程语言实现以下设计模式，包括根据实例绘制相应的模式结构图、编写模式实现代码，运行并测试模式实例代码。 (1)、简单工厂模式 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数R，则返回一个Robot对象，对代码进 行修改并注意女娲的变化。 (2)、工厂方法模式 海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。 (3)、抽象工程模式 电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。 (4)、单例模式 用懒汉式单例实现在某系统运行时，其登录界面类LoginForm只能够弹出一个，如果第二次实例化该类则提示“程序已运行”。绘制类图并编程实现。 提示:不要求做界面，用类模拟界面就可以了。 (5)、组合模式 使用组合模式设计一个杀毒软件(AntiVirus)的框架，该软件既可以对某个文件夹(Folder)杀毒，也可以对某个指定的文件(File)进行杀毒，文件种类包括文本文件TextFile、图片文件ImageFile、音频视频文件MediaFile。绘制类图并编程实现。 (6)、适配器模式 现有一个接口DataOperation定义了排序方法sort(int[]) 和查找方法search(int[], int)，已知类QuickSort的quickSort(int[])方法实现了快速排序算法，类BinarySearch 的binarySearch(int[], int)方法实现了二分查找算法。现使用适配器模式设计一个系统，在不修改源代码的情况下将类QuickSort和类BinarySearch的方法适配到DataOperation接口中。绘制类图并编程实现。（要求实现快速排序和二分查找） (7)、装饰模式 某图书管理系统中，书籍类(Book)具有借书方法borrowBook()和还书方法returnBook() 。现需要动态给书籍对象添加冻结方法freeze()和遗失方法lose()。使用装饰模式设计该系统，绘制类图并编程实现。 (8)、外观模式 在电脑主机(Mainframe)中，只需要按下主机的开机按钮(on())，即可调用其他硬 软件项目管理课程设计报告 学院: 专业: 班级: 学号: 姓名: 指导教师: 时间:2013年 1月 目录 1、项目概述 (1) 2、工作任务 (Statement Of Work,SOW书 (1) (一整体要求 (1) (二系统逻辑模型 (2) (三系统功能描述 (3) (四应达到的技术指标和参数 .................................... 3 3、项目进度计划 .. (4) (一分解项目工作 (4) (二项目工作关系表 (5) (三项目甘特图 (6) (四网络进度计划图 (7) (五里程碑计划 ................................................ 9 4、项目规模成本估算 . (9) (一分解项目工作 (9) (二项目规模估算表 (11) (三计算开发成本 (12) (四计算管理、质量成本 (12) (五直接成本 (12) (六计算间接成本 (12) (七计算总估算成本 (12) (八项目报价 ................................................. 13 5. 项目质量计划 .. (13) (一项目质量保证组织 (13) (二质量目标 (14) (三质量策略 (15) (四质量保证活动 (15) (五质量控制活动 (17) (六质量保证的报告途径 (17) (七记录的收集、维护和保存 ................................... 17 6、软件项目团队 . (17) (一团队组织及职责 (18) (二项目的沟通计划 ........................................... 19 7、软件项目配置管理计划 .. (19) 学校内部职工工资系统项目管理书 1、项目概述 假设学校共有教职工约 1000人, 10个行政部门和 8个系部。每个月 20日前各部门(包括系、部要将出勤情况上报人事处, 23日前人事处将出勤工资、奖金及扣款清单送财务处。财务处于每月月底将教职工的工资表做好并将数据送银行。每月初(3日前将工 【精品实验报告】软件体系结构设计模式实验报告软件体系结构 设计模式实验报告 学生姓名: 所在学院: 学生学号: 学生班级: 指导老师: 完成日期: 一、实验目的 熟练使用PowerDesigner和任意一种面向对象编程语言实现几种常见的设计模式，包括组合模式、外观模式、代理模式、观察者模式和策略模式，理解每一种设计模式的模式动机，掌握模式结构，学习如何使用代码实现这些模式，并学会分析这些模式的使用效果。 二、实验内容 使用PowerDesigner和任意一种面向对象编程语言实现组合模式、外观模式、代理模式、观察者模式和策略模式，包括根据实例绘制模式结构图、编写模式实例实现代码，运行并测试模式实例代码。 (1) 组合模式 使用组合模式设计一个杀毒软件(AntiVirus)的框架，该软件既可以对某个文件夹(Folder)杀毒，也可以对某个指定的文件(File)进行杀毒，文件种类包括文本文件TextFile、图片文件ImageFile、视频文件VideoFile。绘制类图并编程模拟实现。 (2) 组合模式 某教育机构组织结构如下图所示: 北京总部 教务办公室湖南分校行政办公室 教务办公室长沙教学点湘潭教学点行政办公室 教务办公室行政办公室教务办公室行政办公室 在该教育机构的OA系统中可以给各级办公室下发公文，现采用 组合模式设计该机构的组织结构，绘制相应的类图并编程模拟实现，在客户端代码中模拟下发公文。(注:可以定义一个办公室类为抽象叶子构件类，再将教务办公室和行政办公室作为其子类;可以定义一个教学机构类为抽象容器构件类，将总部、分校和教学点作为其子类。) (3) 外观模式 某系统需要提供一个文件加密模块，加密流程包括三个操作，分别是读取源文件、加密、保存加密之后的文件。读取文件和保存文件使用流来实现，这三个操作相对独立，其业务代码封装在三个不同的类中。现在需要提供一个统一的加密外观类，用户可以直接使用该加密外观类完成文件的读取、加密和保存三个操作，而不需要与每一个类进行交互，使用外观模式设计该加密模块，要求编程模拟实现。参考类图如下: reader = new FileReader();EncryptFacadecipher = new CipherMachine();writer = new FileWriter();-reader: FileReader-cipher: CipherMachine-writer: FileWriter +EncryptFacade () +fileEncrypt (String fileNameSrc,: voidString plainStr=reader.read(fileNameSrc); String fileNameDes)String 1、各种性能指标的定义及如何到达各种性能指标的方法ppt1-8 119页-124页 ①性能：吞吐量Throughput 、响应时间Response Time 、Deadlines ②实现吞吐量：Peak & Average Many system have low average but high peak throughput requirements ③实现响应时间： Guaranteed & Average E.g. 95% of responses in sub-4 seconds, and all within 10 seconds ④Dealines ：Deadlines often associated with batch jobs in IT systems 2、常用的中间件有那几种类型（四种） 分类：Business Process Orchestrators 业务流程协调器 Message Brokers 消息代理 Application Servers 应用服务器 Transport 面向消息的中间件，分布式对象系统 （1）CORBA---公用对象请求代理（调度）程序体系结构，它在对象间建立客户-服务器的关系，这样一个客户可以很简单地使用服务器对象的方法而不论服务器是在同一机器上还是通过一个网络访问。 （常见的对象请求代理架构） （2）Basic Message-oriented middleware---- MOM 指的是利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可在分布环境下扩展进程间的通信，并支持多通讯协议、语言、应用程序、硬件和软件平台。 （面向消息的中间件） （3）J2EE---- J2EE 核心是一组技术规范与指南，其中所包含的各类组件、服务架构及技 Message-Oriented Middleware, Distributed Objects Systems J2EE, CCM, .NET BizTalk, WebSphere Message Broker, SonicMQ BizTalk, TIBCO StaffWare, ActiveBPEL 编号：（）字号 《软件课程设计》报告 班姓学级：名：号： 指导老师： 职称： 计算机科学与技术学院 二〇〇八年月 专业年级： 学生姓名： 任务下达日期： 课程设计日期： 课程设计题目：面向过程 一．需求分析 设计任务：软件课程设计任务书 题目七： 1.将输入的罗马数据化为10进制数。假设罗马数据中只使用如下7 个“基值”字母：M、D、C、L、X、V、I，分别用来表示 1000、500、100、50、10、5、1。如，罗马数据LXXXVII 表示10 进 制的87。 2.将输入的10进制正整数转换为罗马数据。假设罗马数据中只使用 “基值”字母：M、D、C、L、X、V、I，分别用来表示 1000、500、100、50、10、5、1。 主要界面为： 输入1或2可以选择功能。 输出的形式 如上所示：当输入大写或小写的阿拉伯字母时。 程序能计算出十进制。 程序所能达到的功能 测试的数据：当输入mvii罗马数字时输出十进制 1007 当输入十进制数4535 时相应输出MMMMDXXXV。 二．概要设计 程序中主要在开头用了一个死循环来实现功能的不断循环。通过exit函数退出程序。 主程序的流程以及各程序模块之间的层次（调用）关系。 Convert1() Break; >switch(n) Default; 三．详细设计 实现概要设计中定义的数据类型和操作。以增加程序的可读性，关键算法部分 画出程序流程图。 主函数的流程图如右图示： Switch() Cin>>n Convert1() Break; Case1: Case2:; Convert2(); Break; Default; Exit(1); While(1) Main() Return 0; Main->jiemina->while(1)- Convert2() Break; Exit() 实验一单例模式的应用 1 实验目的 1) 掌握单例模式（Singleton）的特点 2) 分析具体问题，使用单例模式进行设计。 2 实验内容和要求 很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 通常客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。 事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应该怎么实现呢？用C#控制台应用程序实现该单例模式。绘制该模式的UML 图。 3 实验代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AppConfig { publicclass Singleton { privatestatic Singleton instance; private Singleton() { } publicstatic Singleton GetInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } class Program { staticvoid Main(string[] args) { Singleton singletonOne = Singleton.GetInstance(); Singleton singletonTwo = Singleton.GetInstance(); if (singletonOne.Equals(singletonTwo)) { Console.WriteLine("singletonOne 和 singletonTwo 代表的是同一个实例"); } else { Console.WriteLine("singletonOne 和 singletonTwo 代表的是不同实例"); } Console.ReadKey(); } } } 4 实验结果 通达学院 2017/2018 学年第 1 学期 课程设计实验报告 模块名称综合软件设计 专业通信工程 学生班级141301 学生学号14130118 学生姓名陈启朋 指导教师王诚 目录 第一章在线考试系统 (1) 1.1 实验目的 (1) 1.2 实验内容 (1) 1.3.1考试登录模块设计 (1) 1.3.2管理员模块设计 (7) 1.4 实验结果 (12) 第二章学生成绩管理系统 (13) 2.1 实验目的 (13) 2.2 实验内容 (13) 2.3 实验过程 (13) 2.3.1学生成绩管理模块设计 (13) 2.3.2 公共模块设计 (18) 2.4 实验结果 (20) 总结 (21) 参考文献 (21) 第一章在线考试系统 1.1 实验目的 通过本次软件设计，使学生掌握并能熟练运用Java和mysql语言编写程序，掌握面向对象的概念，采用C/S结构，设计数据库模型，能够了解和数据库连接的方法。 1.2 实验内容 本次实验的内容是编辑生成试题库，随机生成本次考试试题，提供在先评分并保存结果；同时，管理员可以添加、修改、删除考题和考生用户。 1.3 实验过程 1.3.1考试登录模块设计 主要程序如下： package com.Exam.Index; import java.awt.Insets; import javax.swing.*; import javax.swing.GroupLayout; import https://www.wendangku.net/doc/a45523193.html,youtStyle; import com.Exam.bean.*; import com.Exam.controller.ControllerFrame; import com.Exam.dao.*; public class MyLand extends javax.swing.JFrame { initComponents(); }@SuppressWarnings("unchecked") private void initComponents() { jTextField3 = new javax.swing.JTextField(); jTextField1 = new javax.swing.JTextField(); jpanel = new MyJPanel(); choicejLabel = new javax.swing.JLabel(); userChoicejComboBox = new javax.swing.JComboBox(); choicejLabel1 = new javax.swing.JLabel(); UserNameTextField = new javax.swing.JTextField(); choicejLabel2 = new javax.swing.JLabel(); PassWordjTextField = new javax.swing.JPasswordField(); enterButton = new javax.swing.JButton(); enterButton.setMargin(new Insets(2, 2, 2, 2)); resButtonjButton = new javax.swing.JButton(); resButtonjButton.setMargin(new Insets(2, 2, 2, 2)); jTextField3.setText("jTextField3"); jTextField1.setText("jTextField1"); setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); choicejLabel.setText("选择用户："); userChoicejComboBox.setModel(newjavax.swing.DefaultComboBoxModel(new String[] { "","考生", "管理员" })); setTitle("考试系统"); choicejLabel1.setText("用户名："); UserNameTextField.setText(""); choicejLabel2.setText(" 密码："); PassWordjTextField.setText(""); enterButton.setText("登录"); enterButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { enterButtonActionPerformed(evt); } }); resButtonjButton.setText("重置"); resButtonjButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jButton2ActionPerformed(evt); } }); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); 1面向对象编程中是如何体现封装性的？ 封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。 2重载和重写的含义 重载是发生在一个类中，方法名相同，参数不同 重写（覆盖）是子类继承父类，子类可以通过重写的方法隐藏继承的方法 3 什么是接口回调，过程细节是什么？ 概念：把可以实现某一接口的类创建的对象的引用赋给该接口声明接口变量，那么该接口变量可以调用被类实现（重写）的接口方法。 4试举例说明什么是组合关系和依赖关系 组合（关联）关系：A类中成员变量是用B类声明的对象。公司--职员 依赖关系：A类中某个方法的参数是用B类声明的对象，或某个方法返回的数据类型是B类的对象 5抽象类和接口，区别是什么？如何应用 抽象类：抽象类中有抽象方法；抽象类中不能用new运算符创建对象；抽象类的对象做商转型对象 接口：（1）接口中只可以有public权限的抽象方法，不能有非抽象方法； （2）接口由类去实现，即一个类如果实现一个接口，那么他必须重写接口中的抽象方法 （3）接口回调 区别：接口中只有常量，不能有变量；抽象类中既可以有常量也可以有变量； 抽象类中也可以有非抽象方法，接口不可以。 应用：定义抽象方法：public abstract void 方法名(); 在子类实现抽象方法：public void 方法名(){} 接口：public interface 接口名{}接口只负责定义规则，不负责任何实现；实现交给实现接口的类 (6)面向对象的六条基本原则包括： 开闭原则，里式代换原则，单一职责，依赖倒转、迪米特法则（接口隔离）。 (7)什么是设计模式？ 设计模式是从许多优秀的软件系统中总结出的成功的可复用的设计方案。是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性 (8)什么是框架？框架与模式的区别有哪些？ 框架是针对某个领域，提供用于开发应用系统的类的集合。 区别：层次不同、范围不同、相互关系 安徽师范大学 2015-2016 学年 第一学期 数学计算机科学学院软件工程专业2013级《软件设计与体系结构》课程期中考试试卷 （180分钟 闭卷） 注意：请保持字迹工整 一、单选题（10小题，每小题2分，共20分） 1、下面哪种开发方法是非传统方法（ ） A 、功能分解法 B 、结构化方法 C 、面向对象方法 D 、信息建模方法 2、下面那一项不属于用况图中的参与者（ ） A 、人员 B 、内部系统 C 、外部系统 D 、设备 3、对象间的is-a 关系可以用以下哪一个来表示( ) A 、组合 B 、聚合 C 、关联 D 、继承 4、只与你的直接朋友通信描述的哪一个设计原则( ) A 、单一职责原则 B 、开闭原则 C 、接口隔离原则 D 、迪米特法则 5、一个软件实体应该对扩展开放，对修改关闭。这描述的是哪个原则（ ） A 、单一职责原则 B 、开闭原则 C 、依赖倒置原则 D 、里氏代换原则 6、常用的基本设计模式可分为（ ） A 、创建型、结构型和行为型 B 、对象型、结构型和行为型 C 、过程型、结构型和行为型 D 、抽象型、接口型和实现型 7、对于类图，下列叙述正确的是（ ） A 、创建类图是为了对系统的动态结构进行建模 B 、在系统分析和实施阶段可以创建和使用类图 C 、每个类图都应该具有泛化关系 D 、以上说法都不对 8、类与类之间存在相互关系，下面哪一种关系与其他三种不同( ) A 、双向关联 B 、聚合关系 C 、组合关系 D 、依赖关系 9、Open-Close 原则的含义是一个软件实体（ ） A 、应当对扩展开放，对修改关闭. B 、应当对修改开放，对扩展关闭 C 、应当对继承开放，对修改关闭 D 、应当对继承关闭，对修改开放 10、当需要对系统功能以及与系统进行交互的外部事物进行建模时，我们一般采用（ ） A 、用况图 B 、类图 C 、活动图 D 、顺序图 二、简答题（4小题，每小题5分，共50分） 1、OOA 中问题域和系统责任的含义分别是什么意思？ 2、OOD 模型中总共包含几个部分，分别是哪几个部分，哪个部分是核心部分？ 福建农林大学计算机与信息学院 实验报告 课程名称：软件设计与体系结构 姓名：陈宇翔 系：软件工程系 专业：软件工程 年级：2007 学号：070481024 指导教师：王李进 职称：讲师 2009年12月16日 实验项目列表 福建农林大学计算机与信息学院实验报告 学院：计算机与信息学院专业：软件工程系年级：2007 姓名：陈宇翔 学号：070481024 课程名称：软件设计与体系结构实验时间：2009-10-28 实验室田实验室312、313计算机号024 指导教师签字：成绩： 实验1：ACME软件体系结构描述语言应用 一、实验目的 1）掌握软件体系结构描述的概念 2）掌握应用ACMESTUDIO工具描述软件体系结构的基本操作 二、实验学时 2学时。 三、实验方法 由老师提供软件体系结构图形样板供学生参考，学生在样板的指导下修改图形，在老师的指导下进行软件体系结构描述。 四、实验环境 计算机及ACMESTUDIO。 五、实验内容 利用ACME语言定义软件体系结构风格，修改ACME代码，并进行风格测试。 六、实验操作步骤 一、导入Zip文档 建立的一个Acme Project，并且命名为AcmeLab2。如下图： 接着导入ZIP文档，导入完ZIP文档后显示的如下图： 二、修改风格 在AcmeLab2项目中,打开families下的TieredFam.acme.如下图： 修改组件外观 1. 在组件类型中，双击DataNodeT; 在其右边的编辑器中，将产生预览；选择Modify 按钮，将打开外观编辑器对话框。 2. 首先改变图形：找到Basic shape section，在Stock image dropdown menu中选 择Repository类型. 3. 在Color/Line Properties section修改填充颜色为深蓝色。 4. 在颜色对话框中选择深蓝色，并单击 [OK]. 5. 修改图形的边框颜色为绿色 7. 单击Label tab，在Font Settings section, 设置字体颜色为白色,单击[OK] 产生的图形如下图： 设计模式实验二 实验报告书 专业班级软件0703 学号3901070324 姓名吉亚云 指导老师伟 时间2010年4月24日 中南大学软件学院 实验二设计模式上机实验二 一、实验目的 使用PowerDesigner和任意一种面向对象编程语言实现几种常用的设计模式，加深对这些模式的理解，包括装饰模式、外观模式、代理模式、职责链模式、命令模式、迭代器模式、观察者模式、状态模式、策略模式和模板方法模式。 二、实验内容 使用PowerDesigner和任意一种面向对象编程语言实现装饰模式、外观模式、代理模式、职责链模式、命令模式、迭代器模式、观察者模式、状态模式、策略模式和模板方法模式，包括根据实例绘制相应的模式结构图、编写模式实现代码，运行并测试模式实例代码。 三、实验要求 1. 正确无误绘制装饰模式、外观模式、代理模式、职责链模式、命令模式、迭代器模式、观察者模式、状态模式、策略模式和模板方法模式的模式结构图； 2. 使用任意一种面向对象编程语言实现装饰模式、外观模式、代理模式、职责链模式、命令模式、迭代器模式、观察者模式、状态模式、策略模式和模板方法模式，代码运行正确无误。 四、实验步骤 1. 使用PowerDesigner绘制装饰模式结构图并用面向对象编程语言实现该模式； 2. 使用PowerDesigner绘制外观模式结构图并用面向对象编程语言实现该模式； 3. 使用PowerDesigner绘制代理模式结构图并用面向对象编程语言实现该模式； 4. 使用PowerDesigner绘制职责链模式结构图并用面向对象编程语言实现该模式； 5. 使用PowerDesigner绘制命令模式结构图并用面向对象编程语言实现该模式； 6. 使用PowerDesigner绘制迭代器模式结构图并用面向对象编程语言实现该模式； 7. 使用PowerDesigner绘制观察者模式结构图并用面向对象编程语言实现该模式； 8. 使用PowerDesigner绘制状态模式结构图并用面向对象编程语言实现该模式； 9. 使用PowerDesigner绘制策略模式结构图并用面向对象编程语言实现该模式； 10. 使用PowerDesigner绘制模板方法模式结构图并用面向对象编程语言实现该模式。 五、实验报告要求 1. 提供装饰模式结构图及实现代码； 2. 提供外观模式结构图及实现代码； 3. 提供代理模式结构图及实现代码； 4. 提供职责链模式结构图及实现代码； 1.各种性能指标及如何到达各种性能指标的方法 （1）防止变异模式：是如何设计对象，子系统和系统，使这些元素内部的变化或不稳定性不会对其他元素产生不良影响。 解决方案：识别预测的变化或不稳定之处，分配职责用以创建稳定借口。 （2）依赖反转原理：把你的类从局的现实中隔离开，使他们依赖于抽象类或接口。它促进了代码面向接口而不是实现，这通过保证对实现的低耦合来增加系统的灵活性。 2.常用的中间件有那几种类型 （1）常见的对象请求代理架构 （2）面向消息的中间件 （3）J2EE （4）消息代理 （5）业务过程代理 3.有那些常见架构风格 （1）管道和过滤器架构风格 （2）面向对象风格 （3）隐式调用风格 （4）客户-服务器风格 （5）分层风格 （6）仓库风格 （7）解释程序风格 （8）过程控制风格 4.架构师需要的核心技能是什么 （1）涉众之间的交流 （2）技术知识 （3）软件工程学 （4）风险管理 5.什么是软件架构 软件架构是一系列相关的抽象模式，用于指导大型软件系统各个方面的设计。软件架构是一个系统的草图。软件架构描述的对象是直接构成系统的抽象组件。各个组件之间的连接则明确和相对细致的描述组件之间的通讯。在实现阶段，这些抽象组件被细化为实际的组件，比如具体某个类或者对象。在面向对象领域中，组件之间的连接通常用接口（计算机科学）实现。 6.什么是架构风格 一组原则。你可以把它看成是一组为系统家族提供抽象框架的粗粒度模式。 7.什么是架构视图 一个架构视图是对于从某一视角或某一点上看到的系统所做的简化描述，描述中涵盖了系统的某一特定方面，从而省略了此方面无关的实体。 8.各种架构风格的组件和连接器是什么 1.管道和过滤器架构风格： 适用于需要定义一系列的执行规则数据的独立运算，组件在输入时读数据流，在输出时产生数据流 组件：称为过滤器，应用于对局部的输入流的转换，经常增长的计算，因此，在输入结束前输出就开始了 连接器：称为管道，给流提供管道，把一个过滤器的输出传输到另一个输入。 2.面向对象风格： 适用于主要问题识别和保护信息的相关主体 数据代理和他们相关的操作封装在一个抽象数据类型里面 组件：对象 连接器：功能和过程调用 3.客户-服务器风格： 适用于涉及到分布式的数据和跨越一系列的组件的处理 组件：服务器、客户端 连接器：网络 4.分层风格： 适用于设计到分布式的能够分层的组织的类的服务，每层给它的上一层提供服务，同时作为下一层的客户端。只有仔细的从内层选择选择过程，才能用于他们接近的外层。 组件：典型的过程的集合 南京信息工程大学实验（实习）报告 实验（实习）名称对象设计实验日期得分指导教师王海彬 系计算机与软件学院专业软件工程年级13班次2姓名张慧聪学号20131344055 一、实验目的 1.refinement class diagram, design the methods and attributes of that 2.clear the relationship between classes 3.know the way of painting class diagram 二、实验内容 The description of each class in entity class: A. visitors The class name: visitors Attribute: visitors ID Operation: browse the web, register information B. user The class name: user Attribute: user name, user password, user permission Operation: add user, delete user, change user, privilege allocation C. job hunter The class name: job hunter Operation: change password, update personal data, check the mailbox, download resume form work, deliver resume, search recruitment information D. recruiter The class name: recruiter Operation: check the enterprise mailbox, publish recruitment information, update enterprise information, reply to applicant, browse the resume, change password E. administrator The class name: administrator Operation: management news, management password, management of job seekers, management recruiters F. personal information The class name: personal information Attribute: name, age, gender, personal mailbox, address, educational background, job requirements G. resume The class name: resume Attribute: resume number，resume type，job application，date of submission Operation: resume input, resume submission, resume inquiry, resume printing H. enterprise data The class name: enterprise data Attribute: enterprise name, enterprise contact information, enterprise establishment information, enterprise development scale, enterprise mailbox, enterprise intention, enterprise employee information I. recruitment information 1.1 实验一结构化需求分析 一．实验类型 图书馆管理系统 假定校图书馆需要你设计一个图书馆管理系统，要求包括以下功能： ●图书管理员可以管理馆藏图书，包括每本图书的藏书编号、书名、编著者、 ISBN号、出版社、出版时间、入馆时间、馆藏数量（如果馆藏数量为1,则标明为孤本图书）、在馆数量、学科类别等（或其它你认为有用的信息）； ●管理员可以查询、统计所有图书、每一类图书或每一本书的借阅记录； ●图书管理员可以管理所有读者的信息，包括读者类型（学生、教师、社会人 士）、姓名、图书证编号、办证时间、证件状态（正常、挂失、冻结）等信息； ●图书管理员可以查询和统计所有读者、每一类读者或每一个读者的借阅记录； ●读者可以通过本系统查询馆藏图书； ●读者可以通过本系统借阅读书。但对于孤本图书或在馆数量为1的图书则不 准外借； ●管理员可以对超期未归还图书的读者发送电子邮件进行提醒，对于超期一年 不归还图书的读者冻结其图书证； ●读者可以通地本系统归还图书。如果图书超期，则自动计算罚款金额。二．实验目的 1．掌握数据流的分析技术 2．掌握软件需求分析的过程和方法。 3．熟悉项目开发计划和需求规格说明书的制定方法。 三．实验内容和要求 1．用结构化数据流分析技术进行软件系统需求分析，得出系统的数据流图和数据字典。 2．正确运用图表工具进行表示。 3．按规范正确编写软件文档。 四．实验步骤 1．理解所承担项目的业务流程和业务内容。 本软件项目是面向中小型学校、单位机构对于图书管理的基于服务的一款便捷式软件。能满足一系列常用图书管理的功能模块，提供简介、准确的操作性，可以很大程度减少人为因素带来的数据错误，统计错误，系统逻辑错误。并且规模小，很容易进行推广。 ●本项目的参与对象有图书管理员及读者。 ●对于读者，能通过该软件浏览馆藏的所有图书。读者在图书馆找到自己喜欢 的书后，能自行通过该软件操作完成借阅操作。若读者是第一次借书，必须通过图书管理员进行添加读者记录，登记读者信息。读者在登陆后方能完成借阅操作，对于孤本图书（即图书馆中馆藏只有一本的图书）则拒绝进行借阅操作。在规定期限内，读者可以通过该软件完成还书操作，对于超期的图书，应将扣除一定罚款金额，对于超期一年不归还图书的读者冻结其图书证。 并且读者能修改个人信息。 ●对于图书管理员，能管理自己和比自己低一级管理权限的管理员。一级管理 员能完成维护管理员的基本信息和二级管理员的一切操作。二级管理员则能维护自己的信息和添加读者、添加图书的功能。管理员可以对超期未归还图书的读者发送电子邮件进行提醒，对于超期一年不归还图书的读者冻结其图书证； 2．按照系统的功能及性能要求，系统的作业范围等，确定软件系统的开发环境（操作系统、开发工具、程序设计语言等）。 根据软件编程经验，本系统将采用面向对象的设计方法，使用Eclipse开发工具，java窗体应用程序，操作系统使用Win8。 3．绘制数据流图、功能分析图等。南京邮电大学软件设计实验报告
软件设计过程实验报告
软件设计与体系结构
仲恺软件设计模式实验指导书
软件项目管理课程设计实验报告精
【精品实验报告】软件体系结构设计模式实验报告
软件设计与体系结构复习整理题目及答案
《软件课程设计》实验报告
设计模式实验报告
软件设计实验报告
软件设计与体系结构期末复习整理解读
软件设计与体系结构期中考试试卷
软件设计与体系结构实验报告
设计模式上机实验二实验报告
软件设计与体系结构题目与答案
软件设计实验一
软件工程实验报告
- 软件设计与体系结构期末考试学年模拟试卷
- 《软件设计与体系结构》教学大纲
- 软件设计与体系结构-齐治昌
- 软件设计与体系结构
- 软件设计模式与体系结构
- 软件设计与体系结构复习整理题目与答案
- 软件设计与体系结构考试重点
- 软件设计模式与软件体系结构实验报告
- 2015-2016学年一学期软件设计与体系结构期中考试试卷
- 软件设计与体系结构考试重点
- 软件设计与体系结构作业_汇总
- 软件设计与体系结构1
- 软件设计与体系结构实验报告
- 软件设计与体系结构课后练习部分答案
- 软件设计与体系结构练习题
- 2013武汉理工软件设计与体系结构复习(仅供参考)
- 软件设计与体系结构题目与答案
- 软件设计与体系结构论文
- 软件体系结构设计与常用体系结构模型ppt
- 软件设计与体系结构