面向对象--02面向对象的三个基本特征

1.面向对象的三大特征 之 封装
通常把隐藏 属性、方法与方法实现细节 的过程 称为封装

为了保护类里面的属性，避免外界随意赋值，可以采用以下方法解决：
①把属性定义为私有属性，即属性名前加两个下划线

②添加可以供外界调用的两个方法，分别用于设置或者获取属性值

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    #给私有属性赋值
    def setnemage(self,newage):
        if newage > 0 and newage <= 120:
            self.__age = newage
    #获取私有属性
    def getage(self):
        return self.__age

>>> laowang = Person('老王',30)
>>> laowang.name
'老王'
>>> laowang.__age
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    laowang.__age
AttributeError: 'Person' object has no attribute '__age'
>>> laowang.getage()
30
>>>

2.面向对象的三大特征 之 继承

父类的私有属性和私有方法是不会被子类继承的，更不能被子类访问。

注意：当一个类的内部定义了私有方法或者私有属性的时候，Python在运行的过程中，把属性或者方法的名字（不带两个下划线）进行了修改，即在属性或者方法名称的前面加上'_类名'，导致原有的方法和属性无法被访问到。

语法：
class 子类（父类1，父类2，····）


①重写父类的方法

例：

#定义表示人的类
class Person(object):
    #打招呼的方式
    def sayhello(self):
        print('--hello--')

#定义Chinese类继承自Person类
class Chinese(Person):
    #中国人打招呼的方式
    def sayhello(self):
        print('吃了吗')

#创建Chinese类的对象
chinese = Chinese()
chinese.sayhello()

#创建另一个实例
eng = Person()
eng.sayhello()

>>> 吃了吗
>>> --hello--

2.1
如果子类想要调用父类中被重写的方法，需要使用super方法访问父类中的成员。
super() 函数用于调用下一个父类(超类)并返回该父类实例的方法。

语法：
super(cls[, object-or-cls])

cls                -->          类

object-or-cls       -->   一般是 self

例：

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)

        
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类B的对象 FooChild 转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)

>>> fooChild = FooChild()
Parent
Child
>>> fooChild.bar('HelloWorld')
HelloWorld from Parent
Child bar fuction
I'm the parent.
>>>

例：

#定义父类Animal
class Animal(object):
    def __init__(self,legnum):
        #腿的数量
        self.legnum = legnum

#定义Bird类继承自Animal
class Bird(Animal):
    #重写了父类的init方法
    def __init__(self,legnum):
        #增加特有的属性
        self.plume = '白色'
        #调用父类的init方法
        super().__init__(legnum)

bird = Bird(2)
print('有一只%s条腿%s羽毛的鸟儿在树上唱歌'%(bird.legnum,bird.plume))

>>>有一只2条腿白色羽毛的鸟儿在树上唱歌

2.2
当使用继承不合适时，可用组合

class Turtle:
    def __init__(self,x):
        self.num = x

class Fish:
    def __init__(self,x):
        self.num = x

class Pool:
    def __init__(self,x,y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)

>>> pool=Pool(1,2)
>>> pool.turtle.num
1
>>>


所谓组合就是把类的实例化放到一个新类里面，组合用于横向 没有继承关系的类放在一起。

3.面向对象的三大特征 之 多态
调用同一个方法，出现了两种表现形式，这个过程体现的就是多态

在Python中，多态指在不考虑对象类型的情况下使用对象。Python更推崇‘鸭子类型’。也就是想说，它不关注对象的类型，而是关注对象的具体行为。