python面向对象的特征——封装、继承、多态（私有属性和私有方法）

一、封装
封装是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其
含义是其他程序无法调用。
将对象和属性封装起来，使不同的对象具有不同的属性，因此在调用类的时候和将类石烈华的时候需要特备注意

class People():
定义初始化方法
    def __init__(self,name,age):
        self.name = name   类里面的self就是对象本身，name和age都是属性，
        self.age = age     然后将类对象和属性打包并赋值给变量name
    def __str__(self):          定义一般方法，str方法就是返回一个字符串
        return 'I am %s' %self.name        
    def run(self):                                
        print('%s is running...' %self.name)           
p1 = People('laowang',35)  实列化对象
print('p1:',p1.name)    获取名称
p1.run()     调用方法
print(p1)      

p2 = People('laoli',20)
print('p2:',p2.name)
p2.run()
print(p2)
打印结果
p1: laowang
laowang is running...
I am laowang
p2: laoli
laoli is running...
I am laoli

二、继承
1.什么是继承？
继承是一种创建新的类的方式，新创建的叫子类，继承的叫父类、超类、基类。
2.特点：子类可以使用父类的属性（特征、技能）
继承是类与类之间的关系
3.为什么要继承？
减少代码冗余、提高重用性

class Father():
    # 构造方法(初始化方法)在实列化时自动执行
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eta(self):
        print('%s正在吃..' %(self.name))
    def sleep(self):
        print('%s正在睡觉...' %(self.sleep))
        # 定义字类
class Son(Father):
    # 字类没有属性,继承父类的属性和方法
    pass
# 调用父类创建对象
father = Father('老王',18)
# 通过字类间接调用父类创建对象
Son = Son('老李',19)
father.eta()
Son.eta()
打印结果
老王正在吃..   直接调用父类
老李正在吃..    通过子类间接调用父类

class Father():
    # 构造方法(初始化方法)在实列化时自动执行
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eta(self):
        print('%s正在吃..' %(self.name))
    def sleep(self):
        print('%s正在睡觉...' %(self.sleep))
# 定义字类
class Son(Father):
    def eta(self):
        # super(Son,self).eta()  字类中调用父类的第二种方法  
        # Father.eta(self)    字类中调用父类的第一种方法  在子类中执行父类的方法
        print('%s倒立睡觉...' % (self.name))
father = Father('老王',18)
Son = Son('老李',40)   # 通过字类间接调用父类创建对象
# Son.eta()   子类和父类都要eat，都可以调用
Son.eta()   调用父类方法
Son.sleep()    实列化对象默认使用初始化方法，子类没有的方法
打印结果
老李倒立睡觉...  父类与子类都有使用的是子类的方法
<bound method Father.sleep of <__main__.Son object at 0x7fe8f7326a90>>正在睡觉...

多继承

class D():  父类
    def test(self):
        print('test in D...')
class C(D):  d的子类
    def test(self):
        print('test in C...')
class B(D):  d的子类
    pass
    #def test(self):
    #   print('test in B...')
class A(B,C):  b和c的子类
    pass
    # def test(self):
    #    print('test in A...')
a = A()
a.test()
打印结果  A-B-C-D结束
test in C...

三、多态
多态是以封装和继承为前提的，不同的子类对象调用相同的方法，产生不同的结果

class Student(object):
    def get_score(self):
        print('获取学生成绩!')
class Chinese(object):
    def get_score(self):
        print('获取语文成绩!')
class Math(object):
    def get_score(self):
        print('获取数学成绩!')
Student1 = Student()实列化
Student2 = Chinese()
Student3 = Math()
Student1.get_score()  不同对象调用同一个方法产生不同结果
Student2.get_score()
Student3.get_score()
打印结果
获取学生成绩!
获取语文成绩!
获取数学成绩!

新式类：广度优先。旧式类/经典类：深度优先
在python 2需要添加object ，在python2中，若不加object，则是经典类，加了则是新式类
在python 3 中已经默认加载了object（新式类）了即便你没有写上object也是以此为基类

四、私有属和性私有方法
内部可以访问外部不可以直接访问(特殊方法可以访问）
在实际开发中对象的某些属性或方法 可能只希望 在对象的内部被使用，而不希望在外部被访问到
私有属性就是对象不希望公开的属性
私有方法就是对象不希望公开的方法
定义方式
在 定义属性或方法时，在属性名或者方法名前 增加 两个下划线，定义的就是 私有 属性或方法

class Student(object):
    def __init__(self,name,age):  
        self.name = name 定义私有属性
        self.__age = age  
    def __get_info(self):   定义私有方法不能被实列化调用
        print('%s is %s years old' %(self.name,self.__age))
student1 = Student('小黑',20)  实列化
print(student1.name)  内部访问打印name属性
打印结果
小黑

3.2外部不可以直接访问

class Student(object):
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def __get_info(self):
        print('%s is %s years old' %(self.name,self.__age))
student1 = Student('小黑',10)  实列化
# print(student1.name)
print(student1.__age)  外部无法调用打印私有属性
student1.__get_info()   外部无法调用私有方法无法调用  

外部调用python2中不可以双下划綫直接调用
class Student(object):
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def __get_info(self):
        print('%s is %s years old' %(self.name,self.__age))
student1 = Student('小黑',10)
外部调用私有属性和方法
#__age - > _Student__age  
print(student1._Student__age)  
student1._Student__get_info()
打印结果
10
小黑 is 10 years old

3.3私有属性的应用

class Student(object):
    def __init__(self,name,age):  私有属性
        self.name = name
        self.__age = age
    def __get_info(self):   私有方法
        print('%s is %s years old' %(self.name,self.__age))
    def set_age(self,age):   
        if 0 < age < 100:
            self.__age = age
            print('success!')
        else:
            raise Exception('Error!')
student = Student('小黑',10)   实列化
student.__age = 100  修改私有变量的值
print(student.__age)
打印结果
100

注意：私有方法一旦被定义，就不能实列化调用，私有属性可以在类的内部进行转换，然后实列化就可以打印了

class Student(object):
    def __init__(self,name,age):  私有属性
        self.name = name
        self.__age = age
    def __get_info(self):  私有方法
        print('%s is %s years old' %(self.name,self.__age))
    def get_age(self):      转换私有属性
        print(self.__age)
    def set_age(self,age):
        if 0 < age < 100:
            self.__age = age
            print('success!')
        else:
            raise Exception('Error!')
student = Student('小黑',10)
student.__age = 100
# print(student.__age) 无法直接调用私有属性
# student.__get_info()
student.set_age(80)  调用私有属性
打印结果
success!