python 封装、抽象、多态和继承的实现

封装的实现

# 封装
class people:
    def __init__(self,name,money):
        self.name = name
        self.__money = money # 私有属性，只能类的内部使用--》数据封装
    # def __say(self):
    #     #     print('我是私有方法')
    #方法的封装：通过公有的方法来访问私有的属性
    def getMoney(self):
        return self.__money
    def setMoney(self,money):
        self.__money = self.__money +money
    # def run_setMoney(self):
    #     self.__setMoney()
zs = people('张三',100)
#在类的外部私有属性、方法可以通过  对象._类名__私有属性、方法  的方式进行访问
print(zs._people__money)
# print(zs._people__say())
print(zs.getMoney())
zs .setMoney(200)
print(zs.getMoney())

继承的实现

#继承：一个类获取另外一个类的属性和方法的过程
# 子类获取父类的属性或者方法
#人类：属性name age sex 方法：say（） sleep（）
#学生：属性name age sex studentid ...  方法：say（） sleep（） study() ...
class people:  # 父类
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def say(self):
        print('我是一个正直的人')
    def sleep(self):
        print('我是人类，需要休息8个小时')
    def __driver(self): #父类的私有方法不能被继承。
        print('我是老司机有驾驶技能')

class student(people):  #子类  继承people
    # studentid = None
    #父类有构造方法的话，子类必须实现构造方法
    def __init__(self,name,age,sex,studentid):
        #方法1：调用父类的构造方法，必须要传self
        # people.__init__(self,name,age,sex)
        #方法2 使用super,不需要传self
        # super().__init__(name,age,sex)
        #方法3 使用super，此时第一个参数要写子类的名称
        super(student, self).__init__(name,age,sex)
        self.studentid = studentid

    def study(self):
        print('我是学生，需要学习')
    def sleep(self):
        print('我是学生，只能休息7个小时')
yt = student('chouchou',22,'女',777)
# yt.name = 'chouchou'
print(yt.name,yt.age,yt.sex)
yt.say()
# yt.sleep()#子类重写父类方法时，默认调用子类的方法
yt.study()
# yt._people__driver()  #调用父类私有方法
# 子类重写方法后调用父类的方法。
# people.sleep(yt)
super(student,yt).sleep()

多继承的实现

#多继承： 一个子类中含有多个父类
# 人类--教师--司机
class people: # 父类
    def __init__(self,name):
        self.name = name
    def say(self):
        print('我是人类')
    def sleep(self):
        print('我需要睡觉')
class teacher: # 父类
    def __init__(self,Course_name):
        self.Course_name = Course_name
    def say(self):
        print('我是一个阳光型老师，我会教书')
    def play(self):
        print('我教体育，主要是篮球')
# 子类：老师晚上兼职跑滴滴
class driver(teacher,people):  # 两个父类
    def __init__(self,name,Course_name,driverYeas):
        people.__init__(self,name)
        teacher.__init__(self,Course_name)
        self.driverYeas = driverYeas
    # def say(self):   #多继承中假如父类中有同名的方法,那么就按照父类的先后顺序进行调用
    #     print('我是一名老师，兼职跑滴滴')

# 实现
zhuzhu = driver('猪猪','体育',5)
print(zhuzhu.driverYeas)
zhuzhu.say()
print(zhuzhu.name,zhuzhu.Course_name,zhuzhu.driverYeas)

抽象类和抽象案例的实现

from abc import ABCMeta, abstractmethod


# 抽象类
# 1.抽象类中要有抽象方法
# 2.要有抽象类的定义语句
# 3.抽象类是用来被继承的。如果没有被继承那么毫无意义。
class animal(metaclass=ABCMeta):  # 定义抽象类 ，此方法子类强制性必须实现父类的抽象方法
    # __metaclass__ = ABCMeta # 定义抽象类，此方法子类必须实现父类的抽象方法
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex

    # 抽象方法
    @abstractmethod
    def say(self):  # 只定义，不实现具体内容，子类必须实现父类的抽象方法  强制使子类实现父类方法
        pass  # 不会实现任何语句块


class dog(animal):  # 父类是抽象类 1、实现父类的抽象方法  2、子类本身也是抽象类
    def __init__(self, name, sex):
        super().__init__(name, sex)

    def say(self, color):
        print(f"{self.name}我是子类必须实现父类的方法{color}")


xiaohuang = dog('小黄', 2)
print(xiaohuang.name)
xiaohuang.say('hello world')

from abc import ABCMeta, abstractmethod


# 学生--去教室学习
# 老师--去教室上课
# people:name age   方法：goto_class
class people(metaclass=ABCMeta):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @abstractmethod
    def goto_class(self):
        pass


class student(people):
    def __init__(self, name, age, studentid):
        people.__init__(self, name, age)
        self.studentid = studentid

    # 防止开发忘记写goto_class方法
    def goto_class(self):
        print(f'我是学生，学号是{self.studentid}')


class teacher(people):
    def __init__(self, name, age, courseName):
        people.__init__(self, name, age)
        self.courseName = courseName

    def goto_class(self):
        print(f'我是老师，去上{self.courseName}课')


lisi = student('李四', 18, 2)
zhangshan = teacher('张老师', 35, 'python')
print(lisi.name)
lisi.goto_class()
zhangshan.goto_class()

多态的实现

from abc import ABCMeta,abstractmethod
# 多态：一类事物具有多种形态，多态的前提试试必须要实现继承
# 多态性 ：多态性是指具有不同功能的函数可以使用相同的函数名
# txt 文件 --双击  打开查看内容
# exe程序 --双击 打开程序
# MP4视频 --双击 播放视频
class File(metaclass=ABCMeta):
    @abstractmethod
    def duoble_click(self):
        pass
# 多态
class txtFile(File):
    def duoble_click(self):
        print('打开txt文件，查看内容')

class exeFile(File):
    def duoble_click(self):
        print('打开exe程序，运行程序')

class mp4File(File):
    def duoble_click(self):
        print('打开mp4，播放视频')
# 多态性
def d_click(file_obj):
    file_obj.duoble_click()

txt = txtFile()
exe = exeFile()
mp4 = mp4File()

# 调用实现多态性
d_click(txt)
d_click(exe)
d_click(mp4)