更新说明
/

1. 面向对象技术

1.1 面向对象的基本概念

• 对象：属性（数据）+方法（操作）+对象ID
• 类（实体类、控制类、边界类）
• 继承与泛化：复用机制
• 封装：隐藏对象的属性和实现细节，仅对外公开接口
• 多态：不通对象收到同样的消息产生不通的结果
• 接口：一种特殊的类，他只有方法定义没有实现
• 重载：一个类可以有多个同名而参数类型不同的方法
• 模板类
• 消息和消息通信：消息是异步通信的

面向对象设计7大原则

• 单一职责原则：设计目的单一的类
• 开放-封闭原则：对扩展开放，对修改封闭
• 里氏（liskov）替换原则：子类可以替换父类
• 依赖倒置原则：要依赖于抽象，而不是具体实现：针对接口编程，而不是针对实现编程
• 接口隔离原则：使用多个专门的接口比使用单一的总接口要好
• 组合重用原则：要尽量使用组合，而不是集成关系达到重用目的；
• 迪米特（Demeter）原则（最少只是法则）：一个对象对其他对象知道的越少越好

  1.2 UML

  

  1.3 类图

1. 依赖关系：一个事务发生变化影响另一个事务 ………▶
2. 泛化关系：特殊与一般关系 ——▷
3. 关联关系：描述了一组链，链是对象之间的连接 ——
4. 聚合关系：整体与部分生命期不同 ——◇
5. 组合关系：整体与部分生命期相同 ——◆
6. 实现关系：接口与类之间的关系 ………▷

1.4 面向对象-设计模式分类

1.5 面向对象-创建型模式

1.6 面向对象-结构型模式

1.7 面向对象-行为型模式

2. 面向对象程序设计

2.1 C++之类的定义

class 类名
{
  public:
      公有数据成员或公有函数成员的定义;
  protected:
      保护数据成员或保护函数成员的定义;
  private:
      私有数据成员或私有函数成员的定义;
};
例：
class CashSuper{
public:
    virtual double acceptCash(double money)=0;
  }

常见的类的修饰符： public protected defalt private

2.2 C++之派生类的定义

class 派生类名：继承方式1 基类名1，继承方式2, 基类名2，….

{
    public:
        派生类的公有数据和函数;
    protected:
        保护数据成员或保护函数成员的定义;
    private:
        派生类的私有数据和函数
    };
例：
class Cashnormal:public CashSuper{ //正常收费子类
public:
    double acceptCash(double money)
    {return money;)
    }

2.2.1 C++之类外定义函数体

在类外定义函数体的格式如下：
返回值类型 类名::成员函数名（形参表）

{
    函数体：
}
::是类的作用域分辨符，用在此处，放在类名后成员函数前，表明后面的成员函数属于的那个类
例：
double CashNormal::acceptCash(double money)
    (return money;)

2.2.2 C++之虚函数与纯虚函数

虚函数定义的一般语法形式如下：
Virtual 函数类型 函数名（形参表）

{
    函数体;
}
纯虚函数定义形式如下：
virtual 函数类型 函数名 （形参表列）=0；
例：
virtual double acceptCash(double money)=0;

2.2.3 C++之对象指针与对象引用

对象指针的语法形式如下：
类名*对象指针名：
对象引用的定义形式如下：
类名&对象引用名=被引用对象：

注意：通过对象名或对象引用访问对象的成员，使用的运算符是“.”；
而使用对象指针访问对象的成员，使用的运算符是“->”。如：对象指针名->数据成员名
或：对象指针名->成员函数名（参数表）

例：
LightOffCommand*kitchenLightOff=new LightOffCommand(kitchenLight);
remoteControl->setCommand(0,livingRoomLightOn,livingRoomLightOff);

2.2.4 JAVA之类的定义

类的定义格式如下：
[import包]
[类修饰符] class xxxclass[extends 超类名][implements 接口名]

{
    public:
        公有数据成员或公有函数成员的定义;
    protected:
        保护数据成员或保护函数成员的定义;
    private:
        私有数据成员或私有函数成员的定义;
}
说明：
import 包：引入包中的类。
类修饰符：主要有四个修饰符，public、abstract、final、private
class 为关键字，xxxclass为类名，命名遵循Java标识符的命名规则。
    extends为继承关键字，implements为接口关键字
例：
class CashDiscount implements CashSuper{
    private double moneyDiscount; //折扣率
    public CashDiscount(double moneyDisscount){
        this moneyDiscount = moneyDiscount;
    }
}
class Whip
     extends CondimentDecorator { //奶泡
        private final int WHIP_PRICE = 8;
     public Whip (Beverage beverage){this.beverage = beverage();
         public String getDescription（）{
         return beverage.getDescription()+",Whip";
         }
          public int cost(){return WHIP_PRICE+BEVERAGE.COST();}
                                   }
class Department{/*代码省略*/}
    class SqlserverDepatment (3) {}
    abstract class Shape{
        abstract public void draw()
        }
        class Rectangle extends Shape{
        }
Import java.util.*
(1) Class Beverage{//饮料
    String description = "Unknown Beverage";
    public String getDescription(){return description;)
        public abstract int cost();
                                  }
    (1) abstract

2.2.5 JAVA之接口的定义

接口的定义格式如下：
[修饰符]interface 接口名[extends 父接口名列表{
[public][static][final]常量：
[public][abstract]方法：
}

interface IFactory{}
Class SqlServerFactory implements IFactory[{}
（1）Drawing{
    （1）interface
    （2）void drawLine(doubleX1,double y1,double x2,double y2)
    （3）void drawCircle(double x,double y,double r)
Class drawing implements Drawing{
       public void drawLine(double x1,double y1,double x2,double y2){代码}
       public void drawCircle(double x,double y,double r)){代码}
    }

2.2.6 注意事项

一、大小写问题
Java语言大小写敏感，如：定义接口关键字为interface，不能写成Interface。C++也是如此。
二、什么时候要加this
方法中，引用对象的变量

class EvironmentData implements (1){
    private float temperature,humidity,cleanness;
    public void setMeasurements(float temperature,float humidity,float cleanness)
        this.temperatur=temperature;
    this.humidity=humidity;
    This.cleanness = cleanness;
}

3. 历年题

1. 在面向对象方法中，将逻辑上相关的数据以及行为绑定在一起，使信息对使用者隐蔽称为（）。当类中的属性或方法被设计为private时，（）可以对其进行访问。

A.抽象；
B.继承；
C.封装；
D.多态;

A. 应用程序中所有方法；
B. 只有此类中定义的方法；
C. 只有此类中定义的public方法；
D. 同一个包中的类中定义的方法

C； B； 唯一可以访问private的是：只有此类中的方法都可以访问，C，不仅是public方法

1. 采用继承机制创建子类时，子类中（）

A. 只能有父类中的属性
B. 只能有父类中的行为
C. 只能新增行为
D. 可以有新的属性和行为
D；

1. 面向对象分析过程中，从给定需求描述中选择（）来识别对象

A. 动词短语
B. 名词短语
C. 形容词
D. 副词
B 对象往往是名词

1. 阅读下列说明和JAVA代码，将应填入（n）处的字句写在答题纸的对应栏内。

【说明】
生成器（Builder）模式的意图是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。图6-1所示为其类图

import java util*;
class Product{
    private String part A;
    private String part B;
   public void setPartA(String s)(partA=s;)
   public void setPartB(String s)(partB=s;)
    }
interface Builder{ 
    public(1);_______________void buildPartA()
    public void buildPartB();
    public(2);______________Product getResult()
}
class ConcreteBuilder1:implements Builder(
    private Product product;
    public ConcreteBuilder 1()(product =new Product();)
    public void buildPartA()（ （3）______Product.setPartA（"Componnet A"）;）
    public void buildPartB() ( （4）______Product.setPartB（"Component B"）;)
    public ProdectgetResult()(return product);
    }
class ConcreteBuilder2 implements Builder(
     ::代码省略
     }
class Director{  //::这里其实是在实例化
    private Builder builder;
    public Director(Builder builder)(this builder=builder.)
    public void construct(){
    (5) _________builder.buildPartA();
        _________builder.buildPartB();
        _________Product p=builder.getResult();
    ::代码省略
    }
    }
 class Test{
     public static void main(String[]args){
        Director director1=new Director(new ConcreteBuilder1());
        director1.construct()
        }
        }