面向对象

面向对象

• 面向过程编程:(Procedure Oriented)是一种以过程为中心的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是封装、继承、类。
• 面向对象编程（OOP)Object Oriented Programming
• 面向函数编程:(lisp)

(13+10)*2-10
a = 13+10
b = a*2
c = b-10

result = jian(multi(add(13,10),2),10)

思维导图：

以CS游戏中的角色为例，引入对象

role:警察，恐怖分子,人质

role1

name = "xxx"
role = "警察"
waepon="匕首"
life_value = 100
money=16000

role2

name = "xxx"
role="恐怖分子"
wepon="AK47"
life_value = 100
money=16000

role3

name = "xxx"
role="人质"
life_value = 100

def shot(user):
pass

警察类：

class Police:
    def get_info(self,name,role,life_value,weapon,money):
        self.name = name
        self.role = name

    def shot():
        pass

    def jiu():
        pass

class Kongbu:
    def shot():
        pass
    def sha():
        pass

class Renzhi:
    def get_info():
        pass

类的实例化：

gaowenrui = Police()
tanghao = Kongbu()
zhoumengyang = Renzhi()

• 面向对象编程将对象作为程序的基本单元，对象包含了数据和方法组成。
• 类：在python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）。
• OOP首选考虑的不是程序的执行流程，而是某个数据类型应该被视为对象，其拥有自己的属性和方法。
• 方法：在对象中的定义的函数，可操作对象的属性。

class People(object):
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
   ```
- __init__方法在创建实例时，将属性绑上去，self代表实例本身。
- 类的方法的第一个参数永远是实例变量self

    def marry(self):
        print "\t%s,%d岁,%s 开车去娶媳妇" % (self.name,self.age,self.gender)

    def cut(self):
        print "\t%s,%d岁,%s 上山砍柴" % (self.name,self.age,self.gender)

    def gohome(self):
        print "\t%s,%d岁,%s 辍学回家" % (self.name, self.age, self.gender)

laoli=People(“老李”,18,”男”)
xiao=People(“校思浩”,20,”男”)
tang=People(“唐浩”,10,”男”)

```
- 在调用类中的方法时不需要传递self参数
laoli.marry()
xiao.cut()
tang.gohome()

类的特性

• 封装性
• 继承性
• 多态性

封装性

• 封装是指向程序的其他部分隐藏对象的具体实现细节的原则。封装是可以不用关心对象是如何构建的而直接进行使用。

继承性

• 继承：对于面向对象来讲，就是将多个类共有的方法提取到父类中，而子类只需要继承父类的方法，不需要一一实现每个方法。
• 子类（派生类）、父类（基类）、经典类、新式类
  1).多继承
• python的类可以继承多个父类，Java和C#只能单继承；
• 继承多个类，有两种算法，深度优先和广度优先算法；
• 类为经典类(class C:)时，多继承时使用深度优先算法；
• 类为新式类(class C(C1,C2))时，多继承时使用广度优先算法；
  eg：D，C（D），B（D），A（B，C）
  深度优先：A->B->D->C
  广度优先：A->B->C->D

• 新式类：class D(object)： 经典类：class D：

• 新式类：

class D(object):
    def eat(self):
        print "D"

class C(D):
    def eat(self):
        print "C"

class B(D):
    def eat(self):
        print "B"

class A(B,C):
    pass

a=A()
a.eat()

去掉B中的eat方法，运行结果如下：

class B(D):
    # def eat(self):
    #     print "B"
    pass

• 经典类：

class D:
    def eat(self):
        print "D"

class C(D):
    def eat(self):
        print "C"


class B(D):
     def eat(self):
         print "B"

class A(B,C):
    pass

a=A()
a.eat()

运行结果：

去掉B中的eat方法，运行结果如下：

class B(D):
     # def eat(self):
     #     print "B"
    pass

多态性

• 多态体现在多继承时，可以对不同类的对象使用同样的操作。

• “鸭子类型“：当看到一只鸟走起来像鸭子，游泳起来像鸭子，叫起来也像鸭子，那么这只鸟就可以被称为鸭子。“鸭子类型“关注的不是对象的类型本身，而是它是如何使用的。

• 继承最大的好处是子类获得了父类的全部功能。

• 继承的另一个好处就是多态。子类中的方法和父类方法一样时，子类方法覆盖父类的方法。

获取对象的信息

• type()

a=A()
print type(a)
print type(A)

• isinstance()

class D(object):
    pass

class B(D):
    pass

class C(D):
    pass

class A(B，C)
    pass
a=A()
print isinstance(a,A|B|C|D)

- dir() #使用的是对象的继承关系来反馈一个对象的完整的有效属性。

a=A()
print type(a)
print type(A)
print dir(A)
print dir(a)
print a.__doc__
print a.__module__
print a.__class__

访问限制

• 类的私有变量，类内部可以访问，外界无法访问
  双下划线声明私有变量—-private
• 类的内部定义中，所有以双下划线开始的名字都被“翻译“成前面加上单下划线和类名的形式。
  1>可通过“实例._类名__方法|属性“进行访问

class C(object):
    def __eat(self):
        print "C"


class B(object):
    pass

class A(B,C):
    def fun(self):
        pass

a=A()
a._C__eat()

2>子类的属性增加时，需要通过 Animal.init(self,name,age)
和super(Cat, self).init(name,age)
两种方法来继承基类的属性。

class Animal(object):  # Animal:类，盖房的图纸
    def __init__(self, name, age):  # 构造函数，当实例化对象时自动调用，self实质是实例化后的对象本身
        self.__name = name  #__name是私有属性
        self.__age = age  # __age,私有属性

    def setName(self, name):
        self.__name = name

    def getName(self):
        print self.__name

    def __run(self): #__run,私有方法
        print "%s is running" % (self.__name)

    def eat(self):
        print "%s is eating......" % (self.__name)

    def __del__(self): #析构函数，删除实例化对象时自动调用
        print "is delete......."


class Cat(Animal):  
    def __init__(self,name,age，color):
        Animal.__init__(self,name,age)
        #super(Cat, self).__init__(name,age)
        self.color = color

    def eat(self):
         print "%s is eating fish....." %(self._Animal__name)

    pass


class Dog(Animal):
    pass


tom = Cat("fentiao", 6)
print tom._Animal__name
tom.eat()
tom._Animal__run()