python面向对象（2）

面向对象有三大特征：封装、继承、多态

1、封装

封装：顾名思义就是将事物的属性隐藏起来，保证其不能被随意的修改

怎么封装：封装其实就是把属性定义为私有属性，定义私有属性和访问私有的属性都有特定的方法。一般使用set来设置私有属性，使用get来获得私有属性，在设置私有属性时需要给属性前加__。

class Object:
    def __init__(self,name,age,sex):
        self.name=name
        self.__age=age
        self.__sex=sex
    def setage(self,maxage):
        self.__age=maxage
    def setsex(self,s):
        self.__sex=s
    def getage(self):
        if self.__age>0 and self.__age<=150:
            return self.__age
        else:
            return "数据不符合常理"
    def getsex(self):
        if self.__sex =='male' or self.__sex=='female':
            return self.__sex
        else:
            return "false"
p=Object("Allen",20,'male')
print(p.getage(),p.getsex())
#在尝试一下：
p.age=15
p.sex='female'
print(p.getage(),p.getsex())

　通过以上代码可以看出，函数被封装后，不能随意修改

2、继承

含义：类似于现代社会的继承，父业子承

class 子类名（父类名）

假设有一个类A，B是A的子类则：

class A(object)

class B(A)

class Door():
    def __init__(self,height,width):
        self.height=height
        self.width= width
    def openDoor(self):
        print('the door is opening.')
    def closeDoor(self):
        print('the door is closed')

class SafeDoor(Door):
    def newsafedoor(self):
        print('width is '+ str(self.width))
mydoor=SafeDoor(20,30)
mydoor.newsafedoor()

3、多态

含义：多态就是指一类事物有多种形态。

多态的作用：应用程序无需为每一个程序编写功能调用，只需要对父类进行处理即可，大大提高了程序的可复用性。

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        return 'I am a Person, my name is %s' % self.name
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def whoAmI(self):
        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def whoAmI(self):
        return 'I am a Teacher, my name is %s' % self.name

def who_am_i(x):
    print( x.whoAmI())

p = Person('Allen', 'Male')
s = Student('Tony', 'Male', 22)
t = Teacher('Andy', 'Female', 'English')

who_am_i(p)
who_am_i(s)
who_am_i(t)

方法调用将作用在 x 的实际类型上。s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。

由于Python是动态语言，所以，传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以，只要它有一个whoAmI()的方法即可