WEEK6：面向对象编程

• 面向对象介绍
  
  • 类
    一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性、共同方法
  • 对象
    一个对象即是一个类的实例化后的实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可有不同的属性。
• 特性
  • 封装
    在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或者容器，里面包含着类的数据和方法
  • 继承
    一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
    py2 经典类是按深度优先来继承的，新式类是按广度优先来继承的。py3经典类和新式类都是统一按广度优先来继承的
  • 多态
    态是面向对象的重要特性，简单点说“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一件事物表现出的多种形态。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
    

    #class People: #经典类
    class People(object): #新式类
        def __init__(self,name,age):
            self.name=name
            self.age=age
            self.friends=[]
        def eat(self):
            print("%s is eating..." %self.name)
        def talk(self):
            print("%s is talking..." %self.name)
        def sleep(self):
            print("%s is sleeping..." %self.name)
    
    class Relation(object):
        def make_friends(self,obj):
            print("%s is making friends with %s"%(self.name,obj.name))
            self.friends.append(obj) #不能使用obj.name,否则obj的name修改之后不能同步到朋友列表中
    
    #子类1
    class Man(People,Relation): #多类继承,继承顺序为从左到右依次继承
        #添加新变量
        def __init__(self,name,age,money):
            #People.__init__(self,name,age) #此方法在多继承的时候无法使用
            #或者使用下面方法继承父类参数
            super(Man,self).__init__(name,age)
            self.money=money
            print("%s 一出生就有 %s money"%(self.name,self.money))
    
        def piao(self):
            print("%s is piaoing...20s...done" %self.name)
        #给父类方法添加新功能
        def sleep(self):
            People.sleep(self) #保留父类的方法
            print("man is sleeping")
    #子类2
    class Woman(People,Relation):
        def get_birth(self):
            print("%s is born a baby..."%self.name)
    
    #子类1的实例
    m1=Man("NiuHanYang",22,10)
    m1.eat()
    m1.piao()
    m1.sleep()
    
    #子类2的实例
    w1=Woman("ChenRonghua",26,)
    w1.get_birth()
    
    m1.make_friends(w1)
    print(m1.friends[0].name)

     

• 语法
  • 属性
  • 方法
  • 构造函数
  • 析构函数
    在实例释放、销毁（或删除变量）的时候自动执行的，通常用语做一些收尾工作，例如关闭一些数据库连接、关闭打开的一些临时文件等
  • 私有方法、私有属性
  • 类变量
    大家共用的属性，节省开销
  • 实例变量
    

    #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写
    class Role(object):
        #类变量
        n=123
        name="我是类name"
        n_list=[]
    
        #初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
        def __init__(self, name, role, weapon, life_value=100, money=15000):
            #构造函数：在实例化时做一些类的初始化工作
            self.name = name #实例变量（静态属性），作用域就是实例本身
            self.role = role
            self.weapon = weapon
            self.__life_value = life_value #私有属性，格式为__xxx,对外隐藏，类内可见
            self.money = money
    
        #析构函数,函数名为__xxx__，程序执行完毕之后再执行
        def __del__(self):
            print("%s 彻底死了....." %self.name)
    
        #类的方法，功能（动态属性）
        def show_status(self):
            print("name:%s weapon:%s life_val:%s"%(self.name,self.weapon,self.__life_value))
        def got_shot(self):
            print("ah...,I got shot...")
        def buy_gun(self, gun_name):
            print("%s just bought %s" %(self.name,gun_name))
        #私有方法
        def __shot(self):
            print("shooting...")
    
    #生成一个角色，即实例化（初始化一个类）
    r1 = Role('Alex','police','AK47')
    #修改实例变量
    r1.name="陈荣华"
    print(r1.n,r1.name)
    r1.n_list.append("from r1")
    #给实例添加新的值
    r1.bullet_prove=True
    print(r1.n,r1.name,r1.bullet_prove)
    #删除实例的属性之一
    del r1.weapon
    #修改类变量(只影响本实例)
    r1.n="改类变量"
    print("r1:",r1.n)
    #类变量重新赋值(只影响r2)
    Role.n="ABC"
    
    #生成另外一个实例
    r2 = Role('Jack','terrorist','B22')
    print(r2.n,r2.name)
    r2.name="徐良伟"
    r2.n_list.append("from r2")
    print(r2.n,r2.name,r2.n_list)
    print(Role.n_list)

     

  • 继承实例
    

    class School(object):
        def __init__(self,name,addr):
            self.name = name
            self.addr = addr
            self.students =[]
            self.staffs =[]
        def enroll(self,stu_obj):
            print("为学员%s 办理注册手续"%stu_obj.name )
            self.students.append(stu_obj)
        def hire(self,staff_obj):
            self.staffs.append(staff_obj)
            print("雇佣新员工%s" % staff_obj.name)
    
    class SchoolMember(object):
        def __init__(self,name,age,sex):
            self.name = name
            self.age = age
            self.sex = sex
        def tell(self):
            pass
    
    class Teacher(SchoolMember):
        def __init__(self,name,age,sex,salary,course):
            super(Teacher,self).__init__(name,age,sex)
            self.salary = salary
            self.course = course
        def tell(self):
            print('''
            ---- info of Teacher:%s ----
            Name:%s
            Age:%s
            Sex:%s
            Salary:%s
            Course:%s
            '''%(self.name,self.name,self.age,self.sex,self.salary,self.course))
    
        def teach(self):
            print("%s is teaching course [%s]" %(self.name,self.course))
    
    class Student(SchoolMember):
        def __init__(self,name,age,sex,stu_id,grade):
            super(Student,self).__init__(name,age,sex)
            self.stu_id = stu_id
            self.grade = grade
        def tell(self):
            print('''
            ---- info of Student:%s ----
            Name:%s
            Age:%s
            Sex:%s
            Stu_id:%s
            Grade:%s
            ''' % (self.name, self.name, self.age, self.sex, self.stu_id, self.grade))
        def pay_tuition(self,amount):
            print("%s has paid tution for $%s"% (self.name,amount) )
    
    
    school = School("老男孩IT","沙河")
    
    t1 = Teacher("Oldboy",56,"MF",200000,"Linux")
    t2 = Teacher("Alex",22,"M",3000,"PythonDevOps")
    
    s1 = Student("ChenRonghua",36,"MF",1001,"PythonDevOps")
    s2 = Student("徐良伟",19,"M",1002,"Linux")
    
    
    t1.tell()
    s1.tell()
    school.hire(t1)
    school.enroll(s1)
    school.enroll(s2)
    
    print(school.students)
    print(school.staffs)
    school.staffs[0].teach()
    
    for stu in school.students:
        stu.pay_tuition(5000)

     

  • 多态实例
    

    class Animal:
        def __init__(self, name):  # Constructor of the class
            self.name = name
    
        def talk(self):  # Abstract method, defined by convention only
            pass #raise NotImplementedError("Subclass must implement abstract method")
    
        @staticmethod
        def animal_talk(obj):
            obj.talk()
    
    class Cat(Animal):
        def talk(self):
            print('Meow!')
    
    
    class Dog(Animal):
        def talk(self):
            print('Woof! Woof!')
    
    
    d = Dog("陈荣华")
    #d.talk()
    
    c = Cat("徐良伟")
    #c.talk()
    #
    # def animal_talk(obj):
    #     obj.talk()
    
    Animal.animal_talk(c)
    Animal.animal_talk(d)