python基础-面向对象opp

上述是实例化对象的一个过程。

类的定义和实例化：

 1 class Role(object): #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么
 2     def __init__(self,name,role,weapon,life_value=100,money=15000): #初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
 3         self.name = name #__init__中的第一个参数self,和这里的self都 是什么意思？ 看下面解释
 4         self.role = role
 5         self.weapon = weapon
 6         self.life_value = life_value
 7         self.money = money
 8     def buy_gun(self,gun_name):
 9     　　print(“%s has just bought %s” %(self.name,gun_name) )
10 
11 r1 = Role('Alex','police','AK47')
12 r1.buy_gun("B21”) #python 会自动帮你转成 Role.buy_gun(r1,”B21")

好啦，总结一下2点：

上面的这个r1 = Role('Alex','police','AK47’)动作，叫做类的“实例化”，就是把一个虚拟的抽象的类，通过这个动作，变成了一个具体的对象了，这个对象就叫做实例
刚才定义的这个类体现了面向对象的第一个基本特性，封装，其实就是使用构造方法将内容封装到某个具体对象中，然后通过对象直接或者self间接获取被封装的内

面向对象的特性：

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

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

继承

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

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

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

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

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

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

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

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

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

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

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

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

继承示例

 1  
 2 class SchoolMember(object):
 3     members = 0 #初始学校人数为0
 4     def __init__(self,name,age):
 5         self.name = name
 6         self.age = age
 7  
 8     def  tell(self):
 9         pass
10  
11     def enroll(self):
12         '''注册'''
13         SchoolMember.members +=1
14         print("33[32;1mnew member [%s] is enrolled,now there are [%s] members.33[0m " %(self.name,SchoolMember.members))
15      
16     def __del__(self):
17         '''析构方法'''
18         print("33[31;1mmember [%s] is dead!33[0m" %self.name)
19 class Teacher(SchoolMember):
20     def __init__(self,name,age,course,salary):
21         super(Teacher,self).__init__(name,age)
22         self.course = course
23         self.salary = salary
24         self.enroll()
25  
26  
27     def teaching(self):
28         '''讲课方法'''
29         print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,'s12'))
30  
31     def tell(self):
32         '''自我介绍方法'''
33         msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' %(self.name,'Oldboy', self.course)
34         print(msg)
35  
36 class Student(SchoolMember):
37     def __init__(self, name,age,grade,sid):
38         super(Student,self).__init__(name,age)
39         self.grade = grade
40         self.sid = sid
41         self.enroll()
42  
43  
44     def tell(self):
45         '''自我介绍方法'''
46         msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' %(self.name, self.grade,'Oldboy')
47         print(msg)
48  
49 if __name__ == '__main__':
50     t1 = Teacher("Alex",22,'Python',20000)
51     t2 = Teacher("TengLan",29,'Linux',3000)
52  
53     s1 = Student("Qinghua", 24,"Python S12",1483)
54     s2 = Student("SanJiang", 26,"Python S12",1484)
55  
56     t1.teaching()
57     t2.teaching()
58     t1.tell()

多态

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

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

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

Python多态示例

 1 #_*_coding:utf-8_*_
 2  
 3  
 4 class Animal(object):
 5     def __init__(self, name):  # Constructor of the class
 6         self.name = name
 7  
 8     def talk(self):              # Abstract method, defined by convention only
 9         raise NotImplementedError("Subclass must implement abstract method")
10  
11  
12 class Cat(Animal):
13     def talk(self):
14         print('%s: 喵喵喵!' %self.name)
15  
16  
17 class Dog(Animal):
18     def talk(self):
19         print('%s: 汪！汪！汪！' %self.name)
20  
21  
22  
23 def func(obj): #一个接口，多种形态
24     obj.talk()
25  
26 c1 = Cat('小晴')
27 d1 = Dog('李磊')
28  
29 func(c1)
30 func(d1)