面向對象編程

第1章 面向對象編程介紹：

1.1面向對象的程序設計：

核心就是對象二字，基於該思想編寫程序就好比在創造一個世界，世界都是由一個個對象組成，你就是這個世界的上帝

優點：具有高擴展性

缺點：設計開發較爲複雜

1.2如何用面向對象寫程序：

對象是特徵與技能的結合體，類則是一系列特徵的結合體

總結類與對象必須站在一個特定的角度，面向對象的程序設計並不是全部，對於一個軟件質量來說，面向對象的程序設計只是用來解決擴展性

應用場景：

需求經常變化的軟件，一般需求的變化都集中在用戶層，互聯網應用，企業內部軟件，遊戲等方面都是面向對象程序設計大顯身手的好地方

第2章 類與對象

2.1什麼是類？

類即類別，種類，是面向對象設計最重要的概念，對象是特徵與技能的結合體，而類則是一系列對象相似特徵與技能的結合體

2.2定義類：

class OldboyStudent:
    school='jiang'
    defchoose_course(self):
        print('nihao')

print(OldboyStudent.school)

類體代碼在類定義階段就會立即運行，會產生類的名稱空間，用來將類體代碼運行過程中產生的名稱空間存放起來

2.3類的用途：

1.    類的本質就是一個名稱空間，所以第一種用途就是使用其內部的名字，類名.名字

OldboyStudent.school='wang'#修改類中數據信息
print(OldboyStudent.school)
del OldboyStudent.school#刪除類中數據信息
OldboyStudent.sss='hello'#在類中增加變量
print(OldboyStudent.sss)
print(OldboyStudent.__dict__['school'])

2.    調用類來產生對象，對象的本質也是名稱空間

class OldboyStudent:
    school='jiang'
    defchoose_course(self):
        print('nihao')

stu1=OldboyStudent()
stu2=OldboyStudent()
print(stu1)
print(stu2)

第3章 對象的初始化與init方法

給不同的對象，定義不同的特性

方法一：

class OldboyStudent:
    school='jiang'
    defchoose_course(self):
        print('nihao')

stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()
stu1.name='王大炮'
stu1.age=18

stu2.name='王二炮'
stu2.age=20

方法二：

class OldboyStudent:
    school='jiang'
    defchoose_course(self):
        print('nihao')

stu1=OldboyStudent()
stu2=OldboyStudent()
def init(obj,name,age):
    obj.name=name
    obj.age=age

init(stu1,'王大炮',18)
init(stu2,'王二炮',20)
print(stu1.__dict__)
print(stu2.__dict__)

方法三：

class OldboyStudent:
    school='oldboy'

    def__init__(self,name,age):
        self.name=name
        self.age=age

    defchoose_course(self):
        print('choosing course')

stu1=OldboyStudent('王大炮',18)
stu2=OldboyStudent('王二炮',20)
print(stu1)
print(stu2)

3.1總結類在調用階段發生的事：

1.    會產生一個空對象

2.    會觸發類的函數__init__的運行，將空對象連同調用時括號內的參數一同傳入

第4章 屬性查找

類有兩種屬性：數據屬性和函數屬性

4.1類的數據屬性是所有對象共享的

print(id(OldboyStudent.school))

print(id(stu1.school))
print(id(stu2.school))

4430681512

4430681512 

4430681512

4.2類的函數屬性是綁定給對象用的（稱爲綁定方法）

誰來調用就會將誰當作第一個參數傳入

print(OldboyStudent.choose_course)

print(stu1.choose_course)
print(stu2.choose_course)

<function OldboyStudent.choose_course at 0x107c8fd90>

<bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x107c79f98>>

<bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x107d539e8>>

4.3練習：類每進行實例化一次，都進行計數

class HelloStudent:
    school='jiang'
    count=0

    def __init__(self,name,gender,age):
        HelloStudent.count+=1
        self.name=name
        self.gender=gender
        self.age=age

    def choose_course(self):
        print('nihao')

stu1=HelloStudent('jiang','男',12)
print(HelloStudent.count)

4.4python3中統一了類與類型的概念

print(HelloStudent)
print(list)
print(dict)

<class '__main__.HelloStudent'>

<class 'list'>

<class 'dict'>

第5章 繼承與派生

5.1什麼是繼承？

繼承是一種新建類的方式，新建的類稱爲子類/派生類，被繼承的類稱爲父類/基類

繼承描述的是一種遺傳的關係，父類的屬性可以被子類訪問到

5.2爲何要用類？

解決類與類之間代碼冗餘的問題

5.3繼承的基本形式：

class stu1:
    pass

class stu2:
    pass

class func1(stu1):
    pass

class func2(stu1,stu2):
    pass
print(stu1.__bases__)
print(func1.__bases__)

5.4繼承的特點：

1.     在python中一個子類可以同時繼承多個父類

2.     在python3中如果一個類沒有指明繼承關係，默認繼承object類

5.5繼承條件下的屬性查找

在單繼承背景下的屬性查找：

class Foo:
    deff1(self):
        print('Foo.f1')
    deff2(self):
        print('Foo.f2')
        self.f1()#obj.f1()
class Bar(Foo):
    deff1(self):
        print('Bar.f1')

obj=Bar()#obj=f1
obj.f2()

在多繼承背景下的屬性查找：

mro方法：顯示類的繼承關係

print(HelloTeacher.mro())

[<class '__main__.HelloTeacher'>, <class '__main__.Hello'>, <class 'object'>]

這裏以C作爲起始出發的屬性查找，但是C類中沒有test屬性，按照mro列表繼續往後找，找打A類時，執行了super方法，而super方法會按照父類的屬性來進行查找，所以找到了B類中的test屬性

class A:
    deftest(self):
        super().test()
class B:
    deftest(self):
        print('from B')
class C(A,B):
    pass

obj=C()
obj.test()

5.6在子類派生的新方法中重用父類的功能：

方式一：指名道姓的訪問某一個類的函數，完全不依賴於繼承

class OldboyPeople:
    school='oldboy'
    def__init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender

class OldboyStndent(OldboyPeople):
    defchoose(self):
        print('%s is choosing course')

class OldboyTeacher():
    def__init__(self,name,age,gender,level):
        OldboyPeople.__init__(self,name,age,gender)
        self.level=level
    defscore(self,stu,num):
        stu.score=num
        print('老師')

tea1=OldboyTeacher('egon',18,'male',10)
print(tea1)

方式二：依賴繼承的方式

class OldboyPeople:
    school='oldboy'
    def__init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender

class OldboyStndent(OldboyPeople):
    defchoose(self):
        print('%s is choosing course')

class OldboyTeacher(OldboyPeople):
    def__init__(self,name,age,gender,level):
        super(OldboyTeacher,self).__init__(name,age,gender)
        self.level=level
    defscore(self,stu,num):
        stu.score=num
        print('老師')

tea1=OldboyTeacher('egon',18,'male',10)
print(tea1)

第6章 組合多態封裝

6.1什麼是組合？

某一個類的對象具備一個屬性，該屬性的值是另外一個類的對象

class Hello:
    school='jiang'

    def __init__(self,name,gender,age):
        self.name=name
        self.gender=gender
        self.age=age

class Course:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class HelloStudent(Hello):
    def choose_course(self):
        print('nihao')

class HelloTeacher(Hello):
    def __init__(self,name,gender,age,level):
        super().__init__(name,gender,age)
        self.level=level

    def score(self,stu,num):
        stu.score=num
        print('老師%s爲學生%s打了多少分%s' %(self.name,stu.name,num))

tea=HelloTeacher('jiang','nan',21,1)
print(tea.__dict__)
python=Course('pythonq全棧','1000','3mons')
tea.course=python
print(tea.course.__dict__)

6.2多態

6.2.1什麼是多態？

同一事物的多種形態

6.2.2爲何要用多態？

可以在不用考慮一個對象具體的類的前提下，直接調用對象下的方法（參照父類，父類有了，子類一定有）

6.2.3如何用多態？

class Animal:
    def speak():
        pass

class Pelple(Animal):
    def speak():
        print('jiaojiaojiao')

class Dog(Animal):
    def speak():
        print('wangwangwang')

class Pig(Animal):
    def speak():
        print('henghengheng')

obj1=Pelple()
obj2=Dog()
obj3=Pig()

規定子類中必須存在某種固定的方法：

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod
    def speak():
        pass