[Python笔记]第十一篇:面向对象

以上就是本节对于面向对象初级知识的介绍，总结如下：

• 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
• 类 是一个模板，模板中包装了多个“函数”供使用
• 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
• 面向对象三大特性：封装、继承和多态

面向对象基础

什么是面向对象

面向对象有别于传统的面向过程变成,是对一个具体事物的抽象描述,在用编程中的可以提高程序员的工作效率,

值得一提的是在python里面不想Java等语言强制程序员使用面向对象编程,可以采用面向对象和函数混合的

方式进行.

创建类和对象

下面我们来创建一个最基本的类,这个叫做Foo的类:

class Foo:
    def __init__(self, name, favor):
        self.name = name    # 普通字段
        self.favor = favor
    def intro(self):
        print("%s like eat %s" % (self.name, self.favor))

# 类创建对象时候就传入了参数 到构造方法
bob = Foo("Bob", "apple")
sam = Foo("Sam", "orange")

# 执行类方法时候不需要传参数了
bob.intro()
sam.intro()

类名字定义是由class关键字空格加类名字Foo加冒号组成;

这个类里面有两个def开头的像是函数一样的东西,我们叫做它"方法";

这个类里面有一个"__init__"的特殊方法我们叫做它"构造方法";

而另外一个def开头的方法则叫做普通方法;

类的实例化是有一个对象名字加等号类的名字加上一个括号,括号里面是我们需要传入的参数;

类的执行是对象名字加一个点加上类里面的方法加一对括号;

类是对事物的抽象化

对象是类的实例化

　　

面向对象三大特征

1.封装

封装就是:我们定义的类必然要生成不同的对象,封装就是封装那些不重复的类都要使用的字段

class Foo:
    # 构造方法里面的所有成员叫做普通字段
    # 在根据类创建对象的时候自动执行
    def __init__(self, name, favor):
        self.name = name    # 普通字段
        self.favor = favor


# 根据Foo类创造对象
# 自动执行Foo类的__init__方法
bob = Foo("Bob", "apple")

　　

self 是一个形式参数，当执行 bob = Foo("Bob, "apple") 时，self 等于 bob

                            当执行 sam = Foo("Sam", "orange") 时，self 等于 sam

所以，内容(name/favor)其实被封装到了对象bob 和 sam 中，每个对象中都有 name 和 age 属性.

那么封装的内容我们如何调用呢?

　　直接调用:通过 对象.方法调用　

class Foo:
    def __init__(self, name, favor):
        self.name = name    # 普通字段
        self.favor = favor

bob = Foo("Bob", "apple")
print("%s like eat %s" % (bob.name, bob.favor))

　　

　　间接调用:通过self间接调用内容

class Foo:
    def __init__(self, name, favor):
        self.name = name    # 普通字段
        self.favor = favor

    def show_detail(self):
        print("%s like %s" % (self.name, self.favor))

bob = Foo("Bob", "apple")
bob.show_detail()

　　

 有一个同学叫小明,他年龄5岁体重90斤,做一次健身体重减轻,吃一次东西会相应增肥:

class Person:
    # 构造方法
    def __init__(self, name, age, weight):
        # 普通字段
        self.Name = name
        self.Age = age
        self.Weight = weight
    # 方法
    def chidongxi(self):
        self.Weight += 2

    def jianshen(self):
        self.Weight -= 1

p1 = Person('小明', 5, 90)  # 实例化出一个类,包含基本信息(姓名/年龄/体重)
p1.jianshen()    # 执行健身方法减重
p1.chidongxi()  # 执行吃东西方法增肥
p1.chidongxi()
p1.chidongxi()
p1.jianshen()
print(p1.Weight)    # 查看最终体重

2.继承

单一继承

狗和猫都属于动物类,动物都有吃东西喝水的动作,然而狗却是汪汪叫,猫是喵喵叫;所以创建狗和猫两个类之前可以创建一个叫做动物的基类,

让动物拥有吃东西喝水的方法,让狗和猫继承动物的一些基本方法,这样创建其他动物时候就只要创建它们特殊的方法就ok了!

#!/usr/bin/env python
# -*- coding: utf-8 -*-


class Animals:
    def chi(self):
        print(self.name + "吃东西")

    def he(self):
        print(self.name + "喝水")


class Dog(Animals):
    def __init__(self, name):
        self.name = name

    def jiao(self):
        print(self.name + "旺旺叫")


class Cat(Animals):
    def __init__(self, name):
        self.name = name

    def jiao(self):
        print(self.name + "喵喵叫")


zhaocai = Dog("招财")
zhaocai.chi()
zhaocai.he()
zhaocai.jiao()


xiaomi = Cat("小咪")
xiaomi.jiao()

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。

多继承

继承的顺序: 查找自身 ---- 继承类(左边----右边)

经典类/新式类多继承情况下的两种查找顺序:

• 经典类时，多继承情况下，按照深度优先方式查找
• 新式类时，多继承情况下，按照广度优先方式查找

 

#!/usr/bin/env python
# -*- coding: utf-8 -*-


class God:
    def bar(self):
        print 'God.bar'


class A(God):
    def ba(self):
        print 'A.bar'


class B(God):
    def bar(self):
        print 'B.bar'


class C(A):
    def ba(self):
        print 'C.bar'


class D(B):
    def ba(self):
        print 'D.bar'


class E(C, D):
    def ba(self):
        print 'E.bar'


e = E()
e.bar()

#!/usr/bin/env python
# -*- coding: utf-8 -*-


class God(object):
    def bar(self):
        print 'God.bar'


class A(God):
    def ba(self):
        print 'A.bar'


class B(God):
    def bar(self):
        print 'B.bar'


class C(A):
    def ba(self):
        print 'C.bar'


class D(B):
    def ba(self):
        print 'D.bar'


class E(C, D):
    def ba(self):
        print 'E.bar'


e = E()
e.bar()

#B.bar

总结:

　　python2.7未继承object时(经典类),则深度搜索优先(一条道走到黑).

　　python2.7继承object(新式类),则广度搜索优先,顶部(指共同继承一个基类)最后.

　　python3里面只有新式类,执行广度优先

3.多态

 Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。