Python面向对象基础

本章知识简介:

主线A: 类和对象  -抽象
主线B: 封装 -应用 [面向对象就是把面向过程的内容再次封装]  ==>之前没学函数前,写代码执行就有效果; 固定  -->封装:[函数、变量]
主线C: 继承 -class 子类名(父类xxx):

 ==本章目标：==

1:知道类的概念; 
    类是模板
2:知道对象的概念;
    对象就是通过模板创建出来的实体
3:知道使用class关键字定义一个类;
class 类名(object):
    pass
4:能够说出调用对象中的方法的语法格式。
对象名.方法名([参数列表])

什么是面向对象？

[了解]常见的编程思想:

==目标：==了解常见的编程思想有哪些？

编程思想就是：利用计算机来解决实际编程问题的一种思维方式。

而编程思想是通用的，与计算机语言本身没有太大关系。

常见的编程思想有：

（1）面向过程

（2）面向对象

Python是同时支持面向过程和面向对象的编程语言！

注意：当有了编程思想后，学习不同编程语言都是相通的。

面向过程是什么

【官方解释】面向过程是一种以过程为中心的编程思想。

通俗地说，在解决编程问题时，我们会把需要的操作步骤都列出来，然后按照操作步骤写代码，这种思维就是面向过程思想。

说明：

比如，要产生一个随机数，步骤：（1）导入random模块；（2）产生随机数；（3）输出结果。

在实际生活中，为了更好理解面向过程。

使用面向过程思维来了解：使用ATM机取钱的过程

（1）带上银行卡，去ATM机所在的地方；
（2）排队等待；
（3）轮到自己了，把银行卡插入ATM机；
（4）输入密码，取钱；
（5）取钱成功，准备回家把钱上交媳妇儿把钱。

什么是面向对象

==目标：==掌握什么是面向对象？

【官方解释】面向对象是软件开发方法，一种编程范式。面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

# 学生：姓名、年龄；  玩、学习
# a.先定义
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def play(self):
        print(f"{self.age}岁的{self.name}还在玩泥巴...")

    def study(self):
        print("好好学习,天天向上!!")

# b.后调用
stu = Student("张三",16)
print(stu.name)
print(stu.age)
# 调用
stu.play()
stu.study()

# 总结:
# 1. 封装后的代码执行后不能立马有效果  ==抽象
# # 2. 一切皆对象：类 ==> 对象
# # 3. 类：包含两部分: 变量、方法

通俗地说，面向对象思想就是：当解决问题的视角不再是详细的操作步骤，而是另一个视角：操作对象。比如，操作手机打电话、操作电脑来看电影、操作冰箱来存储新鲜水果等。

说明：面向对象听起来很抽象、模糊、不理解，暂时没关系，记住五个字：一切皆对象。

面向对象思想优势：

（1）在现实生活中，所有事物都被看作是对象；

（2）面向对象的宗旨：模拟现实世界中的一切事物；

（3）贴近实际生活，给所有对象都赋予属性和方法，更加人性化。

==总结：==

（1）可以简单的理解操作对象的过程，就是将面向过程的操作步骤再次封装处理；

（2）特别注意：学习面向对象知识，总结归纳就是5个字：一切皆对象。[思考]

==【思考】==例如，一起来完成：

（1）举两个现实生活中的案例；

（2）以面向过程思想分析；

（3）以面向对象思想分析。

吃饭
面向过程: 买菜、洗菜、做饭菜、吃
面向对象: 点外卖 [厨师、外卖员]

打水
面向过程: 拿水杯、去清洗、装水、盖盖子、拿到教室
面向对象: 叫方哥给你打杯水.

[了解]封装

==目标：==了解什么是封装？

面向对象思想虽然比较复杂，但有一些特性有迹可循。

面向对象的三大特性：

（1）封装

（2）继承

（3）多态

简单地说，封装就是把对象的属性和方法放在一个整体中，并限制对属性和方法的访问操作。而这里说的整体，就是【类】。

class 类名:
    def 方法名():
        属性1 = 值1
        属性2 = 值2
        ...
    
    def 方法名2():
        执行代码1
        执行代码2
        ...

[了解]继承

==目标：==了解什么是继承？

在现实生活中，继承一般指的是子女继承父辈的财产，比如：子承父业等。

类似的，面向对象继承也有继承父类的意思。

通俗地说，当子类继承了父类后，子类就具有父类的属性和方法。比如，下图的关系。

注意：继承可以让程序更加简洁。

[了解]多态

==目标：==了解什么是多态？

多态指的是：不同类的对象对同一消息做出不同的响应。这里的发送消息，通常是指调用方法。

通过生活案例来说明什么是多态，比如：电脑键盘上的F12功能键是固定不变的，但完成功能不同。

固定不变的F12功能键	完成功能
F12	在WPS办公软件使用时，提示用户保存文件。
F12	在Notepad++编辑软件使用时，会把工作区间进行全屏显示。
F12	在Chrome浏览器使用时，能进入到开发者模式。

==总结：==

（1）要了解多态，得先掌握封装和继承，咱们仅需要了解有多态特性即可。

面向对象的概念

[了解]两个重要概念

==目标：==了解什么是类，什么是对象？

要掌握Python面向对象的特性，首先需要了解两个重要概念：类、对象。

我们通过公司职员-张三为例子来解释说明。

类是抽象的概念，指的是：对某些事物的描述。[模板]

对象是具体的概念，指的是：实实在在存在的个体。[填写]

例如，请判断以下哪些是类，哪些是对象？

（1）员工；类
（2）《陈翔六点半》里的演员妹爷；
（3）手机；类
（4）被8分钟残忍嘎腰子的那只羊；
（5）银行卡；类
（6）昆虫；类
（7）动物；类
（8）老王买的最新款iPhone 14 Pro，商品编号为：874875487的手机
（9）在对面马路上快速奔跑的Tank 300。

==总结：==

（1）类是（）的概念，表示对某些事物的描述；==A、抽象==；B、具体；

（2）对象是具体的概念，表示实实在在存在的个体。

[掌握]类

==目标：==掌握定义类的语法。

类是抽象的概念，指的是：对某些事物的描述。简单地说，类就是一个模板。

定义Python类语法：

class 类名
    def 方法名(self):
        代码1
        代码2
        ...
    # 其他方法...

例如，一起来完成：

（1）定义一个汽车类；

（2）让汽车类能跑起来；

（3）执行程序，观察效果。

class Car:
    def run(self):
        print("汽车能跑起来..."  )
# 当仅定义了后,执行程序没有效果

==总结：==

（1）可以使用class关键字来定义Python类；

（2）注意：类是抽象的，仅定义了类并执行，没有执行效果。

[掌握]对象

==目标：==掌握创建对象的语法。

对象是具体的概念，指的是：实实在在存在的个体。简单的说，对象就是通过类创建出来的实体。

创建对象语法：

对象名 = 类名()

调用方法语法：

对象名.方法名()

说明：

不用给self参数传递参数值。

例如，一起来完成：

（1）用对象模拟制造出一台小轿车；

（2）小轿车能跑起来；

（3）执行程序，观察效果。

class Car:
    def run(self):
        print("汽车能跑起来...")
# 1.创建对象
# 对象名 = 类名()
car = Car()
# 2.调用方法
# 对象名.方法名()
car.run()   # 不需要给self传递值

==总结：==

（1）创建对象的语法为：（）；==A、对象名 = 类名()==；B、对象名 = new 类名()；

（2）当创建了对象和调用方法后，执行程序则有结果。

[掌握]self关键字

==目标：==掌握self关键字的使用。

self是一个Python关键字，在面向对象中，self指向了对象本身。比如，创建了一个学生对象。

# 定义类
class Student:
    pass
​
# 创建对象
student = Student()

说明：self表示当前的，当前的对象。

例如，一起来完成：

（1）定义一个学生类，且学生在努力学习；

（2）创建一个对象，同时输出对象名、self，了解self的含义；

（3）再到学生类中，定义一个学生睡觉的行为，并分别通过对象名、self调用方法；

（4）执行程序，观察self的效果。

# 类中的self只是一个模版，创建对象之后，self是指向本对象
# 如果你创建了2个对象，每个对象中都有self，每个self都指向自己的对象
class Student():
    def study(self):
        print(self)   # <__main__.Student object at 0x0000021AB977F048>
        print('学生在努力学习!')
​
    def sleep(self):
        print(self)  # <__main__.Student object at 0x0000021AB977F048>
        self.study()   # 同一个类中，要调用其他方法，需要使用self，self表示本对象
        print('学生要好好睡觉！')
​
​
# 2、创建学生对象
s = Student()
print(s)  # <__main__.Student object at 0x0000021AB977F048>
s.study()
s.sleep()
​
print('--------------下边又是创建一个新的对象----------------')
​
s2 = Student()
print(s2)
s2.study()
s2.sleep()
​

==总结：==

（1）self可以理解为：当前的、当前的对象；

（2）注意：在类内部使用【self.属性名】调用属性，使用（）调用方法。==A、self.方法名()==；B、类名.方法名()；

对象属性

[了解]什么是属性

==目标：==了解什么是属性？

在现实生活中，属性就表示固有特征，比如：一辆小轿车的属性有轮胎数、颜色、品牌等。

仔细观察后会发现，属性可以简单理解为与生俱来的特征，比如一个人的姓名、年龄、身高、体重等都是属性。

而属性在Python面向对象中，直接使用变量来表示。

需要注意的是，一个对象通常包含两部分：方法、属性。

==总结：==

（1）属性在面向对象中，可以使用变量来表示；

（2）注意：属性可以在类内部、类外部都进行获取与使用。

[掌握]类外面访问属性

==目标：==掌握类外面添加和获取属性的使用。

在类外面访问属性，分为：

（1）添加属性

（2）获取属性

说明：要访问对象中的属性，需要使用.点来操作。

添加属性语法：

对象名.属性名 = 值

获取属性语法：

对象名.属性名

说明：.点可以理解为：的。

例如，一起来完成：

（1）在车类外设置车的颜色为红色、有4个轮胎；

（2）获取属性值并输出结果。

​

# 1、定义汽车类
class Car:
    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')
​
​
print('--------------造第一个对象------------------------')
# 2、创建Car类对象
car = Car()
# 3、通过对象来调用方法
car.run()
​
# 4、添加属性
car.color = 'red'
car.number = 4
​
# 5、获取属性
print(f'车的颜色{car.color}')  # .就是的
print(f'车的轮胎数量{car.number}')  # .就是的
​
print('--------------造第二个对象------------------------')
# 1、创建对象
car2 = Car()
car2.run()
​
# 2、添加属性
car2.brand = '宝马'
​
​
# 3、获取属性
print(f'车的品牌:{car2.brand}')  # .就是的
​
# 以上代码两辆车的属性都不同

==总结：==

（1）在类外面，添加和获取属性可以使用（）方式；==A、对象名.属性名==；B、类名.属性名

（2）注意：当没有添加属性时，无法直接获取属性结果。

魔法方法

[了解]什么是魔法方法？

==目标：==了解什么是魔法方法？

魔法方法指的是：可以给Python类增加魔力的特殊方法。有两个特点：

（1）总是被双下划线所包围；

（2）在特殊时刻会被自动调用，不需要开发者手动去调用。

魔法方法语法：

__魔法方法名__()

在Python中，常用的魔法方法有：

魔法方法名	描述信息
__init__(self [, ...])	构造器，当一个对象被初始化创建时，会被自动调用。
__str__(self)	输出对象名时，若不想直接输出内存地址值，可重写str()方法。
__del__(self)	当一个对象被删除或销毁时，会被自动调用。

==总结：==

（1）魔法方法的前后，总是被（）包围着；==A、双下划线==；B、单下划线；

（2）注意：魔法方法会在某些特殊时刻被自动调用。

[掌握]无参__init__()方法

==目标：==掌握无参__init__()方法的使用。

在Python中，当新创建一个对象时，则会自动触发__init__()魔法方法。

魔法方法名	描述信息
__init__(self [, ...])	构造器，当一个对象被初始化创建时，会被自动调用。

根据是否给__init__()魔法方法传递参数值，可分为：

（1）无参__init__()方法

（2）有参__init__()方法

无参__init__()方法语法：

class 类名:
    def __init__(self):
        代码
        ...

说明：当仅需在类内部使用与初始化属性时，可以使用该方法。

例如，一起来完成：

（1）给小轿车这个对象默认设置颜色和轮胎数为：黑色、3个轮胎；

（2）创建对象后，直接获取属性结果。

​

# 1、定义汽车类
class Car:
    def __init__(self):
        print('init方法执行了！')
        self.color = '白色'  # 所有对象的属性变量
        self.number = 4     # 所有对象的属性变量
        brand = '宝马'       # init方法中的局部变量，只能在方法内部使用，和对象关系不大
​
    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')
​
​
print('--------------造第一个对象：使用默认的属性------------------------')
car = Car()  # 创建对象，会自动执行init方法
print(f'车的颜色:{car.color}')
print(f'车的轮胎数量:{car.number}')
print(f'车的品牌:{car.brand}')
​
print('--------------造第二个对象：使用默认的属性------------------------')
car2 = Car()  # 自动执行init方法
print(f'车的颜色:{car2.color}')
print(f'车的轮胎数量:{car2.number}')
​
print('--------------造第三个对象：修改默认属性------------------------')
# 修改了对象的属性之后，只是修改本对象的属性，默认属性并不会修改
car3 = Car()
car3.color = '黑色'
car3.number = 3
​
print(f'车的颜色:{car3.color}')
print(f'车的轮胎数量:{car3.number}')
​
print('--------------造第四个对象：使用默认的属性------------------------')
# 这里输出的还是默认属性
car4 = Car()  # 自动执行init方法
print(f'车的颜色:{car4.color}')
print(f'车的轮胎数量:{car4.number}')
​

==总结：==

（1）当创建对象时，会（）执行__init__()方法；A、自动调用；B、不调用；

（2）注意：建议自定义的类中，有一个__init__()魔法方法。

[掌握]有参__init__()方法

==目标：==掌握有参__init__()方法的使用。

当想要在创建对象时，就设定属性值时，可以使用有参__init__()方法。语法：

class 类名:
    def __init__(self, 参数1, 参数2,...):
        代码
        ...

说明：

（1）不需要给self传递参数值；

（2）传递参数个数的计算公式为【传递参数个数 = 定义方法后的参数总个数 - 1】。

例如，一起来完成：

（1）直接在创建车对象时，初始化设定颜色、轮胎数值；

（2）在类外部直接获取对象属性值。

# 1、定义汽车类
class Car:
    def __init__(self,color,number):
        self.color = color       # 所有对象的属性变量
        self.number = number     # 所有对象的属性变量
​
    def run(self):  # self这个参数，暂时不用管，以后也不用传参，代表本对象
        print('汽车可以跑！')
​
​
print('--------------造第一个对象：传入自定义属性------------------------')
car = Car('白色',number=4)  # 创建对象，会自动执行init方法
print(f'车的颜色:{car.color}')
print(f'车的轮胎数量:{car.number}')
​
print('--------------造第二个对象：传入自定义属性------------------------')
car2 = Car(color='黑色',number=3)  # 自动执行init方法
print(f'车的颜色:{car2.color}')
print(f'车的轮胎数量:{car2.number}')
​

• 学生类

  # 1、定义学生类
  class Student:
      # 类属性，这个属性是所有对象共享属性,不独属于任何一个对象
      #当你修改了类属性school_name后，这个改变会影响到所有通过该类创建的实例。
      #这是因为类属性是共享的，一旦你在类的定义外部修改了它，所有对该类属性的引用（包括已经创建的实例）都会看到新的值。
      school_name = '黑马程序员'
      # 属性
      def __init__(self, id,name, age,sex):  # 对象属性
          self.id = id
          self.name = name
          self.age = age
          self.sex = sex
  ​
      # 学习行为
      def study(self):
          print(f'{self.name}学生要好好学习!')
      # 睡觉行为
      def sleep(self):
          print(f'{self.name}学生要好好睡觉!')
  ​
  ​
  # 2、创建学生对象1
  print('---------------造对象1--------------------------')
  stu1 = Student(1001,'刘备',23,'M')
  stu1.study()
  stu1.sleep()
  # 访问对象属性
  print(f'学号:{stu1.id},名字:{stu1.name}')
  # 访问类属性，使用：类名.类属性
  print(f'学校:{Student.school_name}')
  ​
  Student.school_name = '传智播客'
  ​
  print('---------------造对象2--------------------------')
  # 2、创建学生对象
  stu2 = Student(1002,'关羽',24,'W')
  stu2.study()
  stu2.sleep()
  ​
  # 访问对象属性
  print(f'学号:{stu1.id},名字:{stu1.name}')
  # 访问类属性
  print(f'学校:{Student.school_name}')

==总结：==

（1）__init__()方法可以用来设置属性的默认值；

（2）注意：当要在创建对象时，直接设定属性值，则可以通过有参__init__()方法传递参数值来处理。

[掌握]__str__()方法

==目标：==掌握__str__()方法的使用。

内存地址值，也称为引用。表现形式有两种：

（1）十进制数 5040624，id()函数

（2）十六进制数 0x45AC6

说明：当直接输出对象名时，默认输出的是对象的内存地址值。

当在类中定义了__str__方法，则获取的是该方法返回的数据结果。

魔法方法名	描述信息
__str__(self)	输出对象名时，若不想直接输出内存地址值，可重写str()方法。

__str__方法语法：

class 类名:
    def __str__(self):
        代码
        ...
        return 字符串型的结果

说明：必须返回字符串型的结果。

例如，一起来完成：

（1）创建一个有两个参数的小轿车对象，直接输出对象名，观察结果；

（2）思考：在输出小轿车对象名时，如何把颜色、轮胎数显示出来？

# 1、定义学生类
class Student:
    school_name = '黑马程序员'
    # 属性
    def __init__(self, id,name, age,sex):  # 对象属性
        self.id = id
        self.name = name
        self.age = age
        self.sex = sex
​
    # 重写系统的__str__方法,打印对象时，会自动调用该方法
    def __str__(self):
       return f'{self.id},{self.name},{self.age},{self.sex}'
​
​
# 2、创建学生对象1
print('---------------造对象1--------------------------')
stu1 = Student(1001,'刘备',23,'M')
​
# 你直接打印对象时，默认调用的时__str__方法，但是系统中的该方法返回的对象地址,我们重新定义__str__方法，当打印对象时，就可以调用我们自定义的__str__方法
print(stu1)

==总结：==

（1）注意：当没有重写__str__()方法时，输出对象名，则直接输出对象的（）。==A、内存地址值==；B、属性名；

[了解]__del__()方法

==目标：==了解__del__()方法的使用。

当删除对象时，会自动调用__del__()方法。

魔法方法名	描述信息
__del__(self)	当一个对象被删除或销毁时，会被自动调用。

__del__()方法语法：

class 类名:
    def __del__(self):
        代码
        ...

例如，一起来完成：

（1）定义一个有品牌属性的车类；

（2）创建对象后，输出属性值；

（3）再使用__del__()方法删除对象查看效果；

（4）思考：当不调用【del 对象名】，__del__()方法会自动调用执行吗？

# 1、定义学生类
class Student:
    school_name = '黑马程序员'
    # 属性
    def __init__(self, id,name, age,sex):  # 对象属性
        self.id = id
        self.name = name
        self.age = age
        self.sex = sex
​
    # 重新系统的__del__方法，当删除对象时，自动调用该方法
    def __del__(self):
        print(f'请注意，{self.name}学生对象被删除了！')
​
​
print('---------------删对象-------------------------')
del stu1     #  当删除对象时，自动调用__del__该方法
​
print(stu1)  # 删除之后是不能再打印对象的

==总结：==

（1）当使用【del 对象名】时，自动调用了__del__()方法；

（2）注意：当程序执行结束时，Python垃圾回收器会自动销毁内存垃圾，此时会自动调用__del__()方法。

继承基础

[了解]定义类的几种语法

==目标：==了解定义类的标准语法。

在python中，任何一个类的最顶层父类都是object

我们知道，可以使用class关键字定义类。

在类的使用中，定义方式有三种：

（1）【类名】

（2）【类名()】

（3）【类名(object)】

说明：区别在于类名后面是否加其他内容。

方式1语法：

class 类名:
    代码
    ...

方式2语法：

class 类名():
    代码
    ...

方式3语法：

class 类名(父类):   # 推荐
    代码
    ...

说明：方式3是定义类最常见的语法。

例如，一起来完成：

（1）使用方式1/2/3分别定义老师类、学生类、手机类；

（2）当成功定义后，观察类的效果。

# 1.类名
# class Teacher:
class Teacher:
    pass
​
​
# 2.类名()
class Student():  # 删除()
    pass
​
​
# 3.类名(object)
class Phone(object):   # 标准
    pass

==总结：==

（1）定义一个类的语法有3种，但是更规范标准的是（）；==A、类名(object)==；B、类名()；

（2）注意：在实际应用中，建议都采用【类名(object)】方式来定义类。

[了解]什么是继承

==目标：==了解什么是继承？

在现实生活中，继承一般指的是：子女继承父辈的财产。

说明：当继承了父辈的财产后，则归子女所有。

类似的，在面向对象中，当子类继承父类后，则：子类拥有了父类的属性和方法。

继承语法：

class 父类名(object):
    代码
    ...

class 子类名(父类名):
    代码
    ...

说明：

（1）建议在定义父类时，都采用【类名(object)】语法；

（2）当子类拥有了父类的属性和方法后，能提升代码的复用性。

例如，一起来完成：

（1）Father类有一个性别属性，默认为男，同时，Father跑步速度快；

（2）如果Son类也想要拥有这些属性和方法，该怎么做呢？

（3）执行程序，观察程序效果。

# 1.定义父类
class Father(object):
    def __init__(self):
        self.sex = "男"
​
    def run(self):
        print("跑步很快...")
​
# 2.定义子类
# class Son(object):
#     def __init__(self):
#         self.sex = "男"
#
#     def run(self):
#         print("跑步很快...")
​
# 3.改进
class Son(Father):
    pass
​
# 4.输出
son = Son()
print(f"属性:{son.sex}")
son.run()

==总结：==

（1）子类继承父类的语法是：class 子类名(父类名): ...；

（2）注意：object类可以称为基类、顶级类或超类，而案例中的Son类一般称为（）、派生类。==A、子类==；B、父类；

[掌握]单继承

==目标：==掌握单继承的使用。

单继承指的是：一个子类继承一个父类。语法：

class 子类名(父类名):
    代码
    ...

接着，一起来听个故事。故事主线是：一个徒弟跟着老师傅学习摊煎饼……

• 人、学生、工人案例

  

  # 定义父类
  class Person(object):
      def __init__(self, name,age,sex):
          print('父类的init方法')
          self.name = name
          self.age = age
          self.sex = sex
  ​
      def eat(self):
          print('人必须要吃饭!')
  ​
      def sleep(self):
          print('要必须要睡觉!')
  ​
  # 2、定义子类：Student类
  class Student(Person):
      #子类有特殊的对象属性：sid
      print('-------------调用父类的初始化--------------------')
      def __init__(self,name,age,sex,sid):
          super().__init__(name,age,sex)  # 调用父类的init方法进行初始化
          self.sid = sid    # 给自己特有的属性进行初始化
  ​
      # print('-------------自己进行初始化--------------------')
      # def __init__(self,name,age,sex,sid):
      #     self.name = name
      #     self.age = age
      #     self.sex = sex
      #     self.sid = sid    # 给自己特有的属性进行初始化
  ​
  ​
      #特殊的行为：study
      def study(self):
          print('每个学生都要好好学习!')
  ​
      def __str__(self):  # 使用父类的属性就像自己的一样，直接使用self来调用
          return f'{self.name},{self.age},{self.sex},{self.sid}'
  ​
  ​
  ​
  # print('------------测试----------------')
  # 1、创建父类对象
  person = Person('刘备',18,'男')
  person.eat()
  person.sleep()
  ​
  print('----------------子类对象-----------------')
  # 2、创建子类对象
  student = Student('刘备',18,'男','1001')  # 创建子类对象时，会先创建父类对象
  student.eat()    # 调用父类方法
  student.sleep()  # 调用父类方法
  ​
  student.study()  # 调用子类特有方法
  ​
  print(student)   # 打印子类对象

  例如，一起来完成：

（1）从前，有个摊煎饼的老师傅[Master]，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼技术；

（2）渐渐地，老师傅老了，就想着把这套技术传授给他唯一的最得意的徒弟[TuDi]；

（3）试着通过初始化、无参、定义方法与单继承来模拟程序。

# 1.定义父类：老师傅
# 配方
# 摊煎饼
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"
​
    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")
​
# 2.定义子类：徒弟
class TuDi(Master):
    pass
​
# 3.创建对象
fang_ge = TuDi()
print(fang_ge.pei_fang)
fang_ge.make_cake()

==总结：==

（1）单继承就是一个子类继承了一个父类，语法：class 子类名(父类名): ...；

（2）注意：当子类继承了父类后，子类可以拥有父类的属性和方法。

[掌握]多继承

==目标：==掌握多继承的使用。

多继承指的是：一个类同时继承了多个父类。语法：

class 子类名(父类名1, 父类名2, ...):
    代码
    ...

继续，回到摊煎饼的故事主线。

例如，一起来完成：

（1）徒弟是个爱学习的好孩子，想学习更多的摊煎饼技术；

（2）于是，在百度搜索到黑马程序员学校[School]，报班来培训学习如何摊煎饼；

（3）使用多继承形式模拟程序。

# 1.定义父类：老师傅
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"
​
    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")
# 2.定义父类：学校
class School(object):
    def __init__(self):
        self.pei_fang = "【科技与狠活之黑马配方】"
​
    def make_cake(self):
        print("===========采用黑马配方制作煎饼果子!!")
​
# 3.定义子类：徒弟
class TuDi(Master,School):
    pass

==总结：==

（1）当一个类同时继承了多个父类时，这种行为就叫做（）；==A、多继承==；B、单继承；

（2）注意：在Python面向对象中，继承包含：单继承、多继承、多层继承。

[了解]子类调用方法的顺序

==目标：==了解子类调用父类方法的顺序。

当子类同时继承多个父类，并调用多个父类同名方法的顺序，查看时使用：

类名.__mro__

类名.mro()

例如，一起来完成：

（1）可以发现老师傅[Master]、培训学校[School]都有摊煎饼方法；

（2）在徒弟对象中调用摊煎饼方法，会执行哪个父类的方法呢？

（3）思考：当给父类培训学校[School]新增编程方法后，子类能调用方法吗？

# 1.定义父类：老师傅
class Master(object):
    def __init__(self):
        self.pei_fang = "【独创古法配方】"
​
    def make_cake(self):
        print("老师傅用古法配方摊煎饼果子...")
# 2.定义父类：学校
class School(object):
    def __init__(self):
        self.pei_fang = "【科技与狠活之黑马配方】"
​
    def make_cake(self):
        print("===========采用黑马配方制作煎饼果子!!")
​
# 3.定义子类：徒弟
# 如果父类出现同名的方法，调用顺序和这里继承父类的书写顺序相同，先调用Master的make_cake，再调用School的make_cake
class TuDi(Master,School):
    def programming(self):   # 子类的特有方法，加上父类继承的方法，子类一共有三个方法
        print("====培训大数据开发!")
​
​
# 4、创建子类对象
tudi = TuDi()
# 调用方法时：
# a.先去子类中去查找该方法,若存在,则直接使用
# b.如果子类没有，则去第1个父类中查找Master
# c.如果第一个父类没有，则去第2个父类中找School
# d.如果所有父类都没有，则取object找
# e.如果都没有，则报错
tudi.make_cake()
tudi.programming()
​
print('-------mro()查看父类方法调用顺序----------')
print(TuDi.__mro__)

==总结：==

（1）当子类继承父类后，可以给子类添加新的扩展方法；

（2）当要查看子类调用父类方法的顺序时，可以使用子类名.__mro__或（）。==A、mro()==；B、self()；

继承进阶

[掌握]方法重写

==目标：==掌握方法的重写。

当父类的同名方法达不到子类的要求，则可以在子类中对方法进行重写。语法：

class 父类名(object):
    def 方法A(self):
        代码
        ...

class 子类名(父类名):
    def 方法A(self):
        代码
        ...

例如，一起来完成：

（1）徒弟非常认真学习，终于掌握了老师傅的技术；

（2）接着，自己潜心钻研出类独门配方的全新摊煎饼技术；

（3）使用方法重写对摊煎饼方法进行处理。

# 1.老师傅: 父类
class Master(object):
    def make_cake(self):
        print("使用古法配方摊煎饼果子...")
​
​
# 2.徒弟：子类  -父类方法达不到要求
class TuDi(Master):
    # 重写
    def make_cake(self):
        print("======潜心学习,专研了新的配方制作煎饼果子...")
​
# 3.调用使用
tudi = TuDi()
tudi.make_cake()
print(TuDi.mro())

==总结：==

（1）当子类中出现与父类中同名方法且参数内容保持一致时，称为（）；==A、方法重写==；B、方法重载；

（2）当子类重写了父类方法后，子类对象优先调用执行子类方法，可以通过【子类名.mro()】查看执行顺序。

[掌握]调用父类方法

==目标：==掌握使用super()调用父类方法。

当子类要在父类同名方法的基础上，再新增功能且要求在子类中调用同名方法时，就可以使用super()。

super()语法：

super().方法名([参数1, 参数2, ...])

说明：

（1）super()表示父类；

（2）.点表示的。

例如，一起来完成：

（1）徒弟在培训学校学习努力，不仅掌握了黑马摊煎饼配方、还创办了自己煎饼果子的品牌；[配方、品牌]

（2）配合着一起摊煎饼，做出了更加美味的煎饼果子；

（3）使用调用父类方法在__init__()和摊煎饼方法中处理。

# 1.定义父类 [属性、方法]
class School(object):
    def __init__(self, pei_fang):
        self.pei_fang = pei_fang
​
    def make_cake(self):
        print("父类,制作了美味的煎饼果子!!")
​
# 2.定义子类
class TuDi(School):
    # 属性: 配方、品牌
    def __init__(self,pei_fange,brand):
        # self.pei_fang = pei_fange   # 提升代码的复用性
        super().__init__(pei_fange)
        self.brand = brand
​
    def make_cake(self):
        # 调用父类的方法
        super().make_cake()
        print("===========子类制作煎饼果子!!")
​
# 3.创建对象、调用
tudi = TuDi("黑马","方哥")
tudi.make_cake()

==总结：==

（1）super()可以简单的理解为：父类；

（2）当要在子类中调用父类的同名方法时，使用语法：（）.同名方法()。==A、super()==；B、self()；

[了解]多层继承

==目标：==了解什么是多层继承？

多层继承指的是：多级继承的关系，比如：子类继承父类C、继续继承父类B、继续继承父类A等。

为了区分单继承、多继承和多层继承，看下图：

例如，一起来完成：

（1）N年后，当初的徒弟也老了；

（2）因此，徒弟想要把"有自己品牌，也有黑马配方的煎饼果子"的所有技术传授给自己的小徒弟；

（3）请试着使用多层继承的方式完成案例。

# 1.A父类 学校
class School(object):
    def make_cake(self):
        print("----1-----黑马学校:父类")
​
# 2.B父类 徒弟
class TuDi(School):
    def make_cake(self):
        print("=====2======徒弟: 子、父类")
​
# 3.子类 徒孙
class TuSun(TuDi):
    pass
​
​
#------------------
tusun = TuSun()
tusun.make_cake()  #调用的时直接父类的方法，如果父类没有，则调用祖父类，否则就一直向上追溯

==总结：==

（1）简单地说，多层继承表示有多级父类；

（2）请问：Python同时支持单继承、多继承和多层继承，这句话对吗？==A、对==；B、错。

私有权限

[掌握]私有属性

==目标：==掌握私有属性的使用。

为了更好的限制属性的访问和包含隐私，可以给属性设置私有权限。

当把属性设置为私有属性后，则该属性只能被本类直接访问。

定义私有属性语法：

self.__属性名

设置和获取私有属性值语法：

class 类名(xxx):
    # 设置私有属性值[set]
    def set_私有属性名(self,参数):
        self.私有属性 = 参数
​
    # 获取私有属性值[get]
    def get_私有属性名(self):
        return self.私有属性

例如，一起来完成：

（1）FangGe把技术传承给小徒弟时，不想把自己的私房钱（￥6000000）继承给徒弟；

（2）这时，就要为私房钱这个属性设置私有权限；

（3）思考：若想要来访问私有属性，该怎么做呢？

​

#  ---------隐藏该隐藏的，暴露该暴露的--------------------------
# 1、定义父类
class Master(object):
    def __init__(self):
        self.__money = 0  # 私有属性
​
    # 对外提供修改私有属性的方法
    def set_money(self,money):
        self.__money = money
​
    # 对外提供一个获取私有属性的方法
    def get_money(self):
        return self.__money
​
master = Master()
# master.__money = 100  # 对象又自己添加了一个属性，不是私有属性
​
# 修改私有属性
master.set_money(8000)
​
# 获取私有属性
print(master.get_money())
​
# 升级:
# 1.当子类继承了父类后, 子类就拥有了父类的属性和方法
# 2.当子类继承了父类后, 子类就拥有了父类的【非私有】属性和【非私有】方法

==总结：==

（1）当要定义私有属性时，仅需要在属性名前添加（）；==A、双下划线==；B、不添加任何内容；

（2）注意：如果要从外部访问私有属性值，建议要在类中定义set/get方法。

[了解]私有方法

==目标：==了解私有方法的使用。

当把方法设置为私有方法后，则该方法只能被本类直接访问。

定义私有方法语法：

def __方法名(self):
     ...

例如，一起来完成：

（1）FangGe把技术传承给小徒弟时，不想把自己独创配方的制作过程继承给徒弟；

（2）这时，就要为制作独创配方这个方法设置私有权限；

（3）思考：该怎么访问私有方法呢？

# 1.定义父类
class Master(object):
    def __make_secret(self):
        print("===================")
        print("加葱姜蒜...")
        print("加酱油,加白醋")
        print("辣椒面...")
        print("制作好卖给我的学生!!")
        print("===================")
​
    # 间接,我们可以封装一个方法，只有满足我的条件，才能调用私有方法，否则不能访问
    def use(self,info):
        if info == '衷心的徒弟':
           self.__make_secret()
        else:
            print('龟蛋!!!!!')
​
​
print('--------------------------------')
master = Master()
# master.__make_secret()  # 不能在类外部调用私有方法
​
master.use('衷心的徒弟')  # 不能在类外部调用私有方法

==总结：==

（1）当把方法设定为私有权限后，则该方法不会被继承给子类；

（2）注意：当子类继承了父类后，子类拥有父类的（）。==A、非私有属性和非私有方法==；B、属性和方法；

面向对象综合案例

[掌握]案例：减肥

==目标：==掌握面向对象方法和属性的使用。

例如，一起来完成：

（1）小方同学当前体重是100kg；

（2）每当他跑步一次时，则会减少0.5kg；

（3）每当他大吃大喝一次时，则会增加2kg；

（4）假如跑步5次后，再大吃大喝一次，体重如何？

（5）请试着采用面向对象思想来编写案例。

class Student(object):
    # 1、定义属性
    def __init__(self, name,weight):
        self.name = name    # 小方  小花
        self.weight = weight # 100  60
​
    # 2、定义方法
    # 每当他跑步一次时，则会减少0.5kg；
    def run(self,num):
        self.weight -= num * 0.5
​
    # 每当他大吃大喝一次时，则会增加2kg；
    def eat(self,num):
        self.weight += num * 2
​
print('----------------------')
# 定义对象
stu1 = Student('小方',100)
​
# 跑步5次
stu1.run(5)
# 大吃大喝1次
stu1.eat(1)
​
# 打印体重
print(f'当前体重:{stu1.weight}')
​
​
print('----------------------')
# 定义对象
stu1 = Student('小花',60)
​
# 跑步3次
stu1.run(3)
# 大吃大喝1次
stu1.eat(2)
​
# 打印体重
print(f'当前体重:{stu1.weight}')

==总结：==

（1）在类内部调用或获取属性时，可以使用（）方式；==A、self.属性名==；B、类名.属性名；

（2）当通过对象来调用方法时，可以使用【self.方法名()】方式

==总结：==

（1）我们会发现，对于魔法方法的使用，会在某些特殊时刻自动被调用；

（2）在学习面向对象知识时，我们会发现总结起来就是五个字：（）。==A、一切皆对象==；B、一切都是类；