面向对象基础

面向对象编程——Object Oriented Programming,简称OOP

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

面向对象的几个核心特性如下：抽象，封装，继承，多态

Class 类

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

Object 对象

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

Encapsulation 封装

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

-类中封装了：属性、方法

-对象中封装了：成员属性

1、防止数据被随意修改

2、使外部程序不需要关注对象内部的构造

Inhertance 继承

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

Polymorphism 多态

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

下面详细介绍下

 

---

 

类和对象

在Python中，定义类是通过class关键字：

class Role(object): #新式类
    pass

class Role:  #经典类
    pass　

 

新式类与经典类区别稍后再讲，这里以经典类为例，class后面紧接着是类名，即Role，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

 

定义好了Role类，就可以根据Role类创建出Role的实例（对象），创建实例是通过类名+()实现的：

class Role(object):
    pass

role1 = Role()    #实例化后产生的对象，叫实例
print(role1)
print(Role)
结果：
<__main__.Role object at 0x00426B70>
<class '__main__.Role'>
#实例化，其实就是以Role类为模版，在内存里开辟一块空间，存上数据，赋值成一个变量名

可以看到，变量role1指向的就是一个Role的实例，后面的0x00426B70是内存地址，每个object的地址都不一样，而Student本身则是一个类　

定义一个角色，我们是不是需要名字，那名字我们怎么传进去呢？这时候就需要构造函数或者叫构造方法

class Role(object):
    def __init__(self,name):  #构造函数
        self.name = name    #成员属性或者叫成员变量或者叫字段
    def say_hello(self):  #类的方法
        print("hello %s"%self.name)

role1 = Role("lxj")   #Role(role1,'lxj')

上面的这个__init__()叫做初始化方法(或构造方法)， 在类被调用时，这个方法(虽然它是函数形式，但在类中就不叫函数了,叫方法)会自动执行

为什么会有self？是什么意思呢？其实当我们是实例化一个对象时，role1 = Role("lxj")，实际就相当于Role(role1,'lxj')，self即实例本身（这里指role1）

你执行role1 = Role('lxj')时，python的解释器其实干了两件事：

1. 在内存中开辟一块空间,把role1指向这块内存空间
2. 调用Role这个类并执行其中的__init__(…)方法，相当于Role.__init__(role1,'lxj'),这么做是为什么呢？ 是为了把'lxj'这个值跟刚开辟的r1关联起来， 因为关联起来后，你就可以直接role1.name这样来调用啦。所以，为实现这种关联，在调用__init__方法时，就必须把role1这个变量也传进去，否则__init__不知道要把参数跟谁关联呀。
3. 所以这个__init__(…)方法里的，self.name = name , self.role = role 等等的意思就是要把这几个值 存到role1的内存空间里，调用say_hello(),实际上是调用类中的方法。

 

封装：

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

公有属性和私有属性：私有属性只能内部访问(在变量前加__)，不能外部访问。公有属性所有类的对象都可以访问与类方法平级

class Role(object):
    child = 111   #类成员公有属性
    __father = 222 #类成员私有属性

    def __init__(self,name):
        self.name = name   #实例化成员属性
        self.__home = 'house'   #实例化成员私有属性

    def dis_home(self):             #对外部提供访问接口
        return self.__home

    @staticmethod  #静态方法在面向对象进阶会讲到，现在你知道有这么种方法，
    def dis_father():               #对外部提供访问接口
        return Role.__father

#如果我们直接调用Role.child和Role.__father
#Role.__father直接会报错：AttributeError: type object 'Role' has no attribute '__father'
#这里调用Role.father也是同样报错的

------------------------------------
#要访问私有属性，可以在类方法中提供访问接口
print(Role.dis_father())  #访问类成员私有属性

r1 = Role("lxj")
print(r1.dis_home())  #访问实例化成员私有属性，必须先实例化

结果：
222
house

接下来说下具体的流程

class Role(object):
    child = 1  #公有属性
    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
        self.__home = 'house'   #实例化成员私有属性
    def home(self):             #对外部提供只读访问接口
        return self.__home

r1 = Role("lxj","it","drive")
r2 = Role("sx","accounting","drive")

print(r1.home())
print(r1.child)
print(r2.child)

结果：
house
1
1

　实际上r1.child和r2.child是指向类child的内存地址，并没有在实例(r1,r2)中存储该变量。当我们调用r1.child,寻找过程是这样子的（以r1.child为例），先寻找r1所在的内存空间有没有child这个变量，如没有，则寻找类的公有属性有没有child这个变量，（实际上调用类的方法（home），与公有属性也是类似，并没有拷贝类的方法，只是引用）

Role.child = 2    #修改指向的值
print(r1.child)
print(r2.child)
结果：同时改变
2
2

r1.child = 3     #在r1内存中新增一个child变量，指向3
print(r1.child)
print(r2.child)
结果：只改变r1的值
3
2

析构函数：

import time
class Role(object):
    child = ["sansi"]  #共有属性
    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
        self.__home = 'house'   #私有属性
    def home(self):
        return self.__home
    def __del__(self):                 #引用结束时运行
        print("down......%s"%self.name)

r1 = Role("lxj","it","drive")
r2 = Role("sx","accounting","drive")

del r1    #删除r1的引用，python内存回收机制发现r1指向的内存地址没人指向了，此时回收了该内存地址，打印了down......lxj
time.sleep(3)
print("aa")
time.sleep(1)  #程序运行结束，打印down......sx
结果
down......lxj
aa
down......sx

继承　

继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

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

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

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

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

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

继承概念的实现方式主要有2类：实现继承、接口继承。

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

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

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

 

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

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

单继承：

class SchoolMember(object):                

    member = 0   #公有属性，有成员进来就加1
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.enroll()
    def enroll(self):
        print("just enrolled a new school member %s"%self.name)
        SchoolMember.member += 1
    def tell(self):
        print("------info %s-----"%self.name)
        for k,v in self.__dict__.items(): #打印实例中构造函数的所有属性
            print('\t',k,v)
        print("-------end------")
    def __del__(self):
        print("开除 %s"%self.name)

class Teacher(SchoolMember):   #继承SchoolMember

    def __init__(self,name,age,sex,salary,course):
        #SchoolMember.__init__(self,name,age,sex)   #经典类写法，python3里基本不用这种写法
        #super().__init__(name,age,sex)              #新式类，现在一般都用新式类的写法
        super(Teacher,self).__init__(name,age,sex)  #类继承写法3
        self.salary = salary
        self.course = course

    def teaching(self):
        print("Teacher %s is teaching %s"%(self.name,self.course))


class Student(SchoolMember):

    def __init__(self,name,age,sex,course,  tution):
        SchoolMember.__init__(self,name,age,sex)
        self.tution = tution
        self.amount = 0
    def pay_tuition(self,money):
        print("student %s has just paied %s"%(self.name,self.tution))
        self.amount+=self.tution


t1 = Teacher('SX',27,'girl',6000,'math')
s1 = Student('lx',18,'boy','pys15',8000)
s2 = Student('lxj',18,'boy','pys14',6000)
#print(SchoolMember.member)
print(t1.__dict__)   #以字典形式显示构造函数
t1.tell()
# s1.tell()
del t1

结果：
just enrolled a new school member SX
just enrolled a new school member lx
just enrolled a new school member lxj
{'age': 27, 'course': 'math', 'sex': 'girl', 'salary': 6000, 'name': 'SX'}
------info SX-----
	 age 27
	 course math
	 sex girl
	 salary 6000
	 name SX
-------end------
开除 SX
开除 lxj
开除 lx

super两种用法的区别

首先要知道super函数，把它用在派生类的方法定义里，就是要求从这个类的直接基类开始做属性检索（而不是从这个类本身开始查找）。采用super函数而不直接写具体基类的名字，产生的查找更加灵活

super的第一种用法
class A(object):
    def __init__(self):
        print("A.__init__")
class B(A):
    def __init__(self):
        super().__init__()
        print("B.__init__")


class C(A):
    def __init__(self):


        super().__init__()
        print("C.__init__")

class D(B, C):
    def __init__(self):
        super().__init__()
        print("D.__init__")

d = D()
print(D.__mro__)  # 寻找顺序
#按照寻找顺序来
此结果为：
A.__init__
C.__init__
B.__init__
D.__init__
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

#super不加参数会按寻找顺序自动检索

#super的第二种用法，指定继承，在D类中指定顺序

class A(object):
    def __init__(self):
        print("A.__init__")

class B(A):
    def __init__(self):
        super().__init__()
        print("B.__init__")

class C(A):
    def __init__(self):
        super().__init__()
        print("C.__init__")

class D(B, C):
    def __init__(self):
        super(C,self).__init__()
        print("D.__init__")

d = D()

结果：
A.__init__
D.__init__

其实这里记住super指的是MRO中的下一个类

在说多继承时，先说下新式类与经典类区别，等说完这个，你就明白多继承了，也了解新式类与经典类的区别：

在python2和python3中多继承的区别：

先来看个程序

class A(object):
    def __init__(self):
        self.n = 'A'
class B(A):
    def __init__(self):
        self.n = 'B'
    pass
class C(A):
    def __init__(self):
        self.n = 'C'
    pass
class D(B,C):
    def __init__(self):
        self.n = 'D'
    pass

d = D()
print(d.n)
结果：
D

　　上述程序中A为基类，B、C继承A，D继承B、C（多继承）

在上述程序中，如果我们注释掉D，结果会是什么呢？

class D(B,C):                  #新式类
    # def __init__(self):  
    #     self.n = 'D'
    pass
结果：B

　不管新式类还是经典类在python2和3中结果都为B

接着我们再注释掉B，看看结果会有何不同呢？

Python3:
class A(object):
    def __init__(self):
        self.n = 'A'
class B(A):
    # def __init__(self):
    #     self.n = 'B'
    pass
class C(A):
    def __init__(self):
        self.n = 'C'
    pass
class D(B,C):
    # def __init__(self):
    #     self.n = 'D'
    pass

d = D()
print(d.n)
结果：
在python3中不管新式类还是经典类结果都为C，这里就写了新式类的写法

Python2：
class A:
    def __init__(self):
        self.n = 'A'
class B(A):
   # def __init__(self):
    #    self.n = 'B'
    pass
class C(A):
    def __init__(self):
        self.n = 'C'
    pass
class D(B,C):
    # def __init__(self):
    #     self.n = 'D'
    pass

d = D()
print(d.n)
结果：
在python2中新式类运行的结果为C，经典类运行的结果为A，这里就写了经典类的写法　　

总结：

为什么会出现这样的结果呢？这里涉及到深度查询和广度查询，看张图你就明白了。

广度查询即：以该例为说明，先寻找D，如果D没有，则寻找B，B没有则寻找C，C没有则寻找A。即D-B-C-A

深度查询即：D-B-A-C

 总结：在python3中均为广度查询，python2中经典类为深度查询，新式类为广度查询

class F1(object):

    def a1(self):
        print("F1a1")
    def a2(self):
        print("F1a2")
class F2(F1):

    def a1(self):
        self.a2()
        print("F2a1")
    def a2(self):
        print("F2a2")
class F3(F2):

    # def a1(self):
    #     print("F3a1")
    def a2(self):
        print("F3a2")

obj = F3()
obj.a1()
#obj = F3()相当于F3(obj),obj.a1()，此时F3中没有a1函数，那么就寻找父类中的a1函数，此时运行a1(self),其中的self参数就是我们实例化的对象，即obj.那么我们就可以很容易得到结果了。
结果：
F3a2
F2a1

上面我们已经知道　　

　　

多态

 

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

 

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

 

 

 

Pyhon 很多语法都是支持多态的，比如 len(),sorted(), 你给len传字符串就返回字符串的长度，传列表就返回列表长度。

class Animal(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def talk(self):
        print("%s wang wang wang ...."%self.name)

class Cat(Animal):
    def talk(self):
        print("%s miao miao miao...."%self.name)

def animal_talk(obj):   #实现多态的方法，多种实现调用同一接口（这里多种talk方法调用同一个animal_talk方法）
    obj.talk()

animal_talk(Dog('d1'))
animal_talk(Cat('c1'))
结果：
d1 wang wang wang ....
c1 miao miao miao....