java程序员的python之路（面向对象）

面向对象

什么是面向对象？和面向对象对应的就是面向过程，过程就是函数，面向过程考虑的是当前正在发生什么事情？主要表现就是定义了一个个的函数，通过函数的调用来组织程序。
而面向对象，考虑的是“谁”当前正在发生什么事情？“谁”就是对象。主要表现就是定义一个个的对象，通过对象之间的关系来组织程序。
说的比较笼统，不懂的还是不懂。python是一门面向对象的语言，面向对象有三个基本要素，继承，封装，多态。

对象

什么是对象？万物皆对象。人，山，空气等都是对象。但对象并不只包含万物，对象可以是抽象的，比如：思想。
现在我们拿鸟来简单的说一下。我们平时说到鸟的时候，其实就是泛指鸟类，是我们把一些飞禽抽象出来的一种概念。是一类动物
并不是单指一个，这就是面向对象中类的概念。而当我们说你看那只鸟好漂亮的时候，那只鸟就是特指某一只鸟，这只鸟就是对象。
我们把鸟的公共的特性和行为综合起来封装到一起就构成了鸟类。老鹰会飞，它生的孩子也会飞。鸵鸟会跑，它生的孩子也会跑。用一句话说“龙生龙，凤生凤，老鼠的孩子会打洞”，这叫做继承。上面我们简单地说了一下，类，对象以及封装和继承的概念，还有一个重要的概念就是多态，这个我们只能从程序中慢慢理解。

基本术语

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 实例变量（成员变量）：定义在方法中的变量，只作用于当前实例的类。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

创建类和对象

定义类的格式如下：

 class ClassName:
     <特性>
     <行为>

下面我们定义一个鸟类,并且让它有一个可以飞的方法（函数），如下：

class Bird:
    def fly(self):
        print("I fly")

上面我们创建了一个鸟的类，并定义了一个fly方法（成员方法），此方法有一个参数self，表示当前对象的意思。那么我们怎么创建这个类的对象，并且让它飞呢？如下：

bird = Bird()
bird.fly(

输出结果：

I fly

我们通过类名和一对括号来创建一个鸟类的对象，并把这个对象赋值给bird引用，然后使用bird引用调用鸟类的fly方法。

构造方法

构造方法是用来创建对象使用的，可以让我们使用一些参数来实例化一个对象（创建一个对象）,构造方法在创建对象的时候会自动执行。
现在我们要给我们的鸟类添加一个特性（成员变量）颜色，别想希望在创建
对象的时候指定颜色，那么我们就需要用到构造函数，构造函数的结构是固定的，如果父类和子类都重新定义了构造方法_init( )_，
在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用。如下：

 def __init__(self):
     self.data = []

下面我们重新编写鸟类，添加构造方法和成员变量，代码如下：

class Bird:
    #构造方法
    def __init__(self,c):
        print("Bird init")
        #成员变量
        self.color = c

    #成员方法
    def fly(self):
        print("I can fly.")    

    #成员方法
    def getColor(self):
        print("I am %s color." % self.color)

#创建对象,为构造函数传递参数red
bird = Bird("red")
#调用方法
bird.fly()
#访问成员变量
print(bird.color)

输出结果如下：

Bird init
I can fly.
red

通过上面的代码，我们看到，我们可以使用对象引用加上“.”的方式访问对象的方法和属性。

继承

继承的结构如下：

class ChildClass(BaseClassName1):

现在我们需要一个鸵鸟的类，并希望它有一个奔跑速度的特性和奔跑的方法，让鸵鸟的类继承鸟类；

class Ostrich(Bird):

    #构造函数
    def __init__(self,c,s):
        #调用父类Bird1的构造方法
        #子类的构造方法必须调用父类的构造方法，且必须在构造方法的第一行。
        Bird.__init__(self, c)

        #成员变量
        self.runSpeed = s

    #成员方法        
    def run(self):
        print("I can run,speed is %i km/h" % self.runSpeed)

ostrich = Ostrich("gray",100)
ostrich.fly()
ostrich.run()
print(ostrich.color)
print(ostrich.runSpeed)

输出结果如下：

Bird init
I can fly.
I can run,speed is 100 km/h
gray
100

我们可以看到鸵鸟类的对象可以访问fly方法以及color属性，但是鸵鸟类中并没有color和fly方法，这是是从Bird类中继承来的。这里我们就看到了继承的强大之处。但是有个问题，我们都知道鸵鸟是不会飞的。那么我们需要重新实现一个Bird1的fly方法，这个过程我们称作重写。
代码如下：

class Ostrich(Bird):

    #构造函数
    def __init__(self,c,s):
        #调用父类Bird1的构造方法
        #子类的构造方法必须调用父类的构造方法，且必须在构造方法的第一行。
        Bird.__init__(self, c)

        #成员变量
        self.runSpeed = s

    #成员方法        
    def run(self):
        print("I can run,speed is %i km/h" % self.runSpeed)

    #重写父类fly方法        
    def fly(self):
        print("I can not fly")

输出结果如下：

Bird init
I can not fly
I can run,speed is 100 km/h
gray
100

另外python中支持多继承，多重继承需要用逗号把父类分开。看下面代码：

class Animal:
    def howl(self):
        print("I can howl")

    def run(self):
        print("I can not run")
    #多重继承        
class Chicken(Animal,Ostrich):
    def __init__(self,c,s):
        Ostrich.__init__(self, c,s)


chiken = Chicken("green",10);
chiken.fly()
chiken.run()
chiken.howl()        

输出结果如下：

Bird init
I can not fly
I can not run
I can howl

需要注意的是，如果多个类中有相同的方法，那么写在前面的父类会覆盖后面父类的方法。

私有

上面的类中的属性和方法，在类外都可以通过点的方式来调用。为了保证封装性以及安全，某些属性和方法要禁止外部访问。python中双下划线开始的属性和方法是私有的，外部不能直接访问，如下例：

class Duck(Bird):
    def __init__(self,c,swi):
        Bird.__init__(self, c)
        self.__swim = swi

    def swimm(self):
        if self.__swim:
            print("I can swim")
        else:
            print("I can not swim")

    def __setSwim(self,swim):
        self.__swim = swim
duck = Duck("write",True)
duck.swimm()    
duck.__setSwim(False)
print(duck.__swim)        

输出结果：

Bird init
I can swim
Traceback (most recent call last):
  File "E:\workspace-python\firstpython\src\first.py", line 36, in <module>
    duck.__setSwim(False)
AttributeError: 'Duck' object has no attribute '__setSwim'

报错，说明爽下划线开始的成员变量和成员方法，不能在外部访问。

类属性，静态方法，类方法

类属性是直接写在类中的属性，此类的多个成员共享一份类属性，成员方法和类型发可以访问类属性，类方法和静态方法可以直接通过类名来访问，代码如下：

class Static:
    #类属性，多个实例对象共享此属性值
    static_property = "static_property"

    def __init__(self,s):
        self.member_property = s #成员属性，对象独享此属性值


    #静态方法，通过类型直接访问
    @staticmethod
    def staticMethod():
        print("staticMethod")

    #类方法，通过类型直接访问，可访问类属性
    @classmethod
    def classMethod(cls):
        print(cls.static_property)

    #成员方法，通过对象访问        
    def memberMethod(self):
        print("memberMethod")


static1 = Static("aaaaaa")    
static2 = Static("bbbbb") 
print(static1.member_property)
print(static2.member_property)   
print(Static.static_property)
Static.staticMethod()
Static.classMethod()

输出结果如下：

aaaaaa
bbbbb
static_property
staticMethod
static_property

多态

python是弱类型的语言，多态的表现不是那么明显。多态的实现叫做动态绑定，也叫后期绑定,也就是说
直到运行的时候，才确定要执行的是哪个对象的方法。python也是支持多态的,
多态的表现就是一个引用，在赋予不同的对象时表现出不同的行为。看下面的代码：

class Animal:
    def eat(self):
        print("I eat everything")


class Fish(Animal):
    def eat(self):
        print("I eat water")

class Sheep(Animal):
    def eat(self):
        print("I eat grasses")        


#定义函数，接收一个animal的参数    
def eatWhat(animal):
    animal.eat()


animal = Animal()    
fish = Fish()    
sheep = Sheep()    

eatWhat(animal)            
eatWhat(fish)            
eatWhat(sheep)

输出结果为：

I eat everything
I eat water
I eat grasses