面向對象：減少重復代碼，提高效率，比函數式編程更高效

類的創建：

實例屬性又稱：成員變量，成員屬性（或者字段）

面向對象的三大特性：

一、封裝

把客觀事物封裝為抽象的類，並對外只暴露一個可用接口

使用構造方法將內容封裝到對象中，可通過對象直接或者通過self間接獲取被封裝的內容

# 創建類
class Foo(object):
    def __init__(self, name, age):    # 構造方法，根據創建的對象自動執行
        self.name = name
        self.age 
 
= age

    # 類中的方法A
    def A(self):
        Foo.name = ‘yeeh‘
        print(‘hello!‘, self.name)
        print(‘hello!‘, Foo.name)

    # 類中的方法B
    def B(self):
        print(‘word!‘,self.age)


obj = Foo(‘Vera‘, 18)
obj.age = 12
obj.A()
obj.B()

hello! Vera
hello! yeeh
word! 12

二、繼承

子類擁有父類的全部方法，也可以對父類方法進行重寫，並且可以定義自身的方法（一般到特殊，父類定義一些公共的方法，子類可定義自身特殊的方法）

• 註：Python中一個子類可以繼承多個父類

對於實例屬性要進行 ：先重寫，再繼承

# 父類
class People(object):
    number = 0

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.drink()       # 因為繼承，所以調用的時候，都會打印drink ()裏的東西

    def eat(self):
        print(‘都可以吃東西！
 
‘)

    def drink(self):
        People.number += 1
        print(‘[%s].[%s] 的年齡是[%s]‘ % (People.number, self.name, self.age))

# 子類1
class good_person(People):
    def __init__(self, name, age, sex, goodness):          # 先重寫
        super(good_person, self).__init__(name, age, sex)    # 再繼承
        self.goodness = goodness

    def good_ness(self):
        print(‘善良的[%s]做好事‘ % self.name)

# 子類2
class bad_person(People):
    def __init__(self, name, age, sex, sourness):
        super(bad_person, self).__init__(name, age, sex)
        self.sourness = sourness

    def bad_ness(self):
        print(‘壞人[%s]做壞事！‘ % self.name)


g1 = good_person(‘花花‘, 23, ‘女‘, ‘做好事‘)    # 實例化後因為父類的繼承，所以直接會打印drink()
g1.good_ness()
b1 = bad_person(‘李剛‘, 33, ‘男‘, ‘做了壞事‘)  
b1.bad_ness()
b1.eat()      # 繼承會繼承父類的所有方法

[1].[花花] 的年齡是[23]
善良的[花花]做好事
[2].[李剛] 的年齡是[33]
壞人[李剛]做壞事！
都可以吃東西！

註：

新式類 繼承的寫法：super（Teacher，self）.__init__(name,age,sex) # 利用關鍵字super

舊式（經典）類 繼承的寫法：SchoolMember.__init__(self,name,age,sex)

多繼承：

• 在3.0裏及以後多繼承的經典類和新式類都是采用的廣度優先原則
• 在3.0以下的版本，經典類和新式類就有深度和廣度的區分

經典類：class A: 深度優先：繼承了上一級裏沒有這個方法就直接到上一級的上一級去尋找，找到始祖沒有找到，再從繼承的上一級尋找再到它的始祖

新式類：class A(object): 廣度優先 ：繼承的上一級，從左到右依次尋找繼承的類裏有沒有那個方法，如果沒有才再尋找上一級的上一級所繼承的

class A(object):
    def f1(self):
        print(‘我是 A‘)


class B(A):
    def f2(self):
        print(‘我是 B‘)


class C(A):
    def f3(self):
        print(‘我是 C‘)


class D(B, C):
    def f4(self):
        print(‘我是 D‘)


d = D()
d.f1()      # D->B->C->A
d.f2()      # D->B
d.f3()      # D->B->C
d.f4()      # D

class A:
    def f1(self):
        print(‘我是 A‘)


class B(A):
    def f2(self):
        print(‘我是 B‘)


class C(A):
    def f3(self):
        print(‘我是 C‘)


class D(B, C):
    def f4(self):
        print(‘我是 D‘)


d = D()
d.f1()      # D->B->A
d.f2()      # D->B
d.f3()      # D->B->A->C
d.f4()      # D

我是 A
我是 B
我是 C
我是 D

三、多態

多態：當子類和父類都存在相同的方法時，子類的 方法 覆蓋了父類的方法，在代碼運行時，會調用子類的方法（一種調用方式，擁有不同的執行效果），把接口進行統一但（外部調用，內部可以直接轉換到相應方法下）

class Animal(object):
    def func(self):
        print(‘這是Animal。。‘)

    def print_func(slef, animal):    # 不知道這裏對不對。。
        animal.func()
        
        
class dog(Animal):
    def func(self):
        print(‘這是dog。。‘)


class pig(Animal):
    def func(self):
        print(‘這是pig。。‘)

    def run(self):
        print(‘這是pig中的run....‘)


A = Animal()
d = dog()
p = pig()

A.print_func(Animal())   # 對外只暴露一個接口，但是可以直接打印多個不同的東西
A.print_func(dog())
A.print_func(pig())

這是Animal。。
這是dog。。
這是pig。。

Python_面向對象_類1