2023年面向对象程序设计复习资料.doc

1．对象
（1）从概念层面讲，对象是某种拥有责任的抽象。
（2）从规格层面讲，对象是一系列可以被其他对象使用的公共接口。
（3）从语言实现层面讲，对象封装了代码和数据。
2．软件开发中的经典阶段：需求、分析、设计、规范、实现、测试、部署、维护。
3．设计7原则：开闭原则、里氏代换原则、依赖倒转原则、合成/聚合复用原则、
迪米特原则、接口隔离原则、单一职责原则。
4．面向对象的方法学：UML（统一建模语言）、RUP（统一软件开发过程）、XP（极限编程）。
开发方法：Booch、Coad、OMT、UML、OOSE、Wirfs—Brock
5．OOA——运用面向对象方法进行需求分析。
OOD——运用面向对象方法进行系统设计。
OOP——运用面向对象方法进行程序设计。
6．OOA的基本任务：是运用面向对象的方法，对问题域和系统责任进行分析和理解，对其中的事物和它们之间的关系产生对的的结识，找出描述问题域及系统责任所需的类及对象，定义这些类和对象的属性和操作，以及它们之间所形成的结构、静态联系和动态联系。
最终目的：是产生一个符合用户需求，并可以直接反映问题域和系统责任的OOA模型及其具体说明。
优点：（1）加强了对问题域和系统责任的理解。（2）改善与分析有关的各类人员之间的交流。（3）对需求的变化具有较强的适应性。（4）支持软件复用。
OOA的三大策略是：属性策略、方法策略、对象策略。
7．（1）封装：是指对象在其操作中隐藏属性。它是一种信息隐蔽技术，用户只能看见对象封装界面上的信息，对象的内部实现对用户是隐蔽的。封装的目的是使对象的使用者和生产者分开，使对象的定义和实现分开。
例如：要从同事那里借钱，在商店购买食物，就不会抢夺同事的钱包，大翻一通，看看里面是否有足够的钱。而应当询问他们是否可以借你一些钱，他们就会自己翻钱包。
以表达圆的一个对象作为封装的例子。圆的操作应能计算出半径、直径、周长和面积。假定选择存储直径，要访问直径的程序员都会选择存储直径属性，而不是通过“获取直径”的操作来访问。假如在软件的后续版本中要存储的是半径，就必须找出系统中直接访问直径的所有代码，并更正它们，有了封装，就不会有问题。
（2）继承：可以指定类从父类中获取一些特性，再添加它自己的独特特性。继承是类间的基本关系，它是基于层次关系的不同类共享数据和操作的一种机制。父类中定义了其所有子类的公共属性和操作，在子类中除了定义自己特有的属性和操作外，可以继承父类的属性和操作，也可以对父类中的操作重新定义其实现方法。
例如：在面向对象中，我们可以把洗衣机、电冰箱、微波炉、收音机当作是家用电气类的子类，也可以说家用电器类是这些类的超类。家用电器类具有的属性OnOffSwitch和electricWire，具有turnOn（）和turnOff（）操作。因此，假如你知道某物是家用电器，那么就会立即知道它具有家用电器类的属性和操作，这种关系就是继承。每个家用电器类的子类都继承了家用电器类的特性。同时，每个子类都增长了自己的属性和操作。
（3）多态：是指同一操作作用于不同的对象上可以有不同的解释，并产生不同的执行结果。例如：“画”操作，作用在“矩形”对象上，则在屏幕上画一个矩形；作用在“圆”对象上，
则在屏幕上画一个圆。也就是说，相同操作的消息发送给不同对象时，每个对象将根据自己所属类中定义的这个操作方法去执行，从而产生不同的结果。
6．RUP（统一软件开发过程)：是一个面向对象且基于网络的程序开发方法论。RUP仿佛一个在线的指导者，它可认为所有方面和层次的程序开发提供指导方针，模版以及事例支持。 RUP是理解性的软件工程工具，它把开发中面向过程的方面和其他开发的组件整合在一个统一的框架内。
RUP的本质：
（1）RUP是风险驱动的、基于Use Case技术的、以架构为中心的、迭代的、可配置的软件开发流程。
（2）我们可以针对RUP所规定出的流程，进行客户化定制，定制出适合自己组织的实用的软件流程。
因此RUP是一个流程定义平台，是一个流程框架。
7． RUP中有9个核心工作流，分为6个核心过程工作流（商业建模、需求、分析和设计、
实现、测试、部署工作流）以及3个核心支持工作流（配置和变更管理、项目管理、环境工作流）。尽管6个核心过程工作流也许使人想起传统瀑布模型中的几个阶段，但应注意迭代过程中的阶段是完全不同的，这些工作流在整个生命周期中一次又一次被访问。9个核心工作流在项目中轮流被使用，在每一次迭代中以不同的重点和强度反复。
8．RUP是一个基于6个最佳开发实践的流程定义产品：（1）迭代式开发（2）需求管理（3）基于组建的体系架构（4）可视化建模（5）连续的质量管理（6）配置管理 。
9．设计模式：是一套被反复使用、多数人知晓的、通过度类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被别人理解、保证代码可靠性。毫无疑问，设计模式于己于别人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石同样。
分类：创建型模式、行为型模式、结构型模式、Singleton模式。

1．使用简朴工厂模式设计计算器程序
//Computer.java
public class Computer
{
public static void main(String[] args) throws IOException
{
String strA ;
String strB ;
String strO ;
try
{
BufferedReader br = new BufferedReader(new InputStreamReader (System.in));
System.out.print("请输入数据A：") ;
strA = br.readLine( ) ;
System.out.print("请选择运算符号(+、-、*、/):" ) ;
strO= br.readLine( );
System.out.print("请输入数据B：") ;
strB = br.readLine( ) ;
String strResult = "" ;
Operation oper = null ;
IFactory operFactory = null ;
if(strO.equals("+") ) {
operFactory= new AddFactory( ) ;
}
if(strO.equals("-") ) {
operFactory = new SubFactory( );
}
oper = operFactory.createOperation( );
oper.SetNumberA(Double.valueOf(strA).doubleValue( ) ) ;
oper.SetNumberB(Double.valueOf(strB).doubleValue( ) ) ;
strResult = Double.toString(oper.GetResult( ) ) ;
System.out.print(strResult) ;
}
catch(Exception e ) {
}
}
}
优点：简朴工厂模式就是由一个工厂类根据参数来决定创建出哪一种产品类的实例。
专门负责将大量有共同接口的类实例化,并且不必事先知道每次是要实例化哪一个类的模式。

2．策略模式：商场促销
public class Context {
public Strategy strategy ;
public Context(char name) throws Exception {
switch(name) {
case ‘ A ’:
strategy = new ConcreteStrategyA() ;
break ;
case ‘ B ’:
strategy = new ConcreteStrategyB() ;
break ;
case ‘ C ’:
strategy = new ConcreteStrategyC() ;
break ;
default :
throw new Exception(“没有此类输入”);
}
}
public void contextInterface() {
strategy.algorithInterface();
}
}
public abstract class Strategy {
public abstract void algorithInterface() ;
}
public class ConcreteStrategyA extends Strategy {
public abstract void algorithInterface() {
system.out.println(“打折算法”) ;
}
}
public class ConcreteStrategyB extends Strategy {
public abstract void algorithInterface() {
system.out.println(“满100送60算法”) ;
}
}
public class ConcreteStrategyC extends Strategy {
public abstract void algorithInterface() {
system.out.println(“正常收费，不参与活动！”) ;
}
}
public class Client {
public static void main(String[] args) throws Exception {
Context context ;
context = new Context(‘A’) ;
context.contextInterface() ;
}
}

Context
+contextInterface():void
Strategy
+algorithInterface():void
concreteStrategyA
+algorithInterface( ):void

concreteStrategyB
concreteStrategyC
+algorithInterface( ):void

+algorithInterface( ):void

特点：
（1）Strategy属于设计模式中的对象行为型模式，重要是定义一系列的算法，把这些算法一个个封装成单独的类，使它们可互相替换。本模式使得算法可独立于使用它的客户而变化。
（2）它提供了一种用多个行为中的一个行为来配置一个类的方法。
（3）它需要使用一个算法的不同变体。
（4）它以避免暴露复杂的、与算法相关的数据结构。
（5）一个类定义了多种行为， 并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy 类中以代替这些条件语句。

3．装饰模式
举Adapter中的打桩示例，在Adapter中有两种类：方形桩、圆形桩，Adapter模式展示如何综合使用这两个类，在Decorator模式中，我们是要在打桩时增长一些额外功能，比如：挖坑，在桩上钉木板等，不关心如何使用两个不相关的类。
public interface Work
{
public void insert();
}

public class SquarePeg implements Work {
public void insert(){
　　System.out.println("方形桩插入");
}
}

public class Decorator implements Work{
private Work work;
　　//额外增长的功能被打包在这个List中
　　private ArrayList others = new ArrayList();
//在构造器中使用组合new方式,引入Work对象;
public Decorator(Work work)
{ this.work=work;
　　 others.add("挖坑");
　　　　others.add("钉木板");
　　}
　　public void insert(){
　　　　newMethod();
}

public void newMethod()
{
otherMethod();
work.insert();
}

public void otherMethod()
{
　ListIterator listIterator = others.listIterator();
　while (listIterator.hasNext())
　　{
System.out.println(((String)
(listIterator.next())) + " 正在进行");
　　}
}
特点：动态地给一个对象添加一些额外的职责。就增长功能来说，使用装饰模式相比用生成子类方式达成功能的扩充显得更为灵活。
我们通常可以使用继承来实现功能的拓展，假如这些需要拓展的功能种类很繁多，那么势必生成很多子类，增长系统的复杂性，同时，使用继承实现功能拓展,我们必须可预见这些拓展功能，这些功能是编译时就拟定了，是静态的。使用Decorator时这些功能需要由用户动态决定加入的方式和时机.装饰模式提供了“即插即用”的方法，在运营期间决定何时增长何种功能。

Component
+Operation():void
ConcreteComponent
+Operation(): void

Decorator
+Operation(): void

ConcreteDecoratorA
-addState : String
+Operation(): void

ConcreteDecoratorB
+Operation(): void
-AddBehavior(): void

4．使用工厂方法设计模式设计工资打印程序
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class ClientPrint {
public static void main(String[] args) {
try{
String stremp;
System.out.print("请输入员工：");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
stremp = br.readLine();
Employee emp;
emp = EmployeeFactory.createEmployee(stremp);
emp.getSalary();
}
catch(Exception e){
}
}
}