day6

面向对象介绍

特性

class

object

封装

继承

https://segmentfault.com/a/1190000002685939

python2 经典类是按照深度优先来继承的；新式类是按照广度优先继承的。

python3经典类，新式类都是按照广度优先来继承的

多态

 

语法

属性

方法

 

构造函数

析构函授

私有方法，私有属性

类变量

面向对象编程

OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

面向对象的几个核心特性如下

Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

Object 对象 
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

Polymorphism 多态
态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定

 

无论用什么形式来编程，我们都要明确记住以下原则：

1. 写重复代码是非常不好的低级行为
2. 你写的代码需要经常变更 

cs代码

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC

class Role(object):#定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写
    n = 123#类变量
    name = "rose"
    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
        self.money = money
    def shot(self): #类的方法（动态属性）
        print("shooting...")
    def got_shot(self):
        print("ah...,%s got shot..."% (self.name))
    def buy_gun(self, gun_name):
        print("%s just bought %s" % (self.name,gun_name))

print(Role.n) #调用类变量，全局的
#生成两个实例
r1 = Role('Alex', 'police', 'AK47') #生成一个r1角色  Role类的实例
r2 = Role('Jack', 'terrorist', 'B22')  #生成一个r2角色

print(r1.n,r1.name)  #实例以后，先调用实例变量，如果没有才找类变量
r1.name = "AAAAAA" #修改实例面变量
print(r1.n,r1.name)

r1.bullet_prove = True #给实例添加新属性
print(r1.name,r1.role,r1.bullet_prove,r1.weapon)

del r1.weapon #删除一个属性
#print(r1.name,r1.role,r1.bullet_prove,r1.weapon) #缺少weapon，报错
print(r1.name,r1.role,r1.bullet_prove)

r1.n = "改变类变量" #只改变实例r1中的n
print("r1",r1.role,r1.n)
print("r2",r2.role,r2.n)

Role.n = "ABC"
print(r1.n,r2.n) #r1.n不变，r2.n变

# r1.got_shot()
# r1.buy_gun("AA")
# print(r1.name)

面向对象的特性：

封装

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC
#学校，讲师，学员
class School(object):
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
        self.students = []
        self.teachers = []
        self.staffs = []
    def enroll(self,stu_obj):
        print("%s 办理手续" % stu_obj.name)
        self.students.append(stu_obj)
    def hire(self,staff_obj):
        self.teachers.append(staff_obj)
        print("雇佣新老师%s"% staff_obj.name)
    def all_memeber(self,all_obj):
        self.staffs.append(all_obj.name)

class SchoolMemeber(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def tell(self):
        pass

class Teacher(SchoolMemeber):
    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-----
            Nmae:%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(SchoolMemeber):
    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-----
            Nmae:%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("老男孩","沙河")

t1 = Teacher("Oldboy",56,"MF","200000","Linux")
t2 = Teacher("Alex",22,"M","20000","python")

s1 = Student("DCC",36,"F",1001,"python3")
s2 = Student("DCC2",36,"F",1002,"Linux2")


# t1.tell()
# t2.tell()
# s1.tell()
# s2.tell()
school.hire(t1)
school.hire(t2)
school.enroll(s1)
school.enroll(s2)
school.all_memeber(t1)
school.all_memeber(t2)
school.all_memeber(s1)
school.all_memeber(s2)
print("===========")
print(school.students)
print(school.teachers)
print(school.staffs)
print("===========")
school.teachers[0].teach()

for stu in school.students:
    stu.pay_tuition(5000)

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

 

Pyhon不直接支持多态，但可以间接实现

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")
 
class Cat(Animal):
    def talk(self):
        return 'Meow!'
 
class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'
 
animals = [Cat('Missy'),
           Dog('Lassie')]
 
for animal in animals:
    print animal.name + ': ' + animal.talk()

析构函数

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC


#析构函数，在实例释放 销毁的时候，就会自动执行。通常用于一个收尾工作，如关闭一些打开的文件或数据库连接
class Role(object):#定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写
    n = 123#类变量
    name = "rose"
    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 #私有属性，将这个变量隐藏了，外部打印不可见
        self.money = money
    def shot(self): #类的方法（动态属性）
        print("shooting...")
    def got_shot(self):
        print("ah...,%s got shot..."% (self.name))
    def buy_gun(self, gun_name):
        print("%s just bought %s" % (self.name,gun_name))
    def __del__(self): #析构函数，
        print("%s 彻底死了。。。。" % self.name)

    def show_life_value(self): #查看私有属性的方法。
        print("name:%s weapon:%s life_walue:%s" %(self.name,self.weapon,self.__life_value))

r1 = Role('Alex', 'police', 'AK47')
r1.buy_gun("AKAK")
r1.got_shot()
del r1 #删除实例
r2 = Role('Jack', 'terrorist', 'B22')
r2.got_shot()
#print(r1.__life.value) #私有属性报错，不可直接打印
print(r2.show_life_value()) #如果想要查看私有属性，需要定义一个方法。

#私有方法/私有属性，名字前加“__”

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:DCC
#继承/多态

#class People: #经典类
class People(object):#新式类

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print("%s is eating" % self.name)
    def sleep(self):
        print("%s is sleeping" % self.name)
    def talk(self):
        print("%s is talking" % self.name)

class Renlation(object):
    def make_friends(self,obj):
        print("%s is make friend with %s" % (self.name,obj.name))

class man(People,Renlation):
    def __init__(self,name,age,money): #增加新属性
        People.__init__(self,name,age)
        #super(man,self).__init__(name,age) #另外一种写法。新式类使用
        self.money = money
        print("%s 出生就有 %s 钱" % (self.name,self.money))
    def piao(self):
        print("%s is piaoing" % self.name)
    def sleep(self):
        # 重构父类方法
        People.sleep(self)
        print("man %s is piaoing" % self.name )

m1 = man("name1","22","100")
# m1.eat()
# m1.piao()
# m1.sleep()

print("================")
class woman(People,Renlation):
    def get_birth(self,haha):
        print("%s is birthing baby.." % self.name)
        print("%s is birthing baby.." % haha)
w1 = woman("name2","23")

w1.get_birth("AAA")
#w1.name = "BBBB"
m1.make_friends(w1)