第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