面向对象

面向对象两个基本概念

类 定义了一件事物的抽象特点
对象 类的一个实例

类的特性：
-封装
-继承
-多态

定义类

class Programer(object):

1.定义类的属性

#直接定义
class Programer(object):
    hobby = "play computer"

per = Programer()#实例化一个类
print(per.hobby)
>>paly computer
#使用构造函数定义
class Programer(object):
    def __init__(self, name, age, weight):
        self.name = name #共有属性
        self._age = age #私有属性，但也可以访问
        self.__weight = weight #类自身内部可以访问，如下面get_weight函数中，但实例化类不可直接访问
    def get_weight(self):
        return self.__weight

per = Programer('gavin', 25, 70)
#print(dir(per)) #dir函数可以列出对象全部属性
print(per.name)
print(per._age)
#print(per.__weight) #这种写法无法访问到，即实例化类不可直接访问
print(per._Programer__weight) #查看print(dir(programer))结果可知programer有的是_Programer__weight属性
print(per.get_weight()) #类自身内部访问
>>gavin
>>25
>>70
>>70

2.定义类的方法（方法也可以看成是属性）

-函数 直接用函数名调用
-方法 须和对象联系在一起，是类的一部分

方法的定义和前面属性一样，另外还有两种关于方法的装饰器
@classmethod 调用的时候直接用类名，而不是某个对象
@property 像访问属性一样调用方法

class Example(object):
    def TestA(self):
        print("公有方法")

    def _TestB(self):
        print("私有方法")

    def __TestC(self):
        print("不可直接调用")


    @classmethod
    def TestD(self):
        print("直接调用类名")

    @property
    def TestE(self):
        print("像访问属性一样")

if __name__ == "__main__":
    exam = Example()
    exam.TestA()
    exam._TestB()
    #exam.__TestC() #这样写无法访问
    exam._Example__TestC()
    Example.TestD()  #调用的时候直接用类名
    exam.TestE  #像访问属性一样调用方法
>>共有方法
>>私有方法
>>不可直接调用
>>直接调用类名
>>像访问属性一样

类的继承

子类会继承父类的属性和方法
也可以自己定义，覆盖父类的属性和方法，不会影响其他继承父类的子类

-用Super()调用父类的方法(推荐，体现了继承):

class A(object):
    def methodA(self, arg):
        pass
class B(A):
    def methodB(self, arg):
        super(B, self).methodA(arg)

-用父类名调用父类方法：

class A(object):
    def methodA(self, arg):
        pass
class B(A):
    def methodB(self, arg):
        A.methodA(arg)

类的类型判断：
isinstance #判断是否实例
issubclass #判断是否子类

多继承

class DerivedClassName(Base1, Base2, Base3)：
    pass

类的多态

多态的要素：
-继承
-方法重写

类的继承和多态栗子

#coding: utf-8

class Programer(object):
    hobby = 'Play Computer'

    def __init__(self, name, age, weight):
        self.name = name  #可公开访问
        self._age = age   #表私有属性，但也是可以访问的
        self.__weight = weight   #类自身内部可以访问，如下面get_weight函数中，但实例化类不可直接访问，如下

    def get_weight(self):
        return self.__weight

    def introduce(self):
        print('I am {},{} years old'.format(self.name, self._age))

class BackendProgramer(Programer): #类的继承
    def __init__(self, name, age, weight, language):
        super(BackendProgramer, self).__init__(name, age, weight)
        self.language = language

    def introduce(self):#重写类的方法

        print('I am %s\nMy favorite language is %s'%(self.name, self.language))

def introduce(programer):
    if isinstance(programer, Programer):#判断programer是否实例Programer
        programer.introduce()

if __name__ == '__main__':
    per = Programer('gavin', 25, 70)
    backper = BackendProgramer('小明', 30, 75, 'python')
    #print(dir(per))  #dir函数查看属性
    #print(dir(backper))  #可以看到和上面的属性一样，多了language属性
    introduce(per)
    introduce(backper)
>>I am gavin,25 years old
>>I am 小明
>>My favorite language is python