关于python:Python面向对象的三大特征封装继承多态

面向对象的三大特色：

封装：

• 将数据（属性）和行为（办法）包装到类对象中。在办法外部对其属性进行操作，在类对象内部调用办法。这样，无需关系外部办法的实现细节，隔离了复杂性。
• 在 Python 中没有专门的修饰符用于属性的公有，如果该属性不心愿被类对象内部被拜访，属性名前应用两个“_”。

class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 暗藏属性

    def get_age(self):
        print(self.__age)


stu = Student('Alen', 20)
stu.get_age()  # 20
# print(stu.__age)  # AttributeError: 'Student' object has no attribute '__age'
print(stu._Student__age)  # 20，非凡办法能够获取，不倡议应用

继承

语法：class 子类类名(父类 1, 父类 2...):

• 一个类没有继承任何类，则默认继承 object。
• Python 反对多继承。
• 定义子类时，必须在其构造函数中调用父类的构造函数。

代码示例：

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

    def info(self):
        print(self.name, self.age)


class Student(Person):
    def __init__(self, name, age, score):
        super().__init__(name, age)
        self.score = score


class Teacher(Person):
    def __init__(self, name, age, job_title):
        super().__init__(name, age)
        self.job_title = job_title


stu1 = Student('张三', 15, 55)
stu1.info()  # 张三 15
tec1 = Teacher('李老师', 42, '班主任')
tec1.info()  # 李老师 42

办法重写

父类的某个属性或者形式不满足子类的应用要求时，子类能够在其办法体内进行重写。

子类重写后的办法中能够通过 super(). 父类办法名() 调用父类中被重写的办法。

代码示例：

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

    def info(self):
        print('姓名：', self.name, '，年龄：', self.age)


class Student(Person):
    def __init__(self, name, age, score):
        super().__init__(name, age)
        self.score = score

    def info(self):  # 重写 info 办法
        super().info()  # 调用父类的办法
        print('问题：', self.score)


stu1 = Student('张三', 15, 55)
stu1.info()  # 姓名：张三，年龄：15  问题：55

object 类

object 类是所有类的父类，因而所有类都有 object 类的属性和办法。

• 内置函数 dir() 能够查看晓得对象所有的属性
• object 有一个 __str__() 办法，用于返回对于“对象的形容”，对应于内置函数 str() 罕用于 print() 办法，帮咱们查看对象的信息，所以常常会对 __str__() 进行重写

class Student:
    def __init__(self, name, age, score):
        self.score = score
        self.name = name
        self.age = age

    def __str__(self):  # 重写了对象的形容
        return '姓名：'+self.name+'，年龄：'+self.age+'，问题：'+self.score


stu1 = Student('张三', '15', '55')
print(dir(stu1))  # 查看对象所有属性，继承于 object 类

# ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
# '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'score']

print(stu1)  # 默认调用__str__()办法；输入：姓名：张三，年龄：15，问题：55

多态

多态：具备多种状态，指：即使不晓得一个变量所援用的对象到底是什么类型，依然能够通过这个变量调用办法，在运行的过程中依据变量所援用对象的类型，动静地决定调用哪个对象中的办法。

class Animal:
    def eat(self):
        print('动物吃货色')


class Dog(Animal):
    def eat(self):  # 重写父类办法
        print('狗吃骨头')


class Cat(Animal):
    def eat(self):  # 重写父类办法
        print('猫吃鱼')


class Human:
    def eat(self):
        print('人吃各种美食')

        
def fun(a):
    a.eat()


fun(Animal())  # 动物吃货色
fun(Dog())  # 狗吃骨头
fun(Cat())  # 猫吃鱼
fun(Human())  # 人吃各种美食

动态语言和动静语言对于多态的区别

Python 是动静语言，Java 是动态语言。

动态语言事项多态的三个必要条件：

• 继承
• 办法重写
• 父类援用指向子类对象

动静语言的多态：不关怀对象的类型，只关怀对象的行为。有指定的行为即可执行。