面向对象2

昨日内容

编程思想

面向过程编程

按照固定步骤解决已知问题
如 注册功能 登录功能 购物车功能

面向对象编程

创建独立的对象 在需要的时候使用解决
解决一些无法预知未来的问题

对象与类的概念

对象

对象是数据与功能的结合体

类的概念

类是多个对象 相同数据和功能的结合体

对象与类的创建

# 类使用关键字 class创建
class Student:
    # 多个对象共用的数据 如：
    school = '老男孩'
    # 多个对象共用的功能 如：
    def eat(self):  # 这里的self是通过类创建的 正在使用该方法的 对象
        print('吃放啦')
"""
1.class是定义类的关键字
2.类名建议首字母大写
3.类体代码在类定义阶段就会执行
"""

# 对象通过 类() 的方式创建
stu1 = Student()

# 类或者对象获取内部数据和方法有一个特殊的语法>>>:句点符
print(stu1.school)  # 老男孩
stu1.eat()  # 吃放啦  这里不用输入参数 因为默认将 stu1这个对象 放入了 eat(self) 的self中

对象的独有数据

class Student:
    school = '老男孩'
stu1 = Student()
print(stu1.school)  # 老男孩
# 1.自己调用__dict__添加键值对
stu1.__dict__['school'] = '老女孩'
stu1.__dict__['name'] = 'jason'
print(stu1.school)  # 老女孩
print(stu1.name)  # jason
# 2.封装成一个固定的函数
def init(obj, name):
    obj.name = name  # obj.name 等价于 obj.__dict__['name']

stu2 = Student()
init(stu2, 'kevin')
print(stu2.name)  # kevin
# 3.将上述函数封装到类体代码中
class Student:
    school = '老男孩'
    def init(obj, name):
        obj.name = name

stu3 = Student()
stu3.init('oscar')
print(stu3.name)  # oscar
# 4.__init__内置方法(自动触发)
class Student:
    def __init__(self, name):  # 在创建时自动调用
        self.name = name

stu4 = Student('tony')
print(stu4.name)  # tony

今日内容

对象独有的功能

class Student:
    school = '老男孩'

    def __init__(self, name):  # 让对象拥有独有的数据
        self.name = name
    # 定义在类中的函数 我们称之为方法
    def eat(self):  # 是多个对象公共的方法 也算多个对象独有的方法  对象来调用就会将对象当做第一个参数传入
        print(f'{self.name}正在吃饭，它的真实信息{self}')

s1 = Student('jason')
s1.eat()  # jason正在吃饭，它的真实信息<__main__.Student object at 0x0000016750BC49D0>
s2 = Student('kevin')
s2.eat()  # kevin正在吃饭，它的真实信息<__main__.Student object at 0x0000023D29BF9E50>
s3 = Student('oscar')
Student.eat(s3)  # oscar正在吃饭，它的真实信息<__main__.Student object at 0x000001877322A040>

"""
python解释器针对上述问题添加了一个非常牛的特性
    定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法) 调用时需要传入一个对象
    默认情况下 对象调用方法会自动将自身传入一个参数中
"""

动静态方法

绑定给对象的方法

# 直接在类体代码中编写即可
# 对象调用会自动将对象当做第一个参数传入
# 类调用则有几个形参就传几个实参
class Student:
    def run(self):  # self用于接收对象
        print(f'{self}在run')

s1 = Student()
s1.run()  # <__main__.Student object at 0x000001ECC2DA49D0>在run

绑定给类的方法

class Student:
    @classmethod  # 绑定给对象的类
    def eat(cls):  # cls用于接收类
        print(f'{cls}在eat')

s1 = Student()
Student.eat()  # <class '__main__.Student'>在eat
# 类调用会自动将类当做第一个参数传入    eat(Student)
s1.eat()  # <class '__main__.Student'>在eat
# 对象调用会自动将产生该对象的类当做第一个参数传入  eat(Student)

静态方法（普通函数）

class Student:
    @staticmethod  # 静态方法
    def sleep(self, cls):  # 无论谁来调用都必须按照普普通通的函数传参方式
        print(f'猜猜self是谁:{self}，猜猜cls是谁:{cls}')

s1 = Student()
# 调用静态方法
Student.sleep(1, 2)  # 猜猜self是谁:1，猜猜cls是谁:2
s1.sleep(3, 4)  # 猜猜self是谁:3，猜猜cls是谁:4

面向对象三大特性之继承

面向对象三大特性

继承
封装
多态

继承的含义

现实中就是继承遗产，拥有上一辈的所有资源
编程中用来描述类与类之间数据的关系
A继承了B 那么A就有了B的功能 且B不受影响

继承的目的

节省代码

继承的操作

class 要继承的类名(被继承的类名):
    pass
"""
1.定义类的时候在类名后加括号
2.括号内填写你需要继承的类名
3.括号内可以填写多个父类 逗号隔开即可

我们将被继承的类称之为: 父类或基类或超类
我们将继承类的类称之为: 子类或派生类
ps:平时最常用的就是父类和子类
"""
class MyClass(F1,F2,F3):
    pass
# ps:目前掌握从左到右查找每个父类中的属性即可

继承的本质

抽象

将多个类共同的数据或功能抽取出来形成一个基类

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

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

# 发现上述两个类都有相同的功能 那么可以抽象一下

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

class Student(Human):
    pass

class Teacher(Human):
    pass

继承

从上往下白嫖各个基类里面的资源

对象:数据和功能的结合体
类:多个对象相同的数据和功能的结合体
父类:多个类相同的数据和功能的结合体
ps:类和父类最主要的功能其实就是节省代码
一定要掌握继承的本质 这样以后你才会在代码中自己定义出子类父类

名字的查找顺序

不继承的情况下

对象>>>类

继承单个类

对象>>>类>>>类的父类

继承多个类的情况下

非菱形继承

深度优先(每个分支都走到底 再切换)

菱形继承

广度优先(前面几个分支都不会走最后一个类 最后一个分支才会走)

只要涉及到对象查找名字 那么几乎都是
对象自身 类 父类

经典类与新式类

经典类
    不继承object或其子类的类(什么都不继承)
新式类
    继承了object或其子类的类
"""
在python3中所有的类默认都会继承object
    也就意味着python3里面只有新式类
在python2中有经典类和新式类
    由于经典类没有核心的功能 所以到了python3直接砍掉了

以后我们在定义类的时候  如果没有想要继承的父类 一般推荐以下写法
    class MyClass(object):
        pass
目的是为了兼容python2
"""
以后写代码针对object无需关心 知道它的存在即可

派生方法

子类中定义类与父类一模一样的方法并且扩展了该功能

class Human:
    def eat(self):
        print('这里是Human的eat')

class Student(Human):
    def eat(self):
        print('这里是Student的eat')
        super().eat()  # super()就是父类

s = Student()
s.eat()

# 运行结果
# 这里是Student的eat
# 这里是Human的eat