第一阶段面向过程程序设计
1.编程序用迭代法求a的立方根,求立方根的迭代公式为::Xi+1=（2*Xi）/3+a/(3*Xi*Xi)
假定X的初值为a,迭代到|Xi+1-Xi|<10的-5次方为止. 显示a=3,27的值,并通过调用
pow(a,1.0/3)函数加以验证.。
2. 编程序，从键盘输入正整数n，求出n与其反序数之和并输出。例如，输入2038，输出应为2038+8302=10340。
3编程序，使用如下所谓的简单变量“数据平移”方法来求出Fibonacci数列的第n项（的具体项值）并显示在屏幕上（正整数n通过键盘输入）：说明变量old1=1，old2=1，newItem；
新的Fibonacci项newItem总是“距它最近”的前两项（old1与old2）的累加和。而后通过“old1=old2; old2=newItem;”进行所谓的“数据平移”。接着计算另一个新的Fibonacci 项newItem，依次循环，直到求出数列的第n项时为止。
Fibonacci数列的计算公式如下：
fib（1）= 1；
fib（2）= 1；
fib（n）= fib（n-1）+ fib（n-2）；//对大于等于3的任意n。
拓展编程（选做），设计递归函数double fib(int n)；用于求出Fibonacci数列的第n项（的具体项值）并返回，而后编制主函数对它进行调用。
4.编程序，输入正整数m，它代表一个人民币钱数（元数）。求取这样一个方案，使用最
少张数的人民币纸币，凑成上述的钱数m，并输出求取结果。
注意，现在共有7种元以上面值的人民币纸币，分别为：100，50，20，10，5，2，1。
5.编程序，使用户任意输入一个年份以及该年的1月1日是星期几，而后任意指定某一
天（再输入该年的任意一个月份日期），由程序计算出这一天是星期几。注意，2月份闰年为29天，非闰年为28天；可被4整除而不可被100整除的年份、或者可被400整除的年份均为闰年。
思考：利用元年元月元日（即1年1月1日）是星期一的已知事实，可对程序进行改造，让用户仅输入一个表示日期的年月日，则程序就应计算出那一天是星期几。
拓展编程序（选做），设计星座的计算。
6.编写程序求解骑士巡游问题：在n行n列的棋盘上（如n=5），假设一位骑士（按象棋中
“马走日”的行走法）从初始坐标位置(x1，y1)出发，要遍访（巡游）棋盘中的每一个位置一次。请编一个程序，为骑士求解巡游“路线图”（或告诉骑士，从某位置出发时，无法遍访整个棋盘—问题无解）。
当n=5时，意味着要在5行5列的棋盘的25个“点”处，按骑士行走规则，依次将1至25这25个“棋子”（数码）分别摆放到棋盘上（摆满25个位置则成功，否则失败问题无解）。
例如，当n=5且初始坐标位置定为(1，1) —即最左上角的那个点时，如下是一种巡游“路线图”。程序执行后的输出结果为：
(x1,y1)? => (1=>5, 1=>5) : 1 1
1 6 15 10 21
14 9 20 5 16
19 2 7 22 11
8 13 24 17 4
25 18 3 12 23
提示：
（1）“棋盘”可用二维数组B表示。
（2）编制一个具有如下原型的递归函数solve，用于完成任务：从(i,j)点出发，做第k 至第n*n（即n的平方）次的移动—将k直到n的平方这些数码按规则分别摆放到棋盘即数组B中，若成功则通过引用参数ok返回true，否则返回false。
void solve(int i, int j, int k, bool& ok)；
（3）编制主函数，让用户输入作为巡游起点的初始坐标位置(x1,y1)，在该处摆放“棋子”（数码）1，而后进行调用“solve(x1, y1, 2, ok);”来完成所求任务。
欲处理的初始问题为：从某点(x1,y1)出发，按所给行走规则，作24次移动，遍访棋盘中没被访问过的各点（或发现无路可走）。
可分解化简为如下两个子问题（正是形成递归函数的基础）：
①由点(x1,y1)出发，按所给行走规则作1次移动到达(g,h)（或发现无路可走）；
②从(g,h)点出发，按所给行走规则，作23次移动，遍访棋盘中没被访问过的各点（或发现无路可走）。
solve函数具体实现时，若由(i,j)点出发已“无路可走”，则将引用参数ok置为false而递归出口；否则，先“迈一步”到达(g,h)点，而后再进行递归调用：solve(g, h, k+1, ok)；以实现从新点(g,h)出发，将k+1直到25这些“棋子”（数码）分别摆放到棋盘上，若成功则通过引用参数ok返回true（否则返回false）。
点评：
（1）也可编制第二种解法的主函数：将棋盘上的n平方个点依次作为巡游起点的初始坐标位置(x1,y1)，判断从每一位置出发是否有解或无解（输出“OK!”或“NO!”，但并不输出“路线图”）。
（2）若更改程序中的n值（如改为4或6等），便可求解其他阶数的巡游“路线图”。
（3）可改用非递归方法设计并编写solve函数，那样的话，通常要增加一个记录摆放“棋子”信息的数组，可记录下是沿着什么方向到达了当前的什么位置（在那儿摆放了“棋子”）等，而且对上述数组可按照栈（stack）的方式来使用（栈总是采用FILO即所谓的先进后出使用方式），以便在“无路可走”的情况下，回退（回溯）到上一个位置，接着按照另外的方向去寻找其他的“行走”方法。
7.将输入的罗马数据化为10进制数。假设罗马数据中只使用如下7个“基值”字母：M、
D、C、L、X、V、I，分别用来表示1000、500、100、50、10、5、1。如，罗马数据
LXXXVII表示10进制的87。
将输入的10进制正整数转换为罗马数据。假设罗马数据中只使用“基值”字母：M、D、C、L、X、V、I，分别用来表示1000、500、100、50、10、5、1。
8.编程序，循环进行如下的处理过程：由计算机生成简单的四则运算题；用户给出答案；
计算机判断对错。直到用户回答说不再继续做了时结束程序。
提示：可让用户选择指定出加、减、乘、除哪一种运算题，以及出一位数还是两位数的运算题；而后通过使用“rand()%10”或“rand()%100”来获得一个0到9的一位整数随机值或得到0到99的两位整数随机值来为用户出题。还可进一步对用户所做算术题的对错次数进行
记录，结束程序时给出一个某种形式的成绩。
9.编程序，按如下要求来求解任意阶数满秩矩阵的逆矩阵。
（1）矩阵行数（阶数）n之值由用户通过键盘输入；
（2）将欲求逆的“原始矩阵”另加一个“单位矩阵”存放在于数组A之中，而n行2n列的A存储空间通过new来动态分配，且“原始矩阵”的各元素值也由用户通过键盘输入；（3）利用行初等变换设法将A左半的“原始矩阵”化为“单位矩阵”，此时，右半的原“单位矩阵”则变成了欲求的结果逆矩阵。
提示：将整个求解任务（总任务）进行“分解”，设计出多个各负其责的自定义函数以完成各子任务。
求取逆矩阵的主要工作是：利用行初等变换（如将某一行的各数据乘以适当的倍数加到另一行的对应各元素上去），设法将A左半的“原始矩阵”化为“单位矩阵”（首先将“左半”消为“上三角”；又将“左半”主对角线消为1；最后将“左半”消为单位矩阵），此时，右半的原“单位矩阵”则变成了欲求的逆矩阵。
10.编写程序对八皇后问题进行求解：在8行8列的棋盘上放置8个皇后，使任一个皇后都
不能吃掉其他的7个皇后（注：皇后可吃掉与她处于同行或同列或同一对角线上的其他棋子），并将结果以某种方式显示出来。
例如，当求出下述的一个解时，可输出如下信息来表示该解（输出了表示摆放皇后的坐标位置以及“棋盘状态”—棋盘中有皇后的位置放一个“Q”字符，其他位置为“+”字符）。(1,1) (5,2) (8,3) (6,4) (3,5) (7,6) (2,7) (4,8)
Q + + + + + + +
+ + + + + + Q +
+ + + + Q + + +
+ + + + + + + Q
+ Q + + + + + +
+ + + Q + + + +
+ + + + + Q + +
+ + Q + + + + +
提示:
（1）通过“int LineNum[9]; bool a[9], b[15], c[15];”说明具有全局作用域的4个数组。其中的：
LineNum[i]表示第i列的皇后要放的行位置（只用其中的列号1到8）；
a[i]为true（i =1，2，…，8）表示第i行上尚未放皇后；
b[i]为true（i =0，1，2，…，14）表示第i条斜对角线上尚未放皇后（斜对角线指的是“/”状对角线，该对角线上各点的行列号之和i+j为一个常数）；
c[i]为true（i=0，1，2，…，14）表示第i条反斜对角线上尚未放皇后（反斜对角线指的是“\”状对角线，该对角线上各点的行列号之差i-j为一个常数）。
从而当使用语句“if ( a[j] && b[i+j-2] && c[i-j+7] ) LineNum[i]=j;”时，可用于判断并实现：如果在第j行的第i列上放置皇后安全的话，则将一枚皇后放置到那儿。
（2）编制一个具有如下原型的递归函数solve，它负责往第i列开始的连续8-i+1列上均放上皇后，若成功则通过引用参数ok返回true（否则返回false）。
void solve(int i, bool& ok);
摆放皇后之后，若i=8即已放满时则递归出口；否则通过solve(i+1,ok);进行递归调用。
（3）编制主函数，首先初始化一个“空棋盘”，即将a、b、c数组的各元素均置为true （表示当前棋盘的8个行、15条斜对角线以及15条反斜对角线上都尚未摆放皇后）。而后
执行调用语句“solve(1, ok);”，它负责往第1列开始的连续8列上均放上皇后，若成功则通过引用参数ok返回true（否则返回false）。
点评：
（1）可改用非递归方法设计并编写solve函数，那样的话，通常要设置数组来记录皇后的摆放位置信息，还要记录这些皇后所产生的“影响面”（所建立的“势力范围”）—使得哪些行列位置不可再摆放皇后。当在新的行列位置摆放了皇后、但此时又无法进一步摆放其他的皇后时，要回退（回溯）到上一个位置接着去考虑另外的“行走”方法（若还有的话）等等。但注意，“回退”一步后，要同时“撤销”由于该步的回退而关联的那些“影响面”（释放“势力范围”）。
（2）本程序只是找到了某一种“摆放方案”而终止，还可进一步考虑寻找其他各种不同的“摆放方案”（实际上共有92种）。
（3）也可用同样的方法去处理其他“阶数”的皇后问题，如求解四皇后问题等。
第4题：
#include
using namespace std;
int a[8]={0,100,50,20,10,5,2,1}
int main()
{
int n,i,s=0;
cin>>n;
for (i=1;i<=7;i++)
{
s+=n/a[i];
n%=a[i];
}
cout< return 0; } 第5题： #include using namespace std; int a[13]={0,31,28,31,30,31,30,31,31,30,31,30,31}; int main() { int i,s=0,year,month,day; puts("请输入1月1日是星期几"); cin>>n; puts("请输入要查找的日期"); cin>>year>>month>>day; if ((year%4==0&&year&100!=0)||year%400==0) a[2]=29; for (i=1;i s%=7; s+=n; s%=7; printf("星期"); switch(s) { case 1: puts("一"); break; case 2: puts("二"); break; case 3: puts("三"); break; case 4: puts("四"); break; case 5: puts("五"); break; case 6: puts("六"); break; case 7: puts("七"); break; } return 0; } 第2题 #include #include #include using namespace std; int main() { string num; cout<<"请输入一个数:"; cin>>num; int i=num.size(); int result=0; int j; for(j=i-1;j>=0;j--) { result+=(num[j]+num[i-1-j]-2*'0')*pow(10,j); } cout< return 0; } 第6题 #include #include int map[9][9];//用来标记的二维数组 int n=5;//实际计算时的棋盘大小，超过5时运算时间过长，小于5时无解class Knight{ private: int dirx[8];//八个方向可以走，用两个数组分别记录每个方向上x,y的坐标位移int diry[8]; public: Knight(){ dirx[0]=1;diry[0]=2; dirx[1]=2;diry[1]=1; dirx[2]=1;diry[2]=-2; dirx[3]=2;diry[3]=-1; dirx[4]=-1;diry[4]=2; dirx[5]=-2;diry[5]=1; dirx[6]=-1;diry[6]=-2; dirx[7]=-2;diry[7]=-1; } private: bool judge(int y,int x){ if(x>0 && x<=n && y>0 && y<=n && map[y][x]==0) return true; else return false; } public: void set(int y,int x,int t){ if(t==n*n){ map[y][x]=t; cout<<"one possible answer:"< for(int i=1;i<=n;i++){ for(int j=1;j<=n;j++){ if(map[i][j]<10) cout<<" "; cout<<" "< } cout< } map[y][x]=0; return; } else{ if(map[y][x]==0){ map[y][x]=t; int nextt=t+1; for(int i=0;i<8;i++){ if(judge(y+diry[i],x+dirx[i])) set(y+diry[i],x+dirx[i],nextt); } map[y][x]=0; } } } }; void main(){ Knight *horse=new Knight();//骑士也要走马步for(int i=1;i<=8;i++) for(int j=1;j<=8;j++) map[i][j]=0; for(i=1;i<=n;i++) for(int j=1;j<=n;j++) horse->set(i,j,1); delete horse; } 面向过程程序设计和面向对象程序设计的区别 面向过程程序设计我个人的理解简单来说，他考虑问题的方式是面向流程的，一个程序的设计思路就是解决一个问题的流程。就好比游戏先登入界面，再输入密码，然后选择角色，在然后进入游戏玩耍，结束... .... 这把这些步样就是面向过程。面向过程就是分析出解决问题所需要的步骤，然后用函数骤一步调用就可以了一步实现，使用的时候一个一个依次。可以看出面向过程化程序设计是先确定算法，再确定数据结构。而面向对象程序设计是面向问题中的各种独立个体的，程序的析设分计过程就是将程序分解成不同对象（不同概念体）之间的交互的过程。这就好比在针对某个工程或游戏设计程序时先不考虑，游戏是怎么玩的，工作是怎么做的，而先会去找，游戏或工程中有哪些人或事物参与（一般选择：用户，玩家，角色等等），然后再看他们都有什么用，都干了些什么，针对这个区设计方法。最后在通过这些千丝万缕的联系把他们分门别类的，组装在一起。可以看出面向过程化程序设计是先确定数据结构再确定算法。 从上面很容易看出，面向过程的程序上一步和下一步环环相扣，他只考虑实现客户的需求不考虑以后扩展，如果以后客户的需求有变化那代码量要改变非常大耗费的时间也相当多。从本质上说，面向过程基本上是一种状态机，不利于修改，当新状态出现的时候，甚至可能需要重设每一个状态解决实现。所以说面向过 程是一种直接的编程方法，它是按照编程语言的思路考虑问题。尤其是想C语言这种过程式语言，它就是通过顺序执行一组语句来实现一个功能，这些语句的执行过程就是整个程序。不同的语言解决同一个问题的过程是不一样的。 而面向对象的程序设计很多东西都是独立的，每个对象都可以重复使用。而面向对象程序设计强调“封装”，“继承“和“多态”。数据和与数据相关的操作被包装成对象（严格的说是“类”），每一种对象是相对完整和独立的。对象可以有派生的类型，派生的类型可以覆盖（或重载）原本已有的操作。所有的这些，是为了达成更好的内聚性，即一种对象做好一件（或者一类相关的）事情，对象内部的细节外面世界不关心也看不到；以及降低耦合性，即不同种类的对象之间相互的依赖尽可能降低。而所有的这些，都有助于达成一个崇高的目标，就是可复用性。 下面举个例子来说明面向过程的程序和面向对象的程序设计的区别： 用面向过程的思想去考虑它应该是这样的：如何启动汽车、如何起步、加速、刹车、熄火等一个个操作。面向过程是把所有的功能全部在一个大的类里定义出来，当系统庞大时，功能多了，各种操作之间的调用关系也很复杂，当需要修改一个功能时就可能引发一连串的改动，使修改和维护成本增加，而不利于修改。 而面向对象则以汽车为对象，一切由汽车开始，以上的可用操 面向对象与面向过程程序设计方法的比较摘要：区别于一般讲述面向对象技术的文章，本文系统地比较了面向对象技术和面向过 程技术的异同，并着重介绍面向对象技术以及它的封装、继承和多态三个特点，让读者对面向对象有一个形象的理解。然后通过比较和举例，文章分析了OO技术在软件工程中的三大优势。 Abstract：Being different from general articles about object-oriented technology , this paper systematically compared the object-oriented technology and the process-oriented technology, and mainly introduces the object-oriented technology and its three characteristics :packaging, inheritance and polymorphism, to make the reader have an image of understanding of object-oriented. Then through the comparison and some examples, this paper analyzes the OO based software engineering in three points. 关键字：面向对象面向过程软件工程 Key words：Object-Oriented Process-Oriented Software-Engineering 一引言 20世纪60年代中期开始爆发的软件危机，使人们认识到大中型软件系统与小型软件系统的本质区别，软件工程以及面向对象编程（Object-Oriented Programming）技术得以应运而生。从最初的SIMULA到如今的C++、JAVA和C#，面向对象程序设计语言已发展为当前最流行的程序设计语言。 谈到面向对象，一个不能回避的问题是面向过程的程序设计思想。作为一种常用的面向对象语言，C++自C语言发展而来，是一种混合型面向对象的程序设计语言，它既支持面向对象又支持面向过程。面向对象与面向过程虽然在设计理念上截然相反，前者是自底向上而后者是自顶向下的，但它俩仍有众多的相似之处。只有建立在深入理解二者的关系的基础上，我们才算是真正驾驭了面向对象与面向过程技术，以便在未来将它们熟练地运用于学习和生活中。 二面向过程的程序设计方法 著名的计算机科学家Nikiklaus Wirth提出了一个公式：程序=算法+数据结构。这个公式很好地诠释了面向过程程序设计方法的核心思想——算法和数据。 更加具体地说，面向过程的程序设计方法称为功能分解，即自顶向下。以两个人下五子棋为例，面向过程的设计方法是先决定二人中谁先手，然后是先手者下一子，判断游戏是否结实，后手者下一子，判断游戏是否结束……可以看到无论是猜先、落子还是最后的判胜负，它们都是一场五子棋游戏中不能再分割的逻 举例说明面向对象和面向过程的区别 两种方法都是编程中的比较常用的方法，从理论上来说，都能达到用计算机程序来解决实际问题的目的，只不过是其中所体现出来的思想不一样而已。 面向过程：面向过程的思想是把一个项目、一件事情按照一定的顺序，从头到尾一步一步地做下去，先做什么，后做什么，一直到结束。这种思想比较好理解，其实这也是一个人做事的方法。 面向对象：面向对象的思想是把一个项目、一件事情分成更小的项目，或者说分成一个个更小的部分，每一部分负责什么方面的功能，最后再由这些部分组合而成为一个整体。这种思想比较适合多人的分工合作，就像一个大的机关，分成各个部门，每个部门分别负责某样职能，各个部门可以充分发挥自己的特色，只要符合一定前提就行了。 举例说明1：比如刚才说的一个大的机关，要做某一个项目，从面向过程的思想来说，应该是这样分析的，先怎么样，再怎么样，最后怎么样。第一样应该如何完成，第二样应该如何完成等等。等到每一步骤都完成，项目也就完成了。而面向对象的思想则应该是这样想的，这个项目是由几个部分组成的，我们就做好分工，成立一个部门来做一个部分的功能，另一个部门来做另一个部分。各个部门可以不用理解其他部门的事，只要完成自己那一部分的事情就OK了。 举例说明2：又比如我们有一台演出，为简单起见，假设有如下流程：主持人开场——演员一表演——演员二表演——主持人总结。用面向过程的思想来分析，就是先完成主持人开场，再完成演员一的表演，再完成演员二的表演，最后完成主持人的总结。而如果用面向对象的思想来分析，就应该是这样的。这个演出由两大部分组成：主持人、演员。与主持人相关的：开场、总结。与演员相关的：演员编号、所演的节目。然后这台演出就可以这样策划：需要一个主持人a，需 怎么理解面向对象和面向过程到底的本质区别？ 2007-01-25 02:05:51| 分类：默认分类| 标签：|举报|字号大中小订阅 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。 ----------------------------------------------- 面向过程的思维方式是分析综合。面向对象的思维方式是构造。 就是对C语言过程式解决问题时。一般是将现有的数据结构先定义出来。然后想办法构造出算法了。 而用C++这样的面向对象求解时，先是将对象抽出来。构造成一个仿真的环境，然后在这个环境里，把与最终要解决的问题间建立一个方法。 所以面向过程的程序设计有挑战性，技巧性强。 而面向对象主要在于对象抽象有技术性，抽象完了后，任何人都可以做后面的工作了。 ------------------------------------------------- 面向对象和面向过程的主要区别就是数据是单独存储还是与操作存储在一起。对面向过程而言，数据是独立的。而在面向对象中，对象本身就提供了存储数据的空间（类的数据成员），这样就是函数的参数传递简单多了，而且提供了数据封装后，数据的访问也变可靠了。 ------------------------------------------ 面向过程就是将编程当成是做一件事，要按步骤完成，每一步就是一个过程。比如作菜，先放油，接着是放菜进去炒，然后放水，最后菜就做好了。 这里面放油，炒，放水就是三个步骤。 面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不用去管他内部的情况。而编程就是设置事物能够做什么事。其实有点像是将面向过程给放到事物内部了。仍然举作菜为例，其实面向过程就好像你是个厨师，要自己炒菜，所以要讲究步骤，而面向对象就好像你是个食客，你只要通知厨师作 Q：面对对象和面向过程的优缺点，结合实例进行阐述 A： 一、个人理解，面向对象相对于面向过程较显著的优势莫过于可扩展性、可维护性。众所周知在软件开发过程中，开发人员与客户需要不断的沟通，而客户的需求也往往在不断的变化，软件的功能也不是一成不变的。如果采用面向过程的方法来进行软件开发，当用户需求发生变化时，比如要求修改现有软件功能的实现方式或者要求追加新的功能时，就需要自顶向下地修改模块的结构，有时候甚至整个软件系统的设计被完全推翻。 相比之下，面向对象所提供的可扩展性保证了当软件必须增加新的功能时，能够在现有系统结构的基础上，方便的创建新的子系统，而不需要改变软件系统现有的结构，也不会影响已经存在的子系统。可维护性则保证了当用户需求发生变化时，只需要修改局部的子系统的少量程序代码，而不会牵一发动全身。 举一个例子，暴雪公司开发的魔兽争霸游戏，这个游戏里面有很多人物角色，例如我们要编程实现美杜莎这个角色的技能攻击动作。如果使用面向过程的方法来实现。本例使用C++，Visual C++ 6.0环境下调试。 #include 1.1面向过程的软件系统开发方法 1.1.1面向过程开发方法中的系统分析 1、面向过程的系统分析 （1）基本的思路是把系统看成一个过程的集合体 结构化方法也称为面向过程方法——倡导把一个“复杂问题”的求解过程分阶段进行，每个阶段处理的问题都控制在人们容易理解和处理的范围内——应用“自顶向下”和“逐步细化”。 （2）什么是系统分析 所谓的系统分析是帮助开发人员定义系统需要做什么（功能需求）、系统需要存储和使用那些数据（数据需求），系统需要什么样的输入和输出（IO需求）等，以及如何把这些功能结合在一起来完成特定的任务的过程。 （3）面向过程的系统分析中常常采用的技术手段 使用系统结构图来表达功能间的关系 结构化方法是一种基于功能分解的分析方法，并且自上向下的分解或分层。在结构化方法中首先要定义出需要哪些功能程序，每个程序应该实现哪些功能，然后按照某种方式把程序组织成一张图，该图称为结构图。 结构化分析与设计方法所具有的特点：自顶向下的分析和自底向上的开发实施；强调用户和用户参与的重要性；严格区分工作阶段。 分层框图把系统中的各种功能模块用多层方框按照树形结构组织起来。在结构的顶层，用一个方框代表整个系统结构。下面各层由表示不同功能模块类别的方框组成，它们可以看成是上一层方框的子集。在该图的最低一层，每个框包含单独的功能模块。 使用数据流图表达功能与数据间关系，同时使用ER图表达数据间关系。 它应用诸如实体关系图、数据流图以及状态转换图，这些方法试图通过使用数据为界限来分解系统。设计程序先设计数据，然后通过分析数据关系，最后来实现程序。 1.1.2面向过程开发方法中的系统设计 1、面向过程设计 思维方式决定其解决问题的方式，面向过程设计采用自顶向下的思想指导应用系统的设计，即将系统的目标（也就是整个程序）划分为若干个子目标（也就是函数），子目标再进一步划分下去（也就是子函数），直到目标能被编程实现为止。 2、面向过程设计的主要工具是结构图 这是一种表达程序模块层次的图形模型。 C是面向过程 C++、JAVA是面向对象 面向对象和面向过程的区别 一个博大,一个精深. 总体而言,面向对象简单,面向过程对人员要求素质过高 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。 艾兰.库伯的《软件创新之路》中提到： 面向过程和面向对象的区别并不像人们想象得那么大 面向对象的大部分思想在面向过程中也能体现 但面向过程最大的问题（也许是唯一先天的缺陷）在于随着系统的膨胀，面向过程将无法应付，最终导致系统的崩溃 面向对象的提出正是试图解决这一软件危机 目前看来，似乎有一定成效 但仍任重道远 --------------------------------------------------------------- 做一些对比来说吧： 分析基本构件方法工具 －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－ 面向过程基于算法函数／过程数据流图、伪代码... ... 面向对象基于对象类UML建模... Rose，viso等 --------------------------------------------------------------- 其实我始终认为，不管是面向对象，还是面向过程，都体现了一种软件重用的思想！ 只不过面向过程中重用的是过程和函数，但是面向对象重用的是类，一种将数据和处理数据的过程及函数封装在一起的实体，其实面向对象中的过程和函数和面向过程中的分别不是很大，所以数据流图和伪代码还是有用的。 面向对象一个很大的好处就是数据和方法的封装，由此面向对象的三大特性得到发挥 什么是面向对象面向过程面向事件 2010-06-05 11:26 面向过程是在面向对象出现之前，以及之后，甚至至今都应用于程序开发中的程序设计思想。 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向对象是把构成问题事分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。 如： 一辆汽车 面向对象程序设计与面向过程程序设计的区别 想要知道面向对象程序设计与面向过程程序设计的区别，我们应先了解什么事面向对象程序设计，什么事面向过程程序设计，这样我们才能弄清他们之间的区别，下面我们就什么是面向对象程序设计和什么事面向过程程序设计展开论述。 面向对象的基本概念： (1)对象。 对象是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。 (2)对象的状态和行为。 对象具有状态，一个对象用数据值来描述它的状态。 对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。 对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中 (3)类。 具有相同或相似性质的对象的抽象就是类。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象。 类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。 类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。 (4)类的结构。 在客观世界中有若干类，这些类之间有一定的结构关系。通常有两种主要的结构关系，即一般--具体结构关系，整体--部分结构关系。 ①一般——具体结构称为分类结构，也可以说是“或”关系，或者是“is a”关系。 ②整体——部分结构称为组装结构，它们之间的关系是一种“与”关系，或者是“has a”关系。 (5)消息和方法。 对象之间进行通信的结构叫做消息。在对象的操作中，当一个消息发送给某个对象时，消息包含接收对象去执行某种操作的信息。发送一条消息至少要包括说明接受消息的对象名、发送给该对象的消息名（即对象名、方法名）。一般还要对参数加以说明，参数可以是认识该消息的对象所知道的变量名，或者是所有对象都知道的全局变量名。 (1)对象唯一性。 每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。在对象的整个生命期中，它的标识都不改变，不同的对象不能有相同的标识。 (2)抽象性。 分类性是指将具有一致的数据结构(属性)和行为(操作)的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。 (3)继承性。 如何理解程序设计中的面向过程与面向对象 摘要 程序设计语言的发展是一个不断演化的过程，其根本的推动力就是抽象机制更高的要求，以及对程序设计思想的更好的支持。具体的说，就是把机器能够理解的语言提升到也能够很好的模仿人类思考问题的形式。“面向过程”是一种以事件为中心的编程思想。就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。随着程序规模的不段断扩大，在60年代末期出现了软件危机，在当时的程序设计范型中都无法克服错误随着代码的扩大而级数般的扩大，以至到了无法控制的地步，这个时候就出现了一种新的思考程序设计方式和程序设计范型-----面向对象程序设计，由此也诞生了一批支持此技术的程序设计语言，比如EIFFEL，C++，JAVA，这些语言都以新的观点去看待问题，即问题就是由各种不同属性的对象以及对象之间的消息传递构成。 一、程序设计范型的演化 1过程式程序设计 原始的程序设计范型是： 确定需要哪些过程； 采用能找到的最好的算法。 这里所关注的是处理过程-----执行预期的计算所需要的算法，从程序组织的观点看，函数被用于在许多算法里建立一种次序。算法本身通过函数调用和其他语言功能写出，其典型语言是PASCAL。 2模块程序设计 设计程序的着重点已经从有关过程的设计转移到了对数据的组织，这种转移也反映了程序规模增大的情况。相关的过程与他们所操作的数据组织在一起，通称为一个模块，程序设计范型变成： 确定需要哪些模块；将程序分为一些模块，使数据隐藏于模块之中。 在这样的设计范型中，最重要的概念就是数据隐藏原理。 3基于对象程序设计 允许程序员直接定义类型，这种类型的行为方式与内部类型几乎完全一样，这样的类型常常被称为抽象数据类型，其程序设计范型是： 确定需要哪些类型； 为每个类型提供完整的一组操作。 支持这种范型的典型设计语言就是ADA。 4面向对象程序设计 在基于对象程序设计范型的基础上，加入继承和多态这两个组重要的概念就演变出了现在最流行的程序设计方法---面向对象程序设计，其范型是： 确定需要哪些类； 为每个类提供完整的一组操作； 利用继承去明确地表示共性。 支持此范型的典型语言就是EIFFEL，JAVA，C++等。 二、面向过程 “面向过程”是一种以事件为中心的编程思想。 面向对象的程序设计语言与面向过程的程序设计语言 首先C面向过程的编程，C++和JAVA都是面向对象的编程。 二者用最简单的例子来说 比如说：我吃饭 面向过程：着重在吃的过程，要具体描述吃的没一个步骤，比如夹米饭，张嘴，我进行咀嚼等之类的过程 面向对象：是先将我封装成一个类，米饭封装成一个类，然后把吃饭进行封装，来各自实现的。 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。 例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用分别的函数来实现，问题就解决了。 而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的i变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。 可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了总多步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。 功能上的统一保证了面向对象设计的可扩展性。比如我要加入悔棋的功能，如果要改动面向过程的设计，那么从输入到判断到显示这一连串的步骤都要改动，甚至步骤之间的循序都要进行大规模调整。如果是面向对象的话，只用改动棋盘对象就行了，棋盘系统保存了黑白双方的棋谱，简单回溯就可以了，而显示和规则判断则不用顾及，同时整个对对象功能的调用顺序都没有变化，改动只是局部的。 再比如我要把这个五子棋游戏改为围棋游戏，如果你是面向过程设计，那么五子棋的规则就分布在了你的程序的每一个角落，要改动还不如重写。但是如果你当初就是面向对象的设计，那么你只用改动规则对象就可以了，五子棋和围棋的区 面向过程与面向对象程序设计 一、面向过程的程序设计 面向过程（Process Oriented）这个词是在面向对象（Object Oriented）出现之后为与之相对而提出的，其实它在以前基本被叫做“结构化编程”。早期的程序设计，大量使用共享变量（全局变量）和GOTO语句一类的东西，后来有人证明所有的程序流程都可以使用三种基本流程（顺序、选择、重复）来实现，并提出“GOTO有害说”，从此人们进行编程的方式发生重大变化，每种语言都 提供这些基本控制结构的实现方式，并提供把数据访问局部化的能力，以及某种形式的模块化/分别编译机制。在这些基础上，人们所进行的编程活动基本是通过编写用于不同目的的功能函数/过程来实现，故称为“面向过程”。 1.1面向过程设计概述 面向过程的结构化程序设计方法就是采用面向过程的方法来设计结构化程序。结构化程序通常包含一个主程序和若干个子过程，其中每个子过程都描述了某一个小问题的解决方法再由主过程自顶向下调用各子过程，来逐步解决整个问题。结构化程序设计方法是一种数学思维或计算机思维方法，和人们认识世界时所习惯使用的方法不同。 面向过程开发方式是对计算机底层结构的一层抽象，它把程序的内容分为数据和操纵数据的操作两部分。这种编程方式的核心问题是数据结构和算法的开发和优化。C语言所提供的机制就是典型的结构化编程设施。 1.2面向对象设计的特点 面向过程的程序设计方法通过在程序中模拟问题求解中的过程来进行问题 求解，这种方法认为过程或函数可以作为建立大型复杂软件系统的抽象机制。但由于在问题求解过程中，一些过程比较复杂，为控制复杂性，引入了功能分解的方法，即将一个复杂的过程分解为复杂性较低的低级过程，这种分解一直进行到参与设计和编程的人员可以理解的步骤或过程为止。这样使得系统是过程的组件，在整个分解过程中，数据结构的安排是出于对过程组织的需要而进行的。因此，数据处于次要地位，而过程是关心的焦点。面向过程的程序方法把重点放在解决问题的过程上，将数据结构和操作这些数据结构的函数分开，在方法上存在明显的不足。 二、面向对象的程序设计 人们在认识客观世界中的各种系统时所习惯使用的方法是面向对象的方法。面向对象的程序设计（OOP）方法就是用人类在现实生活中常用的思维方法来认识、理解和描述客观事物，强调最终建立的程序系统能够映射问题域，即程序系统中的对象以及对象之间的关系能够如实地反映问题域中固有的事物及其关系。因此，它为我们提出了一个全新的概念，其主要思想是将数据（成员数据）及处理这些数据的相应函数（成员函数）封装到一个类（class）中，而使用类的数 面向过程、面向对象、面向组件、面向服务软件架构的分析与比较 摘要：软件开发从汇编语言、过程式语言、面向对象、面向组件发展到面向服务，每一步都体现了不断抽象、更加贴近业务实际的发展趋势。当前软件发展正处于从面向组件思想向面向服务思想的跨越阶段。本文深入分析了面向过程、面向对象、面向组件、面向服务架构，得出相关的优缺点。 关键字：面向过程，面向对象，面向组件，面向服务 1 背景 当前，信息系统的发展越来越明显地呈现出以下特征：软件系统越来越庞大，但是软件系统内部组成模块的规模却越来越小；软件系统的功能越来越复杂，但是系统的开放性却越来越好。信息系统软件正向着不依赖于特定的硬件和操作系统以及具有高度可重用性的方向发展。 在这种情况下，人们对这种大型复杂软件产品的质量和开发速度都有了更严格的要求，传统的开发方法已经难以满足这种需求。首先，我们来分析一下几种传统的系统开发方法。1）自底向上法 自底向上法出现于早期的计算机管理应用系统，即在进行系统分析和设计时自下而上，先从底层模块做起，然后逐步完成整个系统。自底向上法使得系统的开发易于适应组织机构真正的需要；有助于发现系统的增长需要，所获得的经验有助于下一阶段的开发，易于控制和管理。但由于方法的演变性质，自底向上法使系统难以实现其整体性；同时由于系统未进行全局规划，数据一致性和完整性难以保证；而且为了保证系统性能的需求，往往要重新调整，甚至重新设计系统。 2）自顶向下法 随着信息系统规划的扩大和对开发经验的总结与归纳，自顶向下的系统分析方法论逐步得到了发展和完善。自顶向下法要求开发者首先制定系统的总体规划，然后逐步分离出高度结构化的子系统，从上至下实现整个系统。运用这类方法可以为企业或机构MIS的中期或长期发展规划奠定基础，同时支持信息系统的整体性，为系统的总体规划、子系统的协调和通信提供保证。但它同样也存在缺点：对系统分析、设计人员要求较高，在大系统中，对下层系统的实施往往缺乏约束力，开发的周期长，系统复杂，成本较高。 3）快速原型法 原型法的核心是原型，即模型，是系统的早期可运行版本。随着用户或开发者对系统理解的加深，不断地对原型进行补充和细化。系统的定义是在逐步发现的过程中进行，这就是快速原型法的基本出发点。快速原型法的开发过程体现了不断迭代的快速修改过程，是一种动态定义技术。快速原型法的最大优点是能够大大减少软件系统的后期维护费用，使系统功能正确反映用户的需求。原型本身及这种方法的不足之处在于，如果原型本身功能设置不齐全、性能不好，会导致原型的设计和使用超出预期的花费和时间。另一个关键不足是原型法需要一个合适的软件开发环境，以便原型能直接转换成现实的系统。以上方法各有其优缺点。“自底向上”法只重局部而忽视了对整体的把握；“自顶向下”法开发周期长、见效慢、缺乏灵活性和适应性；快速原型法虽然具有很明显的优越性，但因其依赖于快速开发工具的支持，又不能不令许多系统开发者望而却步。因此通过对软件构建技术的研究，人们提出一种新的开发方法—基 面向对象的三个基本特征（讲解） 面向对象的三个基本特征是：封装、继承、多态。 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 继承 面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”。 被继承的类称为“基类”、“父类”或“超类”。 继承的过程，就是从一般到特殊的过程。 要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。 在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。 继承概念的实现方式有三类：实现继承、接口继承和可视继承。 ?实现继承是指使用基类的属性和方法而无需额外编码的能力； ?接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力； ?可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。 在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。 抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。 OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。 多态 多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。 实现多态，有二种方式，覆盖，重载。 覆盖，是指子类重新定义父类的虚函数的做法。 重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。 其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、 str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。” 那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。 面向对象程序设计与面向过程程序设计的关系程序设计可以分为面向过程程序设计和面向对象程序设计。面向过程的结构化程序设计强调功能的抽象和程序的模块化, 它将解决问题的过程看作是一个处理过程。而面向对象的程序设计则综合了功能抽象和数据抽象, 它将解决问题的过程看作为分类演绎的过程。 在结构化程序设计中, 模块是对功能的抽象, 每个模块都是一个处理单位, 它有输入 和输出。而在面向对象程序设计中, 对象是包括数据和操作的整体, 是数据和功能的抽象和统一。也可以这样说: 对象可包括模块。 在结构化程序设计中, 过程是一个独立的实体, 显示其为它的使用者所见, 而且, 对 于相同的输入参数, 每一次的过程调用, 其输出的结果是相同的。在面向对象的程序设计中, 方法是隶属于对象的, 它不是独立存在的实体, 而是对象功能的体现。面向对象程序借助于成员函数调用实现消息的发送。对象响应消息后, 按照消息的模式找出匹配的方法并执行。应当注意, 发送消息和过程调用的意义是不同的,发送消息只是触发自动机，同样地输入参数, 可能因为自动机状态不同其输出的结果会有不同。 类型和类都是数据和操作的抽象，但是类所定义的数据集(包括数据和操作)比常规语言的类型所定义的数据集要复杂得多。例如, 在生成实例时, 类不能像常规语言那样只做个定义就可以了，而是需要类的说明、定义类的实例、规定生成实例操作、无用内存单元的回收等。而且, 类还引入了继承机制, 实现了可扩充性。 在结构化程序设计方法中, 其核心是逐步细化。这种自顶向下的方法是通过不断在程序的控制结构中增加细节来开发程序。它生产的模块往往为了满足特定的需要, 其可重用性较差。面向对象程序设计以数据结构为中心开发模块,同时一体化的考虑操作的功能, 抓住了程序设计中最不易变化的部分--数据, 因此对象常具有良好的可重用性。 第1章绪论............................................................. 错误！未定义书签。 1.1课题背景..................................................................... 错误！未定义书签。 1.2国内外现状 (2) 1.3课题研究意义 (2) 1.4论文的研究内容 (2) 第2章网站建设的相关技术 (4) 2.1JSP简介 (4) 2.2SQL SERVER2000数据库介绍 (6) 2.3JAVASCRIPT介绍 (7) 2.4TOMCA T简介 ............................................................ 错误！未定义书签。第3章系统分析 (9) 3.1系统需求分析 (9) 3.1.1 系统分析原则 (9) 3.1.2 系统目标 (10) 3.1.3 需求内容 (10) 3.2系统的可行性分析 (11) 3.2.1 经济可行性 (11) 3.2.2 技术上的可行性 (11) 3.2.3 时间可行性 (12) 3.2.4 管理上的可行性 (12) 3.2.5操作可行性 (12) 3.3业务流程分析 (12) 3.4系统数据流程分析 (13) 3.4.1 系统数据流程顶层图 (13) 3.4.2 系统数据流程图一层图 (14) 3.4.3 系统数据流程图二层图 (15) 3.5数据字典 (19) 3.5.1 外部实体定义 (19) 3.5.2 主要处理过程定义 (19) 3.5.3 主要数据流定义 (21) 3.5.4 主要数据存储定义 (22) 第4章系统设计 (24) 4.1系统设计 (24) 4.1.1 应用平台配置 (24) 4.1.2 系统功能设计 (24) 4.1.3 系统功能总体设计 (25) 4.2数据库的设计 (25) 4.2.1概念设计 (26) 4.2.2 逻辑设计 (28) 4.2.3 物理设计 (30) 第5章系统实现 (34) 5.1页面设计 (34) 5.1.1 页面设计原则 (34) 5.1.2 页面色彩设计 (35) 5.2用户主页的详细设计 (35) 5.3主页的用户注册登陆模块介绍 (37) 5.3.1 主页用户登录流程图 (38) 5.3.2 用户注册功能 (38) 5.4服装资讯查询模块 (40) 5.5服装信息查询模块 (42) 面向对象程序设计语言和面向过程程序设计语言的区别有哪些? 面向对象的特点是:封装.多态.继承.其中多态有分为重载和重写.面向对象的编程思想更加接近现实的事物. 有这样几点好处: 1.是编程更加容易.因为面向对象更接近于现实.所以你可以从现实的东西出发.进行适当的抽象. 2.在软件工程上.面向对象可以使工程更加模块化.实现更低的耦合和更高的内聚. 3.在设计模式上(似乎只有面向对象才设计到设计模式).面向对象可以更好的实现开-闭原则.也使代码更易阅读. 相对而言.面向过程的程序设计是面向对象程序设计的基础.面向对象的程序里面一定会有面向过程的程序片断的! 面向对象编程（ObjectOrientedProgramming，OOP，面向对象程序设计）是一种计算机编程架构。OOP的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。OOP主要有以下的概念和组件： 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为面向对象: 举个例子，盖一座大楼，你想到的是楼怎么盖，哪里要有柱子，哪里要有梁，哪里楼梯等等（这就是面向对象），至于柱子该怎么建，用什么建，方的圆的，等等，这就是面向过程。用面向对象思考问题更符合我们人的思考方式。其实我们人现实生活中都是在面向对象。比如：去饭店吃饭，你只要说明吃什么就可以了，有必要还了解这个菜是怎么做的，是哪里来的，怎么去种这个菜吗？面向对象也可以说是从宏观方面思考问题，而面向过程可以说是从细节处思考问题。在面向对象中，也存在面向过程。 面向对象分析与设计试题B卷 一、单项选择题( 在每小题的四个备选答案中，选出一个正确答案，并将正确答案的序号填在题干的括号内。每小题 2 分，共20 分) /* 上个世纪80年代开始至今还盛行的以Smalltalk,C++等为代表的面向对象软件开发方法(00)*/ 1.到20世纪末，面向对象软件工程已经逐渐发展成熟，特别是（D）的 形成和广泛使用，采用面向对象分析与编程的软件开发方法已成为软件开发的主流方法。 A. Simula67语言（20世纪70年代的Simula-67是第一个面向对象的语言） B. Smalltalk语言（80年代初的Smalltalk语言） C. Java语言(对流行的语言进行面向对象的扩充得到的语言或C++) D. 统一建模语言(UML)的标准 2. 面向对象的运动产生了多种面向对象的语言, 其中（C）是一种混合性面向对象语言, 既支持面向过程的程序设计方法，又支持面向对象的程序设计方法，有广泛应用的基础和丰富开发环境的支持，因而使面向对象的程序设计能得到很快普及。 A. Smalltalk B. Eiffel C. C++ D. Java 3．下列不属于面向对象技术的基本特征的是（B）。 A. 封装性 B. 模块性 C. 多态性 D. 继承性 4. 面向对象程序设计将描述事物的数据与( C ) 封装在一起,作为一个相互依存、不可分割的整体来处理。 A. 信息 B. 数据隐藏 C. 对数据的操作 D. 数据抽象 5. 关于面向对象方法的优点，下列不正确的叙述是（C）。 A. 与人类习惯的思维方法比较一致 B. 可重用性好 C. 以数据操作为中心 D.可维护性好 6.（D）是从用户使用系统的角度描述系统功能的图形表达方法。 A. 类图 B. 对象图 C. 序列图 D. 用例图 7. (C ) 是表达系统类及其相互联系的图示,它是面向对象设计的核心，建立状态图、协作图和其他图的基础。 A．对象图 B. 组件图 C. 类图 D. 配置图 **8.（D）描述了一组交互对象间的动态协作关系，它表示完成某项行为的对象和这些对象之间传递消息的时间顺序。 A．对象图*B. 协作图 C. 状态图*D. 序列图 9.（D ）就是用于表示构成分布式系统的节点集和节点之间的联系的图示，它可以表示系统中软件和硬件的物理架构。 A. 组件图(用来反映代码的物理结构) B. 协作图(显示对象和他们之间的关系) C. 状态图(对所描述实物的补充说明,他显示了类的所有对象可能具有的状态) )显示系统中软件和硬件的物理架构(配置图D. 10. 使用UML进行关系数据库的（B ）时，需要设计出表达持久数据的实体类及其联系，并把它们映射成为关系数据库表（Table)、视图(View)等。 A. 业务Use Case模型设计(一种描述系统功能需求的方法。表示用户使用系统的一种情况) B. 逻辑数据模型设计 论面向过程的编程思想和方法 一、概念理解 面向过程就是分析解决问题所需要的步骤,然后用函数把这些步骤一步步实现. 面向过程化程序设计是先确定算法，再确定数据结构。 对此我的理解是确定流程是最关键的,决定用什么流程,并一步步划分成若干个模块,然后把每个模块划分成更小的模块,来实现业务需求.比如,盖一座大楼，你想到的是楼怎么盖，哪里要有柱子，哪里要有梁，哪里楼梯等等（这就是面向对象），至于柱子该怎么建，用什么建，方的圆的，等等，这就是面向过程。 过程如图所示: 二、面向过程的编程思想 “面向过程”是一种以过程为中心的编程思想。结构化方法的基本思想主要体现在以下三方面. 自顶向下,逐步求精:把程序看成是一个逐步演化的过程。把一个系统与程序看成是一层一层的。例如：户籍管理系统可以划分为：户籍迁入迁出，人员迁入 迁出，户籍注销，人员注销等几个子系统，而每个子系统又划分为接收用户信 息，实施处理，提供返回信息等等部分. 模块化:即将几个系统分成几个模块，每个模块实现特定的功能，最终整个系统由这些模块组成。模块跟模块之间通过接口传递信息，模块最重要的特点就 是独立性，模块之间还有上下层的关系，上层模块调用下层模块来实现一些功 能。整个项目经过这样的模块化后，开发人员就可以开始有目的的逐个模块、 逐个函数的去实现，进而完成整个项目。 语句结构化:顺序结构、分支结构、循环结构，都是常用的语句结构。 三、面向过程的编程方法 过程分析,功能分解:面向过程方法认为每个小系统都有着明确的开始和明确的结束，开始和结束之间有着严谨的因果关系。所以如果我们要分析这个世界， 并用计算机来模拟它，首要的工作是将这个过程描绘出来，把它们的因果关系 都定义出来；再通过结构化的设计方法，将这些过程进行细化，形成可以控制 的、范围较小的部分。通常，面向过程的分析方法是找到过程的起点，然后顺 藤摸瓜，分析每一个部分，直至达到过程的终点。这个过程中的每一部分都是 过程链上不可分割的一环。 ●结构化分析的步骤如下： ①分析当前的情况，做出反映当前物理模型的DFD； ②推导出等价的逻辑模型的DFD； ③设计新的逻辑系统，生成数据字典和基元描述； ④建立人机接口，提出可供选择的目标系统物理模型的DFD； ⑤确定各种方案的成本和风险等级，据此对各种方案进行分析； ⑥选择一种方案； ⑦建立完整的需求规约。 ●设计原则: ①使每个模块执行一个功能（坚持功能性内聚） ②每个模块用过程语句（或函数方式等）调用其他模块与 ③模块间传送的参数作数据用与 ④模块间共用的信息（如参数等）尽量少 有科学家提出程序=算法+数据结构.这个公式很好地诠释了面向过程程序设计方法的核心思想-----数据和算法.面向过程，都是通过函数实现的。其设计方法 的重点在于如何实现细节过程，将函数与数据分开。它主要是以：主模块+ 若干子模块（mian（）+子函数）的形式展开的。每一个程序的功能、动作都 以相应的函数方法去实现，然后再由主函数以此调用完成相应动作。面向过程 的方法的另一种表述是组成程序的若干函数方法。也就是说，一个程序是由若面向对象程序设计与面向过程程序设计的区别
面向对象与面向过程程序设计方法的比较
举例说明面向对象和面向过程的区别
面向对象和面向过程的本质区别
面向对象和面向过程对比
面向过程的软件系统开发方法
面向对象与面向过程的区别
面向对象程序设计与面向过程程序设计的区别 1
如何理解程序设计中的面向过程与面向对象
面向对象的程序设计语言与面向过程的程序设计语言
面向过程与面向对象程序设计(马京振)
面向过程、面向对象、面向组件、面向服务软件架构的分析与比较
面向对象的三个基本特征和概念
面向对象语言与面向过程语言的关系
面向过程开发方法论文框架
面向对象程序设计语言和面向过程程序设计语言的区别有哪些
完整版面向对象分析与设计练习题含答案
论面向过程的思想与方法
相关主题
文本预览