面向对象基础

什么是面向对象

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

值得一提的是在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崇尚“鸭子类型”。