OOP: Object-Oriented Programming

Chapter 1对象导言• 本章将介绍面向对象程序设计的基本概念，包括 OOP开发方法的描述–抽象–封装–多态–继承

抽象的过程• 什么是抽象？

Abstraction is the process or result of generalization by reducing the information content of a concept or an observable phenomenon, typically to retain only information which is relevant for a particular purpose.

<http://en.wikipedia.org/wiki/Abstraction>

什么是抽象

抽象的过程• 所有的的程序设计语言都提供抽象的机制。– 程序通常是现实的一个模型：一个窗口，一辆战车。

• 以复杂度的角度来看，抽象的好处在于让人忽略无关的细节• 人们能够解决的问题的复杂性直接与抽象的类型和质量有关。• 程序设计语言的演化过程是抽象层次不断提高的过程。

抽象的过程• 纯面向对象程序设计语言的特性– 万物皆对象。– 程序就是一组对象，对象之间通过发送消息互相通知做什么。– 每一个对象都有它自己的由其他对象构成的存储区。– 每个对象都有一个类型。– 一个特定的类型的所有对象都能够接受相同的消息。

• 纯的面向对象的程序设计语言能够保证写出面向对象风格的程序吗？

对象有一个接口（界面）• 对象的接口（界面）规定我们能像特定的对象发出什么消息。• 对象的接口由其类 (class)或类型 (type)确定。• 抽象的接口在现代程序设计语言中具有重要的意义。

隐藏实现的细节• 在一个软件开发的过程中，一个团队中的成员可以分为类的创建者和客户程序员。• 类的创建者是是创建新数据类型的人，他们的目标是创建类。• 客户程序员的目标是去收集一个装满类的工具箱，用于快速构建应用。• 创建者所能设计的一个好的工具箱应该只暴露对于客户程序员必须的东西，而其他的都隐藏起来。

能够热咖啡的 CPU

另一种热咖啡的办法

隐藏实现的细节• 现实世界中的信息隐藏–电视遥控器–咖啡加热器

• 程序中的信息隐藏 (封装 )–提供更加明确的接口 (界面 )–保护易于变化的部分–通过访问控制来达到隐藏实现细节的目的

• 抽象让人能从一个层次来观察对象，而封装则限制你只能从这个层次来观察对象。

隐藏实现的细节• 例：获取一年的某天是否为假日

class HolidayManager{ public char[365] days;}

class HolidayManager{ private char[365] days; public boolean isHolidy(Date date){ …….. }}

实现的重用：组合• 创建了一个类并进行了测试后，这个类在理论上成为了重用的对象–重用性并不像许多人所希望的那样容易达到

• 重用一个类的最简单的方法是直接使用这个对象：组合• 组合具有很大的灵活性，可以在运行的时候改变被组合的对象，从而动态改变程序的行为。

继承：基本概念• 继承是类之间建立的一种关系。• 继承提供了层次化的分类机制。• 继承是一种重用的机制。但不见得是最好的重用方式

继承：简单继承• 继承反映了类型之间的关系

简单地继承一个类，而不做其他任何事情，派生出的类于其父类具有相同的行为，这一点并不是特别有意义。

继承：改变接口• 改变子类的接口

由于基类没有我们期望这个子类提供的接口，因此需要向子类中增加全新的函数。在这种情况下， Triangle 作为Shape，它的行为没有改变。

继承：重载• 改变基类的行为

使用同一个接口函数，但子类与基类将具有不同的行为。

继承： is-a 和 is-like-a• Is-a– 对待继承的理想方法是重载，因为这被认为是纯代替 (pure

substitution)，又被称为是代替原则。– 在这种情况下，子类和父类之间的关系可以看作是 is-a关系

• Is-like-a– 有时需要向一个派生类添加新的接口元素，这样就扩展了接口，并创建了新的类型。– 这个新的类型仍可以代替这个基类，但这个代替不是完美的，因为这些新的函数不能从基类访问。– 在这种情况下，子类和基类的关系可以看作是 is-like-a的关系。

继承：多态• 当处理类型层次结构时，程序员常常希望不把对象看作是某一特殊类型的成员，而是想把它看作是其基本类型的成员，这样就允许程序员编写不依赖于特殊类型的程序代码。

继承：多态

class BirdController{ Collection<Bird> birds; public void reLocate(){

for(Bird bird : birds){bird.move();

} }}

多态： upcasting

• 我们把处理派生类型就如同处理其基类型的过程成为向上类型转换

多态：究竟发生了什么• 函数调用通常被编译成指针跳转到函数的开始位置，这是在编译和连接是就确定下来的。这被称为 early binding。• 然而 OOP的编译器多态采用了 late binding的技术，函数调用是在运行时才确定的。• C++中的 virtual关键字。

C++ Java

多态：逛街模拟器public abstract class Person{

public String getName(){...}public Date getBirthday(){...}public abstract Collection shopping();

}

public class Girl extends Person{public Collection shopping(){...}

}

public class Boy extends Person{public Collection shopping(){...}

}

多态：逛街模拟器• 继承被滥用很危险。• 在可能的情况下，用属性来组合其他类以达到重用的效果。

enum Gender{male, female

}

public class Person{public String getName(){...}public Date getBirthday(){...}public Gender getGender(){...}

}

多态：逛街模拟器• 然而，就我们的应用而言，由于 Girl和 Boy在 Shopping 时的行为有所不同，如果不采用继承的方法：

public class Person{ public Gender getGender(){...} public Collection shopping(){

if(getGender()==Gender.male){...}else{...}

}}

程序中分支过多，会影响程序的灵活性

多态：逛街模拟器• Shopping模拟器的实现：public class ShoppingSimulator{

public Collection simulate(Collection<Person> persons){for(Person person : persons){

person.shopping();......

}}

}

多态：逛街模拟器• 假如狗也可以逛街

public class Dog extends Person{public void shopping(){...}

}

尽管能够临时解决问题，但类型层次怪异，需要重新设计，但如何修改？

多态：逛街模拟器• 较好的解决方案：引入接口

public interface IShoppinger{Collection shopping();

}

public class Person{public String getName(){...}public Date getBirthday(){...}public Gender getGender(){...}

}

多态：逛街模拟器public class Girl extends Person implements IShoppinger{

public Gender getGender(){return Gender.femal;}public Collection shopping(){...}

}

public class Boy extends Person implements IShoppinger{ public Gender getGender(){return Gender.male;} public Collection shopping(){...}

}

public class Dog implements IShoppinger{public void wangwang(){...}public Collection shopping(){...}

}

• 较好的解决方案：引入接口 (2)

多态：逛街模拟器

多态：逛街模拟器

public class ShoppingSimulator{public Collection simulate(Collection<IShoppinger> shoppingers{

for(Collection<IShoppinger> shoppinger: shoppingers{shoppinger:.shopping();......

}}

}

什么被重用了？

• 较好的解决方案：引入接口 (3)

创建和销毁对象• 对象数据存放在何处？• 如何控制对象的生命周期？• Java/C#的自动垃圾回收机制大大降低的程序开发的复杂性。

C++ Java

信息隐藏：比较• C++中的封装• Java中的封装• 语法和语义封装

C++类的访问控制• 一个类的成员可以有以下的修饰符：– private• 只能被类内部的成员访问

– protected• 只能被类内部和其子类访问

– public• 能被所有类访问

C++ Java

友元• 如果程序员想显式地允许不属于当前结构的一个成员访问当前结构中的数据，可以在该结构内部声明设个函数为友元 (friend)• Friend.cpp

C#: interal关键字• internal 关键字是类型和类型成员的访问修饰符。只有在同一程序集的文件中，内部类型或成员才是可访问的，如下例所示：

public class BaseClass { // Only accessible within the same assembly internal static int x = 0;

}• 内部访问通常用于基于组件的开发，因为它使一组组件能够以私有方式进行合作，而不必向应用程序代码的其余部分公开。

Java中的内部类• 静态成员类• 成员类• 局部类

C++ Java

Java：成员类• 成员类的显著特性就是成员类能访问它的外部类实例的任意字段与方法。方便一个类对外提供一个公共接口的实现是成员类的典型应用。• 以 JDK Collection类库为例，每种 Collection类必须提供一个与其对应的 Iterator实现以便客户端能以统一的方式遍历任一 Collection实例。每种 Collection类的 Iterator实现就被定义为该

Collection类的成员类。

Java：成员类public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> { …… public Iterator<E> iterator() { return new Itr(); } private class Itr implements Iterator<E> {

public E next() { checkForComodification(); try {

E next = get(cursor);lastRet = cursor++;return next;

} catch (IndexOutOfBoundsException e) {…… } }

} ……}

Java：成员类特点• 能够访问到包含其类的所有数据成员• 实例化时需要有一个包含类的示例–由包含类实例化• 如上例

– 带包含类的实例：• out.new Inner();

Java: 局部类• 将一个类的定义和实例化移至方法体中，这个类成为局部类

Java: 局部类

Java: 局部类匿名类public void onSelectionChanged(SelectionEvent event) {

final FlowItem selected = getFlowById(event.getRecord().getAttribute("id"));

actionButton.addClickHandler(new ClickHandler() {public void onClick(ClickEvent event) {

TaskPanel taskPanel = TaskPanelFactory.getTaskPanel(selected, ad.getId());

taskPanel.show();}

});}

Java: 局部类• 局部类只在被定义的块中可见• 局部类不能被声明为 public, protected,

private, 或 static• 局部类不能够包含静态成员• 不能定义为接口• 局部类可以使用所定义的块中可见的，声明为 final的局部变量。

其他实现信息隐藏的手段• 通过 interface实现的信息隐藏

总结• Class• Package• Subsystem

依靠语法就足够了吗？• 要格外注意避免从语义上破坏封装性– 假如一个类有两个公共的方法，分别为

• Terminate• PerformFinalOperation

– 如果在使用中需要知道， PerformFinalOperation中已经调用过 Terminate了，不需要再次调用 Terminate，那我们就说这两个方法在实现上破坏了语义上的封装。– 每当你发现自己是通过查看了的内部实现来得知该如何使用这个类的时候，你就不是在针对接口编程了。– From [Code Complete II]

异常处理• 在异常处理发明前，用 if/else和返回值来处理异常– 异常处理的代码量要多于正常的代码。– 正常处理逻辑和异常处理逻辑混在一起。– 函数使用返回值来标识错误状态。

• 使用异常处理后–能够简洁漂亮地处理异常。– 正常处理逻辑和异常处理逻辑混分离。

未用异常处理

int printFile (char* fileName){ char c[10] ； int result = 0; FILE *file;

file = fopen(fileName, "r"); if(file==NULL) { result = 1; }else { n = fread(c, 1, 10, file); if( n!=-1){ c[n] = '\0'; printf(c); }else{ result = 1; } fclose(file); } return result;}

使用异常处理public void printFile (String fileName) throws IOException {

char[] c = new char[10];FileReader reader = null;try {

reader = new FileReader(fileName);reader.read(c, 1, 10);System.out.println(c);

} finally {if (reader != null) reader.close();

}}

异常处理：下面代码有什么问题？public void printFile (String fileName) {

char[] c = new char[10];FileReader reader = null;try {

reader = new FileReader(fileName);reader.read(c, 1, 10);System.out.println(c);

} catch(IOException e){

}finally {if (reader != null) reader.close();

}}