面向对象-抽象类

什么是抽象类？
不完整的一种类。
具有抽象方法的类就是抽象类。

什么是抽象方法？
不完整的方法
没有方法体的方法就是抽象方法。

什么是元类？
元类就是用来制作类的类。
正常情况下所有类的元类默认都是type

如何查看一个类的元类
类.__class__
type(类)

查询数据类型
type(对象)
对象.__class__

注意：正常情况下type是系统默认的元类

抽象类的特征：
1.抽象类不能实例化使用
2.抽象类中可以存在抽象方法，也可以存在正常的方法
3.抽象类中是否可以添加成员属性
4.抽象类的使用方式就是被其他类继承。
5.其他类继承了抽象类并且实现了抽象类的所有抽象方法之后就可以实例化该类！

抽象类的实际作用：
1.指定开发程序规范
2.协同程序开发，加速开发效率

 

抽象类1

'''
关于元类：
'''
'''
#定义一个普通的类？
class Car:
    pass

#查看类的元类1
print(type(Car))
#查看类的元类2
print(Car.__class__)
'''

#声明抽象类
#导入抽象类的功能模块
import abc
class User(metaclass = abc.ABCMeta):#注意制作抽象类必须另外指定元类
    #属性
    id = 999

    #定义方法

    #添加用户的方法     对象方法 -> 抽象的对象方法
    @abc.abstractmethod
    def user_add(self):
        pass

    #修改用户的方法     类方法 -> 抽象的类方法
    @abc.abstractclassmethod
    def user_update(cls):
        pass

    #删除用户的方法     绑定类的方法 - > 抽象的绑定类的方法
    @abc.abstractmethod
    def user_del():
        pass

    #查找用户的方法     静态方法 -> 抽象的静态方法
    @abc.abstractstaticmethod
    def user_find():
        pass

    #抽象类中可以有正常的方法
    def user_lock(self):
        print('封禁用户的方法')

#尝试实例化抽象类User
#u = User()

#声明一个类继承User类来使用
class MyUser(User):
    #实现所有抽象类中的方法
    # 添加用户的方法     对象方法
    def user_add(self):
        print('这是一个添加用户的方法')

    # 修改用户的方法     类方法
    @classmethod
    def user_update(cls):
        print('这是一个设置用户的方法')

    # 删除用户的方法     绑定类的方法
    def user_del():
        print('这是一个删除用户的方法')

    # 查找用户的方法     静态方法
    @staticmethod
    def user_find():
        print('这是一个查找用户的方法')

#实例化MyUser类
mu = MyUser()
#print(mu)
#输出结果：<__main__.MyUser object at 0x000002DBE8A100F0>

#调用方法
#调用user_lock方法
#mu.user_lock()
#输出结果：封禁用户的方法

#调用user_add方法
#mu.user_add()
#输出结果：这是一个添加用户的方法

#调用user_update方法
#MyUser.user_update()
#输出结果：这是一个设置用户的方法

#调用user_del的方法
#MyUser.user_del()
#输出结果：这是一个删除用户的方法

#调用user_find方法
#mu.user_find()
#输出结果：这是一个查找用户的方法

 

抽象类2 【指定了开发的规则】

#声明抽象类 【指定了开发的规则】
#导入抽象类的功能模块
import abc
class User(metaclass = abc.ABCMeta):#注意制作抽象类必须另外指定元类
    #属性
    id = 999

    #定义方法

    #添加用户的方法     对象方法 -> 抽象的对象方法 【小赵】
    @abc.abstractmethod
    def user_add(self):
        pass

    #修改用户的方法     类方法 -> 抽象的类方法    【小钱】
    @abc.abstractclassmethod
    def user_update(cls):
        pass

    #删除用户的方法     绑定类的方法 - > 抽象的绑定类的方法 【小孙】
    @abc.abstractmethod
    def user_del():
        pass

    #查找用户的方法     静态方法 -> 抽象的静态方法   【小李】
    @abc.abstractstaticmethod
    def user_find():
        pass

    #抽象类中可以有正常的方法  【自己】
    def user_lock(self):
        print('封禁用户的方法')


#小赵的工作  [但是可以在一个单独的文件中开发]
class XZUser(User):
    # 添加用户的方法     对象方法 【小赵】
    def user_add(self):
        print('添加用户的方法-小赵完成的')


#小钱的工作[但是可以在一个单独的文件中开发]
class XQUser(XZUser):
    # 修改用户的方法     类方法   【小钱】
    @classmethod
    def user_update(cls):
        print('设置用户的方法-小钱完成的')

#小孙的工作[但是可以在一个单独的文件中开发]
class XSUser(XQUser):
    # 删除用户的方法     绑定类的方法【小孙】
    def user_del():
        print('删除用户的方法-小孙完成的')

#小李的工作[但是可以在一个单独的文件中开发]
class XLUser(XSUser):
    # 查找用户的方法     静态方法 -> 抽象的静态方法   【小李】
    @staticmethod
    def user_find():
        print('查找用户的方法-小李完成的')

#这里可以使用小李的类
u = XLUser()

#调用方法
#u.user_lock()
#输出结果：封禁用户的方法

#u.user_add()
#输出结果：添加用户的方法-小赵完成的

#XLUser.user_update()
#输出结果：设置用户的方法-小钱完成的

#XLUser.user_del()
#输出结果：删除用户的方法-小孙完成的

#u.user_find()
#输出结果：查找用户的方法-小李完成的