面向对象【第1篇-面向对象设计】

面向对象

什么是对象

对象如果要思考的话应该是我们对任何事物的一个抽象的说明，举个例椅子我们可以说是一个对象，桌子也可以是个对象。但是这些都是我们看得见或者摸得着的东西！

在软件开发中对象的定义也没多大区别也是形容或者描述"东西"，正式的讲：对象是一个数据以及相关行为的集合。

（举个例子我们来描述下椅子这个对象：

数据：长40厘米，宽50厘米，高100厘米

方法：可以坐下，可以打人，可以吃饭，可以睡觉....

）

什么是面向对象

面向对象的简单的意思就是指向，所以面向对象的简单意思就是"功能上指向建模对象（某个功能指向对象比如写入数据库功能指向某个对象）"

面向对象中的术语

经常搞混的：面向对象分析、面向对象设计、面向对象分析设计、面向对象编程这些术语都是TMD什么意思？

面向对象分析（OOA Object-Oriented Analysis）：

着眼于一个问题、系统或者任务的过程，并且识别这些对象以及对象间的交互。分析我们都要做什么，把一个网站（分析的对象），变成一个需求

最后需求出来：

订单查看

订单取消

产品订购

面向对象设计（OOD Object-Oriented Design）：

把需求转换为实践规范的过程，比如命名这些对象（命名）、定义行为（方法）、定义接口~

面向对象编程（OOP Object-Orientd programming）：

是把设计转化成一个可以工作的程序的过程（写代码的过程）

但是实际上，在这个快节奏的世界，大部分开发刚好是一个"迭代式开发模型"。在迭代式开发中，会先模块化、设计和编程实现任务重的小部分，然后评估这个程序并通过扩展来改善每一个特性，包括在一系列短的周期里增加新的特性

面向对象编程特性

重新理解一下 封装、继承、和多态

封装

学面相对象的时候我们知道分装就是把：数据、方法封装到一个对象中。那封装的作用是什么？

用一句话概括：隐藏细节提供公共接口（隔离复杂度）

举个非常形象的例子，看电视的时候我们通过遥控器调节：节目数字、电视音量、声道等信息，遥控器就是电视这个对象提供的接口，操控方法（节目数字、音量大小、）,电视机的属性（品牌、大小、等信息）

这里电视给我们提供的统一接口你只要按遥控器就可以了，根本不需要管它是怎么实现信号传输、音量的大小、节目的调节的。

class Television(object):
def __init__(self, master):
self.master = master

def add_show(self):
print('%s操作当前节目ID加1' % self.master)

def subtract_show(self):
print('%s操作当前节目ID减1' % self.master)

def add_volume(self):
print('%s操作当前电视音量加1' % self.master)

def subtract_volume(self):
print('%s操作当前电视音量加1' % self.master)

我们操作电视的时候，只需使用提供的这几个接口，具体内部怎么实现的我们不需要关心。

继承

接下来看下继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

组合

组合的概念：

眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生（继承）而成。



举例来说：

class Eye(object):
def __init__(self, person):
self.person = person

def look(self, something):
print('%s look %s' % (self.person, something))

class Head(object):
def __init__(self, name, age):
self.name = name
self.age = age
# 通过组合的方式吧Eye类里的方法组合起来
self.eye = Eye(self.name)

def look(self, something):
self.eye.look(something)

........

继承

先看一个接口的定义：创建一个没有实现任何放的类，这个类简单的告诉我们这个类该做什么，但是绝对没有提供任何建议告诉我们如何去做，在面向对象的世界里这样的的类称之为接口。

继承的概念就想一个家庭图谱，比如你父亲从你爷爷那里继承了姓氏（罗）你从你父亲那里继承了姓氏（罗），这种关系称之为继承。

多重继承

举个例子说就是你继承了你父亲眼睛的颜色，又继承了你母亲头发的颜色，这种在一个类中继承多个类的情况称之为：多重继承

但是只要两个类有不同的借口，对于一个多重继承是无害的，但是如果我们从两个重叠借口继承就会变得很差。比如你继承了"汽车类"又继承了"摩托车"类，它们都有一个move方法，当你调用move方法的时候，这个合成类到底该怎么做呢！

通常这种设计是错误的，出现这种情况看看是否可以把多重继承删掉，采用类似关联或者组合的设计

多态

我们可以说：

封装的作用是简化代码复杂度

继承的作用是增加代码重用性

那多态的作用呢？

多态的作用是增加接口重用性

先看一个接口的定义：创建一个没有实现任何放的类，这个类简单的告诉我们这个类该做什么，但是绝对没有提供任何建议告诉我们如何去做，在面向对象的世界里这样的的类称之为接口。

# !/usr/bin/env python3.5
# -*- coding:utf-8 -*-
# __author__ == 'LuoTianShuai'

import abc

# 定义交通工具类
class Vehicle(object):
# 基类定义接口使用abc强制约束子类必须重写move这个类
@abc.abstractmethod
def move(self):
pass

# 给他的意义他能让乘坐它的人去某个地方

class Car(Vehicle):
def __init__(self, car_name):
self.car_name = car_name

def move(self):
print('%s正在移动.....' % self.car_name)

class Subway(Vehicle):
def __init__(self, line_name):
self.line_name = line_name

def move(self):
print('%s正在移动.....' % self.line_name)

"""
父类定义接口，子类实现，然后统一调用，只要你实现了这个接口谁管你是怎么实现的，但是都是统一调用接口
只要这个工具能动、能运输人 我们就称他为交通工具
"""

benz = Car('Benz')
line10 = Subway('Beijing Subway line 10')

benz.move()
line10.move()

但是Python本身就是一们多态的语言动态语言，在Python中你很少听说多态的概念，在Python中的多态性通常称为鸭子类型：当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子

在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为鸭的对象，并调用它的走和叫方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的走和叫方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的走和叫方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。

# coding=utf-8
class Duck(object):
def quack(self):
print("鸭子在嚎叫")

class Swan(object):
def quack(self):
print("天鹅在嚎叫")

class Goose(object):
def quack(self):
print("鹅在嚎叫")

def in_the_forest(duck):
duck.quack()

duck_obj = Duck()
bird_obj = Swan()
doge_obj = Goose()
for x in [duck_obj, bird_obj, doge_obj]:
in_the_forest(x)