【python入门】day14：面向对象的三大特征：封装、继承、多态

封装的实现方式

封装：提高程序的安全性。
将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，
在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔
离了复杂度。在Python中没有专门的修饰符用于属性的私有，如果有该属性不
希望在类对象外部被访问，前边使用两个“_”。

继承：提高代码的复用性。
多态：提高程序的可扩展性和可维护性。

class Car:
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('汽车已启动！')

car=Car('宝马X5')
car.start()
print(car.brand)

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age #年龄不希望在类的外部被使用，所以加了两个__
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
#在类的外面使用name和age
print(stu.name)
#print(stu.__age)
print(dir(stu))
print(stu._Student__age) #在类的外部可以通过 _Student_age进行访问

继承及其实现方式

例如下面这个例子，教师类和学生类都继承了人类。而管理员类同时继承了教师类和学生类，是区别于Java的，Java不能继承多个类，而这里python可以。

class Person(object):
    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,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no

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

stu=Student('张三',20,'1001')
teacher=Teacher('诸葛亮',34,10)
stu.info()
teacher.info()
## 多继承
'''java是不可以继承多个类,java是单继承的,但是java通过接口可以实现多继承,
也就是说,一个java类只能继承一个父类,但可以有多个接口;
python可以继承多个类。
python如果继承多个类,其寻找方法有两种:深度优先和广度优先。
'''
## 新建一个管理员类，管理员有老师也有学生
class Admin(Student,Teacher):
    pass

方法重写

沿用上面的例子

class Developer(Person):
    def __init__(self,name,age,stack):
        super().__init__(name,age)
        self.stack=stack
    def info(self):
        super().info()
        print('技术栈',self.stack)
stu.info()
teacher.info()
deve=Developer('Steve Jobs',26,'Java')
deve.info()

object类

默认object是任何的父类

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

    def __str__(self):      #返回对象的描述
        return '我的名字是{0}，今年{1}岁了'.format(self.name, self.age)


stu = Student('张三', 20)
print(dir(stu))
print(stu)      #默认会调用__str__方法
print(type(stu))

多态的实现

#鸭子类型，动作像鸭子，不关心其父类具体是谁，只关心其行为
#py是动态语言，静态语言实现多态的必要条件：继承，方法重写，父类引用指向子类对象(java)
class Animal(object):
    def eat(self):
        print('动物要吃东西')

class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')

class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')

class Person(object):
    def eat(self):
        print('人吃五谷杂粮')

def fun(obj):
    obj.eat()

fun(Cat())
fun(Dog())
fun(Animal())
print('-------------')
fun(Person())

静态语言实现多态的三个必要条件 Java就是静态语言
1.继承
2.重写
3.父类引用指向子类对象

注意：动态语言的堕胎崇尚’鸭子类型‘当看到一只鸟走起来像鸭子、游泳像鸭子、收起来也像鸭子，呢么这只鸟就可以被称为鸭子。在鸭子的类型中，不需要关系对象是什么类型，到底是不是鸭子，只关心对象的行为。

python特殊属性

dir查看属性和方法
init创建对象
dict 字典查询
class 查看所属的类
base c父类类型的元组

静态语言和动态语言

静态语言：JAVA，必须明确继承关系！
动态语言：python,在鸭子类型中，只关心对象的行为像不像鸭子，不用关心他是谁的子类！