改变思维
曾经在学校学习数据结构课程时，第一节课上，老师就告诉我们：程序=数据结构+算法。这句话对我后来学习数据结构起了很大的作用，积极的作用。
可是后来学到C++面向对象部分时，这句话让我在有些地方怎么也想不通。想了很久之后，我得出了另一个结论，在面向对象程序中，程序=对象&行为。这里我使用&，是为了说明对象与行为是关系的。行为是对象的行为，对象要对它自己的行为负责。
这种思维上的转换在从PO到OO的过程中非常重要，下面我举个例子：
假如使用PO的思维，我们想要实现“兔子走路”和“人走路”，我们会怎么做呢？
首先，写一个“兔子”结构体。struct rabbit{}r;
然后是一个“兔子走路”的算法。void rabbitWalk(rabbit r);
最后对“兔子”使用“兔子走路”算法。rabbitWalk(r);
“人走路”与“兔子走路”类似：
struct human{}h;
void humanWalk(human h);
humanWalk(h);这就是数据结构+算法的思维。程序“兔子走路”=数据结构“兔子”+算法“兔子走路”。程序“人走路”=数据结构“人”+算法“人走路”。
如果数据结构“人”+算法“兔子走路”会怎样呢？
首先创建一个“兔子”对象class rabbit{};rabbit r;
由于兔子需要“走路”这一行为，因此向类中添加这一行为class rabbit{ void walk(){}};
让“兔子”对象执行它的“走路”行为。r.walk();
同样地，“人走路”的程序可以这样实现：
Class human : public animal
{void walk(){}};
human h;
h.walk();在这里，是对象调用它自己的行为。两个“走路”行为虽然同名，但是它们是不相关的。由对象自己决定它们调用哪个“走路”行为，而程序员要做的，只是让对象执行它们的“走路”行为。人没有兔子的走路行为，所以让人用兔子走路的方法是不可能的。
面向对象
上文用一个简单的例子说明了从PO到OO的思维转变，下面开始介绍一些OO相对于PO来说所具体的一些特性。网上能查到相关术语的解释，这里不会详细展开。
对象和类
对象是与现实世界相关的一个实例，而类是对对象的抽象。注意，在面向对象中，通常是先有对象再有类的。首先是我们需要一个对象，就把它抽象成一类，丰富它的行为。然后再使用这个类实例化出一个对象来使用。
类不一定是名字，也可以是动词。
比如一只“喜羊羊”是一个对象，抽象出来的羊是一个类。
喜羊羊“从学校走到村长的家”也可以是一个对象，抽象出走路这个类。
消息传递与动态分发
请看这样两行代码
xiyangyang.walk(hua_ban);
xiyangyang.walk(bike);消息传递是指，当程序想要喜羊羊用滑板走路时，就使用这条语句，给xiyangyang发送一条walk的消息，并带上hua_ban参数。
那么这个消息会怎么处理呢？这个我们不需要关心，因为这是由xiyangyang决定的。这就是动态分发。
封装
PO也有封装的概念，不过OO做得更好。
组合与继承
也许大家对继承比较熟悉，对组合比较陌生。这里把它们放在一起作比较，是想说明它们的能实现的作用相似，但是目的却不同。
当我们想给一个类增加行为时，通常想到的是继承。但我作为，继承最主要的作用是提供统一接口，而在功能扩展方面更推荐使用组合。
比如原本有一个类叫“羊”。但现在需要一个“会说话的羊”的对象，要怎么做呢？
我们很容易就想到一个解决方案：
这是一个继承的例子，就好比这种羊进化出一个新的具有speak行为的品种。
其实它还有一种实现方式，就是利用组合：
如果把继承比喻成进化，那么组合就可以这么解释：可以这么解释。这种羊还是不会说话，但是它得到了一个发声器，利用这个发声器的speak行为替羊说话。
多态
多态是这里面最抽象最难解释的概念，所以这里通过一个故事来说明：
大森林里要举行跑步比赛，小动物们都来的报名。
- PO：
大象：我是大象，我来报名。 管理员：好的，请你用大象跑步的方式参加比赛。
犀牛：我是犀牛，我来报名。 管理员：犀牛？应该是一种牛吧？请你用牛跑步的方式参加比赛。
小黄牛：我是小黄，我来报名。管理员：小黄是什么？没有“小黄跑步”这种跑步方式，你不能参加跑步比赛。
结局：大象完成了比赛。犀牛中途退赛了，因为牛的跑步方式不适合它。小黄牛没有参赛比赛。
- OO：
管理员：我不管你是什么动物，也不管你以什么方式跑步。只要你有跑步这种行为，你就可以参加比赛，并且以你自己的跑步方式跑步。
结局：大家都参加了比赛，且以自己的方式完成了比赛。
C++
C++在C的基础做了许多功能上的延伸，但是本文的主题是面向对象，其它方面就不作说明。C++作为一种面向对象语言，必然支持上述的面向对象特性。下面将用例子证明：
对象和类
class animal
{
string name;
public:
animal(string n):name(n){}
void introduce(){cout<<"my name is "<<name;}
void walk(){cout<<"default walk way"<<endl;}
};
class sheep : public animal
{
public:
sheep(string n):animal(n){}
void walk(){introduce();cout<<"walk like a sheep"<<endl;}
};
class human:public animal
{
public:
human(string n):animal(n){}
void walk(){introduce();cout<<"walk like a human"<<endl;}
};
void test()
{
sheep A("xiyangyang");
human B("xiaohuangren");
A.walk();
B.walk();
}
运行结果
my name is xiyangyangwalk like a sheep
my name is xiaohuangrenwalk like a human
在本例中：animal、sheep、human都是类，而是A和B对象。
继承
class animal
{
string name;
public:
animal(string n):name(n){}
void introduce(){cout<<"my name is "<<name;}
void walk(){cout<<"default walk way"<<endl;}
};
class sheep : public animal
{
public:
sheep(string n):animal(n){}
void walk(){introduce();cout<<"I walk like a sheep"<<endl;}
void speak(){introduce();cout<<"sorry, I can't speak"<<endl;}
};
class de_dao_gao_yang : public sheep
{
public:
de_dao_gao_yang(string n):sheep(n){}
void speak(){introduce();cout<<"I'm de dao gao yang, I can speak"<<endl;}
};
void test()
{
de_dao_gao_yang A("yang da xian");
A.speak();
A.walk();
sheep B("normal sheep");
B.speak();
B.walk();
}
运行结果：
my name is yang da xianI'm de dao gao yang, I can speak
my name is yang da xianI walk like a sheep
my name is normal sheepsorry, I can't speak
my name is normal sheepI walk like a sheep
在本例中，A羊通过继承实现了说话功能，B羊是普通羊，没有说话功能。但A和B的走路方式是一样的。
组合
class speaker
{
public:
void say_a_word(string word)
{
cout<<word<<endl;
}
};
class animal
{
string name;
public:
animal(string n):name(n){}
void introduce(){cout<<"my name is "<<name;}
void walk(){cout<<"default walk way"<<endl;}
};
class sheep : public animal
{
speaker *hu_die_jie_fa_sheng_qi;
public:
sheep(string n, bool can_speak = false)
:animal(n),hu_die_jie_fa_sheng_qi(NULL)
{
if(can_speak == true)
hu_die_jie_fa_sheng_qi = new speaker();
}
~sheep()
{
if(hu_die_jie_fa_sheng_qi != NULL)
delete hu_die_jie_fa_sheng_qi;
hu_die_jie_fa_sheng_qi = NULL;
}
void walk(){introduce();cout<<"I walk like a sheep"<<endl;}
void speak()
{
introduce();
if(hu_die_jie_fa_sheng_qi == NULL )
cout<<"sorry, I can't speak"<<endl;
else
hu_die_jie_fa_sheng_qi->say_a_word("this is a speaker, hello");
}
};
void test()
{
sheep A("xiyangyang", true), B("nuanyangyang");
A.speak();
A.walk();
B.speak();
B.walk();
}
运行结果
my name is xiyangyangthis is a speaker, hello
my name is xiyangyangI walk like a sheep
my name is nuanyangyangsorry, I can't speak
my name is nuanyangyangI walk like a sheep
在本例中，A羊通过组合实现了说话功能，B羊是普通羊，没有说话功能。但A和B的走路方式是一样的。
多态
class animal
{
string name;
public:
animal(string n):name(n){}
void introduce(){cout<<"my name is "<<name;}
virtual void walk(){cout<<"default walk way"<<endl;}
};
class sheep : public animal
{
public:
sheep(string n):animal(n) { }
void walk(){introduce();cout<<"I walk like a sheep"<<endl;}
};
class human : public animal
{
public:
human(string n):animal(n) { }
void walk(){introduce();cout<<"I walk like a human"<<endl;}
};
class monkey : public animal
{
public:
monkey(string n):animal(n) { }
void walk(){introduce();cout<<"I walk like a monkey"<<endl;}
};
class duck : public animal
{
public:
duck(string n):animal(n) { }
void walk(){introduce();cout<<"I walk like a duck"<<endl;}
};
class pig : public animal
{
public:
pig(string n):animal(n) { }
void walk(){introduce();cout<<"I walk like a pig"<<endl;}
};
void test()
{
animal * runner[5];
runner[0] = new sheep("xi yang yang");
runner[1] = new human("tai shan");
runner[2] = new monkey("kong kong");
runner[3] = new duck("tang lao ya");
runner[4] = new sheep("zhu ba jie");
for(int i = 0; i < 5; i++)
runner[i]->walk();
for(int i = 0; i < 5; i++)
delete runner[i];
}
运行结果：
my name is xi yang yangI walk like a sheep
my name is tai shanI walk like a human
my name is kong kongI walk like a monkey
my name is tang lao yaI walk like a duck
my name is zhu ba jieI walk like a sheep
在本例中，runner只是一个animal类型的指针，并不知道它实际指向的是什么动物（只有在开始实例化的时候知道，使用的时候是不知道的），但它仍然会调用具体动物类对应的行为。
面向对象设计原则
clean code的宣传者Uncle Bob提出了面向对象设计的五个原则，简称为SOLID。但在我看来，OO设计最重要的原则就是分析可能发生的变化以及如何响应变化。
SRP - Single responsibility principle（单一职责）
单一职责原则是指，一个类，只有一个原因引起它的改变。
先看这样一个类，它符合单一职责原则吗？
正如上文所说，在评价一个OO的设计是否合理时，一个很重要的前提就是推测变化。是在分析这个设计所对应的需求中，哪些地方是有很有可能发生变化的。没有这个前提的评价都是片面武断的。
在本例中，我们假设对于这个羊类来说，它支持哪些行为是容易发生改变的，它叫的方式也是容易发生改变的，那么这个类至于有两个原因导致它的修改，因此不符合单一职责原则。
我们可以怎么修改这个设计呢？一个很常用的方法就是封装变化。在这里我们把“叫”这个容易发生的行为封装起来，封装成另一个类speaker。这样，当发声的方式改变时，只需要修改speaker类就可以了。
OCP - Open-Closed Principle（开放封闭）
开放-关闭原则是指，对扩展开放而对修改关闭。也就是说，尽量通过不修改代码的方法能够扩展类的功能，这听起来有点奇怪，但如果设计得好，是可以做到的。比如上一个例子中，把发声的方法提取出来，那么就可以扩展发声的方法而不需要改变sheep类了。
在这次例子中，我们的需求又发生了变化。我们想要这只羊发出mou的声音，而其它（比如发声的频率、单调）则保持不变。我们很快想到了解决方案
LSP - Liskov Substitution Principle（李氏代换）
李氏代换是指，在任何可以使用基类的地方，都可以使用派生类代替它。这点似乎是理所当然，既然派生类继承基类，那么基类该有的行为派生类当然会有了，这有什么可说的呢？但是参考上面这个例子，虽然派生类继承了基类的所有行为，但不是说这些继承来的行为对于派生类都是有意义的。比如这个高级发声器，其实它并不支持mie这个行为，因此不满足李氏代换。怎么改进呢？考虑一下这个方案：
其实李氏代换，可以理解为基类对于派生类来说没有多余的接口。我们把mie和mou并列放置，并同时继承speaker，父类只是提供接口，而子类实现行为。
从这个例子可以看出，继承和组合虽然相似，却用法不同。继承通常中为了统一接口，而组合可用于扩展功能。
ISP - Interface Segregation Principle（接口隔离)
接口隔离：即使用客户端特定的细粒度接口。
在定义接口时，我们是定义一个大的接口呢还是定义多个小的接口好呢？在这里，我们推荐后者。
多个小接口也许会造成多个接口难以管理，但它带来的好处远多于它的缺点。
当一个接口很大，需要很多参数时，常常是为了适应多种情况。对于某些用例只用到这几个参数而有些用例只用到那几个。
假如某接口有参数A,B,C,D,E,F,G。但某个应用场景其实只用到A,B,C。那么当接口的参数D部分改变时，其实对是这个用例没有关系的。但用例不得不由于这种情况更改它的调用方式，这样不是合理的。
没有想到合适的例子。
DIP - Dependency Inversion Principle（依赖倒置）
依赖倒置是指，我们要依赖抽象而不是具体实现。因为OO最大的特点就是擅长于响应变化。上文说过，我们要封装变化。那么抽象和具体实现，哪个更容易变化呢？当然是具体实现。
在上面这个例子中，speaker是抽象，mie和mou是实现。sheep现在依赖的是speaker，因此不管我们使用的mie发声法还是mou发声法，对于sheep都没有影响，因此它符合依赖倒置原则。