16_python_面向对象

一、面向对象和面向过程的区别
    
    1、面向对象：一切以对象为中心。有相同属性和动作的结合体叫做对
 
        优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
        缺点：性能比面向过程低
 
    2、面向过程：一切以实物的流程为中心
 
         优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
         缺点：没有面向对象易维护、易复用、易扩展
 
二、面向对象的编写 
1 class Car:     #  class是关键字，表示类
2     def __init__(self, color, pai, pailiang): # self表示当前类的对象. 当前你创建 的是谁, 谁来访问的这个方法.那这个self就是谁.
3             self.color = color
4             self.pai = pai        
5             self.pailiang = pailiang
6     def run(self, speed):
7             print("车可以跑%s迈" % speed)
8 c = Car("red", "京A66666", "2.0T")   # 创建对象，类名称后加括号即可，即为实例化
9 c.run(100) # 这时. python会自动把对象c传递给run方法的第一个参数位置.

　　1、面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
   　　  类就是一个模板，模板里可以包含多个函数，函数里实现一些功能；对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
 
　　2、类中的函数第一个参数必须是self（详细见：类的三大特性之封装）；类中定义的函数叫做 “方法”
  　　   实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征 
 1 class 类名:
 2     def __init__(self,参数1,参数2):
 3         self.对象的属性1 = 参数1
 4         self.对象的属性2 = 参数2
 5 
 6     def 方法名(self):pass
 7 
 8     def 方法名2(self):pass
 9 
10 对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
11                   #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
12                   #括号里传参数，参数不需要传self，其他与init中的形参一一对应
13                   #结果返回一个对象
14 对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
15 对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可
三、面向对象的三大特征 -- 封装、继承和多态
 
    1、封装
 
    封装:  把很多数据封装到一个对象中.  把固定功能的代码封装到一个代码块, 函数, 对象,  打包成模块. 这都属于封装的思想. 具体的情况具体分析. 比如. 你写了一个很牛B 的函数. 那这个也可以被称为封装.  在面向对象思        想中. 是把一些看似无关紧要的内容组合到一起统一进行行存储和使用. 这就是封装.
  2、继承
 
    (1) 单继承
    
    子类可以自动拥有父类中除了私有属性外的其他所有内容
class DerivedClassName(BaseClassName1):
    <statement-1>
    . . .
    <statement-N>

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法

 1 #类定义
 2 class people:
 3     #定义基本属性
 4     name = ''
 5     age = 0
 6     #定义私有属性,私有属性在类外部无法直接进行访问
 7     __weight = 0
 8     #定义构造方法
 9     def __init__(self,n,a,w):
10         self.name = n
11         self.age = a
12         self.__weight = w
13     def speak(self):
14         print("%s 说: 我 %d 岁。" %(self.name,self.age))
15 #单继承示例
16 class student(people):
17     grade = ''
18     def __init__(self,n,a,w,g):
19         #调用父类的构函
20         people.__init__(self,n,a,w)
21         self.grade = g
22     #覆写父类的方法
23     def speak(self):
24         print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
25 
26 s = student('ken',10,60,3)
27 s.speak()
28 结果：
29 ken 说: 我 10 岁了，我在读 3 年级

(2) 多继承

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
     . . .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。(MRO算法)

 1 #类定义
 2 class people:
 3     #定义基本属性
 4     name = ''
 5     age = 0
 6     #定义私有属性,私有属性在类外部无法直接进行访问
 7     __weight = 0
 8     #定义构造方法
 9     def __init__(self,n,a,w):
10         self.name = n
11         self.age = a
12         self.__weight = w
13     def speak(self):
14         print("%s 说: 我 %d 岁。" %(self.name,self.age))
15 #单继承示例
16 class student(people):
17     grade = ''
18     def __init__(self,n,a,w,g):
19         #调用父类的构函
20         people.__init__(self,n,a,w)
21         self.grade = g
22     #覆写父类的方法
23     def speak(self):
24         print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
25 #另一个类，多重继承之前的准备
26 class speaker():
27     topic = ''
28     name = ''
29     def __init__(self,n,t):
30         self.name = n
31         self.topic = t
32     def speak(self):
33         print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
34 #多重继承
35 class sample(speaker,student):
36     a =''
37     def __init__(self,n,a,w,g,t):
38         student.__init__(self,n,a,w,g)
39         speaker.__init__(self,n,t)
40 test = sample("Tim",25,80,4,"Python")
41 test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法
42 结果：
43 我叫 Tim，我是一个演说家，我演讲的主题是 Python
    (3) 方法重写
 
    如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法 
1 class Parent:        # 定义父类
2    def myMethod(self):
3       print ('调用父类方法')
4 class Child(Parent): # 定义子类
5    def myMethod(self):
6       print ('调用子类方法')
7 c = Child()          # 子类实例
8 c.myMethod()         # 子类调用重写方法
9 super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
3、多态
 
多态: 同一个对象, 多种形态. 这个在python中其实是很不容易说明白的. 因为我们一 直在用. 只是没有具体的说.  比如. 我们创建一个变量a = 10 , 我们知道此时a是整数类型. 但是我们可以通过程序让a = "alex", 这时, a又变成了字符串类型.  这是我们都知道的. 但是, 我要告诉你的是. 这个就是多态性. 同一个变量a可以是多种形态. 
 1 class Animal:    
 2     def chi(self):
 3         print("动物就知道吃")
 4 class Pig(Animal):
 5     def chi(self):
 6             print("猪在吃")
 7 class Haski(Animal):
 8     def chi(self):
 9             print("哈?士奇在吃")
10 class Alasika(Animal):
11     def chi(self):       
12         print("阿拉斯加在吃")
13 class SiYangYuan:
14     def yanng_animal(self, ani):  
15         ani.chi()
16         
17 zhu = Pig()
18 erha = Haski()
19 ala = Alasika()
20 alex = SiYangYuan()
21 alex.yanng_animal(zhu)
22 alex.yanng_animal(erha)
23 alex.yanng_animal(ala)
程序具有超高的可扩展性.  面向对象思想的核心与灵魂. python自带多态
 
四、类对象补充 
 1 一：我们定义的类的属性到底存到哪里了？有两种方式查看
 2 dir(类名)：查出的是一个名字列表
 3 类名.__dict__:查出的是一个字典，key为属性名，value为属性值
 4 
 5 二：特殊的类属性
 6 类名.__name__# 类的名字(字符串)
 7 类名.__doc__# 类的文档字符串
 8 类名.__base__# 类的第一个父类(在讲继承时会讲)
 9 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
10 类名.__dict__# 类的字典属性
11 类名.__module__# 类定义所在的模块
12 类名.__class__# 实例对应的类(仅新式类中)

 

posted @ 2018-09-25 21:22  qi.hu  阅读(170)  评论(0)  编辑  收藏  举报