python class类 与 对象

1. 体验 类与对象

# 先要创建类， 才能创建实例（对象）
# 1. 创建 类  采用驼峰命名法
class Washer():
    # self 指的是调用该函数的对象
    def wash(self):
        print('能洗衣服')
        print(self)

# 2. 创建 实例（对象） 实例 = 类()
haier = Washer()

# 3. 验证是否成功 实例.函数名()
haier.wash()

print(haier)

2. 一个类可以创建多个对象

class Washer():
    def wash(self):
        print('洗衣服')
        print(self)

# 一个类可以创建多个对象、 但实例对象的存储地址不同
haier1 = Washer()
haier1.wash()

haier2 = Washer()
haier2.wash()

3. 类里面创建 多个函数

class  Washer():
    def wash(self):
        print('洗衣服')

        print(self.height)

    # 可以创建 多个函数
    def print_num(self):
        print(self.width)

haier = Washer()

# 添加 属性
haier.height = 600
haier.width = 900

# 执行 函数
haier.wash()

haier.print_num()

4. 魔法方法__init__()

class Washer():
    # 定义魔法方法
    def __init__(self):
        # 定义 实例对象的属性
        self.width = 500
        self.height = 800

    def print_info(self):
        print(f'宽度是{self.width}')
        print(f'高度是{self.height}')

haier = Washer()

# __init__() 默认调用，不需要手动调用
# 属性值也不用手动传递
haier.print_info()

5. 带参数的__init__(self)

class Washer():
    # 创建实例属性
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def print_info(self):
        print(f'宽度是{self.width}')

        print(f'高度是{self.height}')

    # 1. 魔法方法 __str__(self) 解释说明
    def __str__(self):
        return '解释说明：  这个类的作用或者特点'

    # py 文件执行完会自动删除， 也就会调用 __del__(self) 方法
    def __del__(self):
        print('删除实例对象')

# 带参数的 __init__(self)
haier1 = Washer(30, 60)
haier1.print_info()

# 2. 魔法方法 __str__(self) 解释说明
# 打印输出的是 return 后面的注释文件
print(haier1)

haier2 = Washer(100, 200)
haier2.print_info()

6. 继承

# 定义一个父类
class A(object):
    # 定义属性
    def __init__(self):
        self.num = 1

    # 定义方法
    def info_print(self):
        print(self.num)

# 定义一个子类
class B(A):
    # 防止报错
    pass

# 验证方法
result = B()

# 调用 父类的方法
result.info_print()  #  1

7. 单继承

# 创建 父类
class Master(object):
    # 定义 属性
    def __init__(self):
        self.name = '[古法煎饼果子]'
    # 定义 方法
    def move_coke(self):
        print(f'调用{self.name}制作煎饼果子')

# 创建 子类 单继承
class Prentice(Master):
    pass

# 创建实例对象
dayou = Prentice()

# 验证使用 实例对象的方法
print(dayou.name)
dayou.move_coke()

8. 多继承

# 创建 父类
class Master(object):
    # 定义 属性
    def __init__(self):
        self.name = '[古法煎饼果子]'
    # 定义 方法
    def move_coke(self):
        print(f'调用{self.name}制作煎饼果子')

class shool(object):
    # 定义 属性
    def __init__(self):
        self.name = '[黑马煎饼果子]'

    # 定义 方法
    def move_coke(self):
        print(f'调用{self.name}制作煎饼果子')

# 创建 子类 继承   重点： 多继承 在继承时 会优先调用第一个继承类的同名属性和方法
class Prentice(shool, Master):
    pass

# 创建实例对象
dayou = Prentice()

# 验证使用 实例对象的方法
print(dayou.name)
dayou.move_coke()

9. 子类和父类拥有同名属性和方法时

# 创建 父类
class Master(object):
    # 定义 属性
    def __init__(self):
        self.name = '[古法煎饼果子]'
    # 定义 方法
    def move_coke(self):
        print(f'调用{self.name}制作煎饼果子')

class shool(object):
    # 定义 属性
    def __init__(self):
        self.name = '[黑马煎饼果子]'

    # 定义 方法
    def move_coke(self):
        print(f'调用{self.name}制作煎饼果子')

# 创建 子类 继承   重点： 多继承 在继承时 会优先调用第一个继承类的同名属性和方法
class Prentice(Master, shool):
    # 子类 和父类拥有同名属性和方法时，优先调用子类的属性和方法
    # 定义 属性
    def __init__(self):
        self.name = '[自创煎饼果子]'

    # 定义 方法
    def move_coke(self):
        print(f'调用{self.name}制作煎饼果子')

# 创建实例对象
dayou = Prentice()

# 验证使用 实例对象的方法
print(dayou.name)
dayou.move_coke()


# 2.  子类继承多个父类属性及方法时， 优先调用第一个父类的属性和方法
# 3.  子类 和父类拥有同名属性和方法时，优先调用子类的属性和方法

10. 实例对象__mro__ 查看继承顺序

# 查看 类的 继承顺序
print(B.__mro__)

11. 子类调用自己的同名属性和方法 同时也可以调用父类的属性和方法

# 创建 父类
class Master(object):
    # 定义 属性
    def __init__(self):
        self.name = '[古法煎饼果子]'
    # 定义 方法
    def move_coke(self):
        print(f'调用{self.name}制作煎饼果子')

    def print_info(self):
        print('Master 父类的方法')

class shool(object):
    # 定义 属性
    def __init__(self):
        self.name = '[黑马煎饼果子]'

    # 定义 方法
    def move_coke(self):
        print(f'调用{self.name}制作煎饼果子')

# 创建 子类 继承   重点： 多继承 在继承时 会优先调用第一个继承类的同名属性和方法
class Prentice(Master, shool):
    # 子类 和父类拥有同名属性和方法时，优先调用子类的属性和方法
    # 定义 属性
    def __init__(self):
        self.name = '[自创煎饼果子]'

    # 定义 方法
    def move_coke(self):
        # 先获取 自己的属性， 因为 获取父类的属性时会替换自己的属性
        self.__init__()
        print(f'调用{self.name}制作煎饼果子')

    # 调用 父类的属性和方法
    def make_Master_cook(self):
        # 先获取 属性  再调用方法
        Master.__init__(self)
        Master.move_coke(self)

    # 调用 父类的属性和方法
    def make_shool_cook(self):
        # 先获取 属性  再调用方法
        shool.__init__(self)
        shool.move_coke(self)



# 创建实例对象
dayou = Prentice()

# 验证使用 实例对象的方法
dayou.move_coke()

# 调用父类的属性和方法
dayou.make_Master_cook()
dayou.make_shool_cook()

# 调用 自己的属性 和方法
dayou.move_coke()

# 调用 Master 的父类的print_info()方法
dayou.print_info()

# 1.  同名属性方法使用起来有些繁琐，后续少用尽量不用
# 2.  子类继承多个父类属性及方法时， 优先调用第一个父类的属性和方法
# 3.  子类 和父类拥有同名属性和方法时，优先调用子类的属性和方法

12. super() 使用 定义私有方法和属性

# 定义 方法
    def move_coke(self):
        # 先获取 自己的属性， 因为 获取父类的属性时会替换自己的属性
        self.__init__()
        print(f'调用{self.name}制作煎饼果子')
        
        # 使用super()调用父类的属性和方法
        super().__init__()
        super().move_coke()


# 定义私有方法和属性
class Prentice(shool):
    # 子类 和父类拥有同名属性和方法时，优先调用子类的属性和方法
    # 定义 属性
    def __init__(self):
        self.name = '[自创煎饼果子]'
        # 设置成为私有属性，不传递给子类
        self.__money = 2000
    # 获取 私有属性
    def get__money(self):
        return self.__money

    # 设置 私有属性
    def set__money(self):
        self.__money = 500
    
    def __info_print(self):
        print('私有方法')

13. 面向对象 多态性

class Dog(object):
    def work(self):
        pass


class ArmyDog(Dog):
    def work(self):
        print('追击敌人...')


class DrugDog(Dog):
    def work(self):
        print('检查毒品...')


class Prenson(object):
    def prenson_with_dog(self, dog):
        print('开始带警犬工作')
        dog.work()

ad = ArmyDog()
dd = DrugDog()

daqiu = Prenson()

daqiu.prenson_with_dog(ad)
daqiu.prenson_with_dog(dd)

14. 类方法 静态方法

# 类方法
class Dog(object):
    __tooth = 10

    # 创建 类方法 获取私有属性
    @classmethod
    def get_tooth(cls):
        return cls.__tooth

wangcai = Dog()

result = wangcai.get_tooth()

print(result)

# 静态方法
class Dog(object):

    @staticmethod
    def info_print():
        print('这是静态方法')

wangcai = Dog()

# 实例对象 和 类 都可以调用类的方法
wangcai.info_print()
Dog.info_print()