09-2023-05-16-面向对象类的封装，继承，多态

1、什么是面向对象？（概念）

白话：根据模板（创建一个类）并实例化类 这个思路就叫面向对象

2、使用面向对象编程的好处

1.         可以重复使用（实例化类）
2.         容易修改（只用修改类的模板）

3、面向对象的特点

1.         封装
2.         继承
3.         多态

4、类名首字母必须大写

5、面向对象的案列

class Demo():
    # 成员变量
    name = None # 闹钟的名字
    # 成员方法
    def user(self):
        print(f'我是闹钟{self.name}，我的功能是：dididiiddidi，起床啦') # 闹钟功能


# 创建一个实例
demo = Demo()
# 给闹钟赋值起一个名字
demo.name = '我是闹钟1'
# 调用闹钟的方法
demo.user()

二、面向对象特点：封装、集成、多态

2.1、什么是封装

将生活中的实例，创建一个类并实例化类就叫封装（概念） 

创建类 + 实例化类 也叫封装

2.1.1 面向对象有一个私有方法

私有方法：定义一个函数 在函数名前面加上__函数名（例如：__username）

私有方法的作用：只能在函数内使用

应用场景：

私有方法的使用：

# 下面函数定义的__username就是私有方法
def __username(self):
    pass

2.1.2面向对象公有方法

公有方法：在任意地方 都可以被调用

2.1.3、如何区分公有方法和私有方法

看函数名前面是否加了__，加了就是私有，没加就是公有

2.2 继承

2.2.1 什么是继承

从字面上来讲：儿子继承父亲的基因和财产 子承父业

在我们类中什么叫继承？

子类继承父类的成员属性和成员方法

如果所子类想继承父类 就把父类的名字写到子类类名的括号中

继承： 不管公有还是私有都会被继承

# 写一个类 父类
# 汽车 1代汽车 2代汽车 3代汽车 4代汽车
class AllCar:
    # 初始化
    def __init__(self, name, typename, price, color, engine):
        # 汽车的名字
        self.name = name
        # 汽车的类型
        self.typename = typename
        # 汽车的价格
        self.price = price
        # 汽车的颜色
        self.color = color
        # 汽车的发动机
        self.engine = engine

    # 私有方法__算出汽车的一个最大马力，100 不要管 这个算术准不准只有自己知道别人不知道，私有方法
    def __calc_ml(self):
        # 计算发动机最大马力
        return self.engine * 100

    # 公有方法
    def get_ml(self):
        # 拿最大马力 并赋值给ml
        ml = self.__calc_ml()
        print(f'汽车的最大马力是{ml},目前正在马路上狂奔')


# 图纸已经设计完毕 只需通过这个图纸批量改造汽车
car1 = AllCar('一代奔驰', '轿车', 200000, '红色', 1.5)
car1.get_ml()

# 通过汽车的案列延伸下继承
# 有客户说 这个汽车设计的太low了，能不能升级
# 如果升级就要对类进行一个功能添加 ，此时就需要用到继承
class AllCar2(AllCar):
    # 在原基础上添加一个新的功能
    def get_color(self):
        print(f'它是{self.color}的，它真是一道漂亮的风景')

# 实例化子类 一定也要把父类的参数带上 继承我们父类的属性和方法
car2 = AllCar2('二代奔驰', '轿车', 300000, '白色', 1.8)

# 如果访问父类的属性和方法 我们父类的方法可以被子类调用
car2.get_ml()
# 也可以调用新定义的自身类的方法
car2.get_color()

2.3 多态

多种状态，即完成某个行为时，使用不同的对象对得到不同的状态。

# 多态
# 父类
class Animals:
    # 定义一个方法，干公有方法
    def sound(self):
        print(f'我是父类A')


# 子类 在子类函数名中加入父类的类名
class Cat(Animals):
    # 定义一个方法 公有方法
    def sound(self):
        print(f'我是子类Cat，喵喵喵')

# 子类 在子类函数名中加入父类的类名
class Dog(Animals):
    # 定义一个方法 公有方法
    def sound(self):
        print(f'我是子类Dog，汪汪汪')

# 实例化三个类
a = Animals()
cat = Cat()
dog = Dog()

# 见证奇迹的时候到了，设置一个函数名为admin
def admin(x):
    # x就是这个类 类中有一个方法叫sound
    x.sound()

admin(cat)
admin(dog)
admin(a)

# 这样一个过程就叫多态
# 我们在调用函数的时候传入不同的类 可以输出不同的结果

实战案列（开发的应用场景）

模拟一个应用场景：

模拟银行账户：使用类来模拟银行账户，每个账户可以存款、取款、查询余额等操作

# 模拟银行账户：使用类类来模拟银行账户，每个账户可以存款、取款、查询余额等操作
# 因为很多人都要来查询账户 余额 存款 取款
# 很多人 以面向对象的编程思路写案列
class BankAccount:
    # 初始化
    def __init__(self, card_no, balance):
        # 卡号
        self.card_no = card_no
        # 余额
        self.balance = balance

    # 存钱
    def func_save_money(self, save_money=0):
        # 我们拿到余额 加上我们要存的钱
        self.balance += save_money
        print(f'当前存款{save_money}，存款后余额{self.balance}')
    # 查询余额
    def func_balance_query(self):
        print(f'您当前的余额为{self.balance}')

    # 取钱
    def func_withdraw_money(self, withdraw_money):
        # 如果当前余额小于你要取钱的金额你就不能去
        if withdraw_money > self.balance:
            print(f'您当前要取{withdraw_money},您的余额为{self.balance}，您最多只能取{self.balance}')
        else:
            #拿当前余额减去取钱的金额
            self.balance -= withdraw_money
            print(f'您成功取钱{self.balance}')

# 实例化一个类 fisher
fisher = BankAccount('12345678', 20000)
yongan = BankAccount('87654321', 100000)
# 查询fisher的余额
fisher.func_balance_query()
# 永安取走1500
yongan.func_withdraw_money(1500)

# fisher 存了5000
fisher.func_save_money(5000)