面向对象 复习资料1Word文件下载.docx
《面向对象 复习资料1Word文件下载.docx》由会员分享，可在线阅读，更多相关《面向对象 复习资料1Word文件下载.docx（15页珍藏版）》请在冰豆网上搜索。
开发方法：
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）多态：
是指同一操作作用于不同的对象上可以有不同的解释，并产生不同的执行结果。
“画”操作，作用在“矩形”对象上，则在屏幕上画一个矩形；
作用在“圆”对象上，
则在屏幕上画一个圆。
也就是说，相同操作的消息发送给不同对象时，每个对象将根据自己所属类中定义的这个操作方法去执行，从而产生不同的结果。
RUP
螺旋式、迭代式和递增式方法称为RationalUnifiedProcess
RUP核心工作流
RUP中有9个核心工作流，分为6个核心过程工作流和3个核心支持工作流
1.商业建模2.需求3.分析与设计4.实现5.测试6.部署7.配置和变更管理8.项目管理9.环境
重载
函数重载是指在同一个作用域内的若干个参数特征不同的函数可以使用相同的函数名字。
运算符重载是指同一个运算符可以施加于不同类型的操作数上面。
抽象方法和虚方法的区别：
1．（abstract）抽象方法和（virtual）虚方法的区别在于：
虚方法有一个实现部分可以为子类实现有共同的方法，并为派生提供了覆盖该方法的选项，相反，抽象方法没有提供实现部分，强制派生覆盖方法（否则派生类不能成具体类）.
2..（abstract）抽象方法只能在抽象类中声明，（virtual）虚方法不是。
3.（abstract）抽象方法不能声明方法实体，虚方法可以。
4.包含抽象方法（只有抽象类才可以包含抽象方法）的类不能实例化（也就是说只可以使用predected和private修饰符），虚方法可以
Java中抽象类和接口的区别:
1. 一个类只能继承一个抽象类。
但是，一个类却可以实现多个接口interface
2.在abstractclass中可以有自己的数据成员，也可以有非abstract的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是staticfinal的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。
3.abstractclass和interface所反映出的设计理念不同。
其实abstractclass表示的是"
is-a"
关系，interface表示的是"
like-a"
关系。
4.实现抽象类和接口的类必须实现其中的所有方法。
抽象类中可以有非抽象方法。
但是，接口中必须都是抽象方法（默认都是publicabstract类型的）。
5.接口中定义的变量默认是publicstaticfinal型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。
6.抽象类中的变量，其值可以在子类中重新定义，也可以重新赋值。
原则之间的相互关系：
开闭原则是构造可维护性复用性软件的基石，其他原则是达成开闭原则的手段和工具。
为什么需要使用单例模式
属性是系统的一种"
资源"
，应当避免有多余一个的对象读取特别是存储属性。
此外，属性的读取可能会在很多地方发生，创建属性对象的地方应当在哪里不是很清楚。
换言之，属性管理器应当自己创建自己的实例，并且自己向系统全程提供这一事例。
因此，属性文件管理器应当是一个单例模式负责。
❑作为对象的创建模式[GOF95]，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
这个类称为单例类。
❑单例模式的要点
单例模式的要点有三个；
❑一是某各类只能有一个实例；
❑二是它必须自行创建这个实例；
❑三是它必须自行向整个系统提供这个实例。
1．使用简单工厂模式设计计算器程序
//Computer.java
publicclassComputer
{
publicstaticvoidmain（String[]args）throwsIOException
StringstrA;
StringstrB;
StringstrO;
try
BufferedReaderbr=newBufferedReader（newInputStreamReader（System.in））;
System.out.print（"
请输入数据A：
"
）;
strA=br.readLine（）;
请选择运算符号（+、-、*、/）:
）;
strO=br.readLine（）;
请输入数据B：
strB=br.readLine（）;
StringstrResult="
;
Operationoper=null;
IFactoryoperFactory=null;
if（strO.equals（"
+"
））{
operFactory=newAddFactory（）;
}
-"
operFactory=newSubFactory（）;
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（Exceptione）{
}
//Operation.Java
publicabstractclassOperation{
privatedoublenumberA;
privatedoublenumberB;
publicdoubleGetNumberA（）{
returnnumberA;
publicvoidSetNumberA（doublea）{
numberA=a;
publicdoubleGetNumberB（）{
returnnumberB;
publicvoidSetNumberB（doubleb）{
numberB=b;
publicabstractdoubleGetResult（）;
//IFactory.Java
publicinterfaceIFactory{
publicabstractOperationcreateOperation（）;
//AddFactory.Java
publicclassAddFactoryimplementsIFactory{
publicOperationcreateOperation（）{
returnnewOperationAdd（）;
publicclassSubFactoryimplementsIFactory{
returnnewOperationSub（）;
classOperationAddextendsOperation{
publicdoubleGetResult（）
{
doubleresult=0;
result=super.GetNumberA（）+super.GetNumberB（）;
returnresult;
classOperationSubextendsOperation{
doubleresult=0;
result=super.GetNumberA（）-super.GetNumberB（）;
简单工厂模式就是由一个工厂类根据参数来决定创立出哪一种产品类的实例。
专门负责将大量有共同接口的类实例化,而且不必事先知道每次是要实例化哪一个类的模式。
2．策略模式：
商场促销
publicclassContext{
publicStrategystrategy;
publicContext（charname）throwsException{
switch（name）{
case‘A’:
strategy=newConcreteStrategyA（）;
break;
case‘B’:
strategy=newConcreteStrategyB（）;
case‘C’:
strategy=newConcreteStrategyC（）;
default:
thrownewException（“没有此类输入”）;
publicvoidcontextInterface（）{
strategy.algorithInterface（）;
publicabstractclassStrategy{
publicabstractvoidalgorithInterface（）;
publicclassConcreteStrategyAextendsStrategy{
publicabstractvoidalgorithInterface（）{
system.out.println（“打折算法”）;
publicclassConcreteStrategyBextendsStrategy{
system.out.println（“满100送60算法”）;
publicclassConcreteStrategyCextendsStrategy{
system.out.println（“正常收费，不参加活动！
”）;
publicclassClient{
publicstaticvoidmain（String[]args）throwsException{
Contextcontext;
context=newContext（‘A’）;
context.contextInterface（）;
特点：
（1）Strategy属于设计模式中的对象行为型模式，主要是定义一系列的算法，把这些算法一个个封装成单独的类，使它们可相互替换。
本模式使得算法可独立于使用它的客户而变化。
（2）它提供了一种用多个行为中的一个行为来配置一个类的方法。
（3）它需要使用一个算法的不同变体。
（4）它以避免暴露复杂的、与算法相关的数据结构。
（5）一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。
将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。
3．装饰模式
//Person.Java
publicclassPerson{
privateStringname;
publicPerson（）{
publicPerson（Stringname）{
this.name=name;
publicvoidshow（）{
System.out.println（"
装扮的"
+name）;
//Client.Java
publicclassClient{
publicstaticvoidmain（String[]args）{
Personperson=newPerson（"
流浪"
）;
第一种装扮"
Clothingdtx=newTshirt（）;
Clothingckk=newCrossPants（）;
dtx.Decorator（person）;
ckk.Decorator（dtx）;
ckk.show（）;
第二种装扮"
Clothingxz=newSuit（）;
Clothingld=newTie（）;
xz.Decorator（person）;
ld.Decorator（xz）;
ld.show（）;
//Clothing.Java
publicclassClothingextendsPerson{
protectedPersoncomponent;
publicvoidDecorator（Personcomponent）{
ponent=component;
if（component!
=null）{
component.show（）;
//CrossPants.Java
publicclassCrossPantsextendsClothing{
穿跨裤"
super.show（）;
//suit.Java
publicclassSuitextendsClothing{
穿西装"
//Tie.Java
publicclassTieextendsClothing{
打领带"
//Tshirt.Java
publicclassTshirtextendsClothing{
Tshirt"
动态地给一个对象添加一些额外的职责。
就增加功能来说，使用装饰模式相比用生成子类方式达到功能的扩充显得更为灵活。
我们通常可以使用继承来实现功能的拓展，如果这些需要拓展的功能种类很繁多，那么势必生成很多子类，增加系统的复杂性，同时，使用继承实现功能拓展,我们必须可预见这些拓展功能，这些功能是编译时就确定了，是静态的。
使用Decorator时这些功能需要由用户动态决定加入的方式和时机.装饰模式提供了“即插即用”的方法，在运行期间决定何时增加何种功能。
4．使用工厂方法设计模式设计工资打印程序
importjava.io.BufferedReader;
importjava.io.InputStreamReader;
publicclassClientPrint{
publicstaticvoidmain（String[]args）{
try{
Stringstremp;
System.out.print（"
请输入员工：
BufferedReaderbr=newBufferedReader（newInputStreamReader（System.in））;
stremp=br.readLine（）;
Employeeemp;
emp=EmployeeFactory.createEmployee（stremp）;
emp.getSalary（）;
catch（Exceptione）{
升级会员 