python基础之面向对象的三大特性

面向对象的三大特征——封装、继承、多态

封装

为什么要封装
为了数据的安全性，降低代码的耦合度
表现形式
将一组具有统一功能和相关的代码，抽象成一个函数或一个类或类的方法
三种权限级别
为了保护数据的安全性，在定义类的时候具有三种权限级别。分别是公有，私有，保护

正常新建一个类，实例化，调用是这样的

那我如果不想让外部知道我的收入是多少，把收入设为私有属性，然后在外部就无法访问了
设为私有属性就是在当前属性的前面加两个下划线
设为私有属性在外面就无法访问了，提示类中没有这个属性

所有的属性，只要前面加了双下划綫，就变成了私有属性，外界无法访问。安全性最高

外界要是想访问私有属性怎么办？
在类中专门定一个访问私有属性的接口，在外部通过访问接口来获取私有属性。在接口中可以做一些操作，来确保你是内部的人。

修改私有属性
也是要在类里定一个修改的接口，在里面做一些操作（例如校验），然后在外部调用这个接口来修改

如果没有定义私有属性，任何一个可以引用该属性的位置都可以修改，不安全

私有方法
私有方法不能在外部直接调用，只能在类的内部设置公共方法来调用私有方法，然后在外部调用这个公共方法
公共方法里边可以添加校验，验证通过之后再修改

保护
“保护”是前面加一个下划线的，是受保护的标志。外面可以访问可以修改，但是加了受保护的标志为了告诉别人，这个属性是受保护的，不要随便修改。
我在类中新加了一个受保护的属性：_address
在外部也是可以访问可以修改的，只是不能随便修改

继承

类是可以相互继承的
子类可以继承多个父类，父类可以被多个子类继承
父类的私有属性不能直接用
子类拥有父类的私有属性，但是引用的方法比较特殊（一般不用）

继承后子类拥有父类的所有属性和方法

父类的初始化方法会给父类添加属性
实例化子类的时候，就必须要添加这些属性，否则就会报错
即：父类的初始化方法也会被子类继承

也可以在子类中添加子类独有的方法

子类也可以重写自己的初始化方法
调用父类的初始化方法，并增加子类的方法
这样子类会具有比父类更丰富的方法和属性，在父类的基础上进行扩展

多层继承
Staff继承Human，ArtDesigner继承Staff

class Human():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def eat(self):
        print("i eat something")

    def run(self):
        print("i run away")

    def work(self):
        print("do something get money")


class Staff(Human):
    def __init__(self, name, age, gender, department, salary_dep):
        # 显示调用父类Human的初始化方法
        Human.__init__(Human, name, age, gender)
        # 定义自己的
        self.department = department
        self.salary_dep = salary_dep

    def come_to_work(self):
        print("来公司上班")


class ArtDesigner(Staff):
    # 重写子类自己的初始化方法
    def __init__(self, name, age, gender, department, salary_dep, salary):
        # 显示调用父类Staff的初始化方法
        Staff.__init__(Staff, name, age, gender, department, salary_dep)
        # 增加一个子类的实例属性
        self.salary = salary

    def draw_picture(self):
        print("draw a picture")

    def work(self):
        print("artdesigner's work is draw pictures")


one_art = ArtDesigner("小雅", 22, "female", "美工部", 6000, 6600)
# Human的属性
print("one_art.name", one_art.name)
print("one_art.age", one_art.age)
print("one_art.gender", one_art.gender)
# Staff的属性
print("one_art.department", one_art.department)
print("one_art.salary_dep", one_art.salary_dep)
# ArtDesigner的属性
print("one_art.salary", one_art.salary)

one_art.come_to_work()
one_art.work()

多重继承
一个子类继承多个父类

class Human():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def eat(self):
        print("i eat something")

    def run(self):
        print("i run away")

    def work(self):
        print("do something get money")


class Staff(Human):
    def __init__(self, name, age, gender, department, salary_dep):
        # 显示调用父类Human的初始化方法
        Human.__init__(Human, name, age, gender)
        # 定义自己的
        self.department = department
        self.salary_dep = salary_dep

    def come_to_work(self):
        print("来公司上班")

 
class ArtDesigner(Staff):
    # 重写子类自己的初始化方法
    def __init__(self, name, age, gender, department, salary_dep, salary):
        # 显示调用父类Staff的初始化方法
        Staff.__init__(Staff, name, age, gender, department, salary_dep)
        # 增加一个子类的实例属性
        self.salary = salary

    def draw_picture(self):
        print("draw a picture")

    def work(self):
        print("artdesigner's work is draw pictures")


class TestEngineer(Staff):
    def run_test(self):
        print("run test")


one_art = ArtDesigner("小雅", 22, "female", "美工部", 6000, 6600)
one_test = TestEngineer("王大力", 30, 'male', "测试部", 8000)


# 多重继承，一个子类继承多个父类
class Master(ArtDesigner, TestEngineer):
    def __init__(self, name, age, gender, department, salary_dep, salary):
        ArtDesigner.__init__(ArtDesigner, name, age, gender, department, salary_dep, salary)
        TestEngineer.__init__(TestEngineer, name, age, gender, department, salary_dep)


print("---多重继承")
one_master = Master("乐老师", 30, "male", "乐博学院", 10000, 15000)
print(one_master.name, one_master.department, one_master.salary_dep)

one_master.run()
one_master.come_to_work()
one_master.draw_picture()
one_master.run_test()

多态

就是重写。在子类中重写父类的某个方法