Python 面相对象编程，类

# 类的 实例化, 以及继承。
# 把一个抽象的类变成一个具体的对象的过程， 叫实例化。

class Role(object):
    def __init__(self,name,role,weapon,life):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life = life

    def buy_weapon(self,weapon):
        self.weapon = weapon
        print("[%s] buy weapon [%s]" %(self.name,weapon))

    def info(self):
        print('''
        ------个人信息-------
            姓名：%s
            身份：%s
            武器：%s
            生命：%s
        ---------------------
        ''' %(self.name,self.role,self.weapon,self.life))

p1 = Role('jicki','警察','手枪',100)
p2 = Role('luck','匪徒','机关枪',100)
p1.info()
p2.info()
p1.buy_weapon('AK47')
p2.buy_weapon('狙击枪')
p1.info()
p2.info()



打印结果：

------个人信息-------
姓名：jicki
身份：警察
武器：手枪
生命：100
---------------------

------个人信息-------
姓名：luck
身份：匪徒
武器：机关枪
生命：100
---------------------

[jicki] buy weapon [AK47]
[luck] buy weapon [狙击枪]

------个人信息-------
姓名：jicki
身份：警察
武器：AK47
生命：100
---------------------

------个人信息-------
姓名：luck
身份：匪徒
武器：狙击枪
生命：100
---------------------

 

# 类的继承
class ShoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.enroll()

    def enroll(self):
        print("[%s] 加入了学校" %self.name)

    def tell(self):                            # 所有类 公有方法
        print("大家好，我的名字叫[%s]" %self.name)

class Teacher(ShoolMember):       #继承了 ShoolMember 类
    def __init__(self,name,age,sex,coures,salary):    # 重写 ShoolMember 父类的构造方法__init__
        super(Teacher,self).__init__(name,age,sex)    # 新式类 的继承，继承了父类的__init__
        self.coures = coures
        self.salary = salary

    def teaching(self):                              # Tenacher 类 私有方法
        print("[%s] 是教 [%s] 课程" %(self.name,self.coures))

class Student(ShoolMember):    #继承 ShoolMember 类
    def __init__(self,name,age,sex,coures,tuition):    # 重写 ShoolMember 父类的构造方法__init__
        super(Student,self).__init__(name,age,sex)     # 新式类 的继承，继承了父类的__init__
        self.coures = coures
        self.tuition = tuition

    def pay_tuition(self):                           # Student 类 私有方法
        print("[%s] 学习 [%s] 课程交了 [%s] 学费" %(self.name,self.coures,self.tuition))

# 实例化
t1 = Teacher("alax",22,'F','Python',10000)
t2 = Teacher('wupeiqi',23,'F','Python',10000)
s1 = Student('jicki',22,'F','Python',6000)

t1.teaching()       # 调用 Teacher 私有方法
s1.pay_tuition()    # 调用 Student 私有方法

t1.tell()     # 调用共用 方法
s1.tell()     # 调用共用 方法


输出结果：
[alax] 加入了学校
[wupeiqi] 加入了学校
[jicki] 加入了学校
[alax] 是教 [Python] 课程
[jicki] 学习 [Python] 课程交了 [6000] 学费
大家好，我的名字叫[alax]
大家好，我的名字叫[jicki]

 

Python 多态：
    多态性 允许子类类型的指针赋值给父类类型的指针。
    多态的作用是什么？  
    我们知道，封装可以隐藏实现细节，使的代码模块化；
    继承可以扩展已存在的代码模块（类）；
    封装与继承的目的都是为了 代码重用。
    而多态则是为了实现 接口重用，多态的作用就是为了类的继承和派生的时候，保证能使用类的成员中任意类的实例的某一属性时的正确调用。
    

Python 是不支持多态的，可以使用如下方法实现：

class Animal(object):
    def __init__(self,name):
        self.name = name
        
    def talk(self):
        raise NotImplementedError("Subclass must implement")
        
class Cat(Animal):
    def talk(self):
        return 'miao, miao !'
        
class Dog(Animal):
    def talk(self):
        return 'wang wang !'
        

def animal_talk(obj):
    print(obj.talk())
    
d = Dog("WangCai")
c = Cat("BoSi")

animal_talk(c)
animal_talk(d)


输出结果：
miao, miao !
wang wang !

 

 

 

 

类的成员可以分为三大类：字段，方法，属性


                            普通字段
                    字段：
                            静态字段
        
                            普通方法
        类成员        方法：    类方法
                            静态方法
        
        
                    属性：    普通属性
                    
                    

一、字段：
    字段包括： 普通字段 和 静态字段，他们在定义和使用中有所区别，本质区别是 内存中保存的位置不同。
    
    普通字段属于 对象 (实例变量)
    静态字段属于 类   (类变量)
    
    
    
    
类的装饰器：

    1. @classmethod ，类方法，  不能访问实例变量。
    
    2. @staticmethod, 静态方法， 既不能访问实例变量，也不能访问类变量。
    
    3. @property,  把方法变成属性，调用不需要加()