面向对象

最新推荐文章于 2024-11-01 12:20:35 发布

baluo7321

最新推荐文章于 2024-11-01 12:20:35 发布

阅读量73

点赞数

文章标签：数据库数据结构与算法 python

原文链接：http://www.cnblogs.com/PYlog/p/8981361.html

版权

面向对象编程

以前学的都都是面向过程编程，我理解的面向过程就是写好流程图，跟着流程图一步一步走，实现功能。

面向对象是你是一个上帝，滴尿成湖，泼尿成海，创造万物，赋予他们属性，调用他们的功能，实现我们的目的。

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

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

class a: #经典类

class a（object）#新式类

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

就是实力话一个对象。。。。。

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

常用方法：

析构函数

在实例释放、销毁的时候执行，通常进行收尾工作，如果关闭一些数据库连接，打开的临时文件

语法:

    def __del__(self):
        print('%s 彻底死了'%self.name)

私有方法

内部执行的方法，避免外部调用，例如cs见血通过被人攻击

语法：

def __init__(self,name,role,weapon,life_value=100,money=800):
    #构造函数
    self.name=name #实例变量，静态属性
    self.role=role
    self.weapon =weapon
    self.__life_value=life_value #这里设置的私有属性，只能通过特定的方法调用
    self.money=money

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

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

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

Polymorphism 多态
一种接口多种实现。

类的实例，里边含有类的基本语法，默认参数，私有属性（方法）

在运行那块有函数的运行机制，　　

 1 class role:
 2     n=123  #默认参数
 3     n_list=[]
 4     def __init__(self,name,role,weapon,life_value=100,money=800):
 5         #构造函数
 6         self.name=name #实例变量，静态属性
 7         self.role=role
 8         self.weapon =weapon
 9         self.__life_value=life_value #这里设置的私有属性，只能通过特定的方法调用
10         self.money=money
11 
12 
13     def buy_gun(self): #类的方法，功能，动态属性
14         print('%s buy gun %s'%(self.name,self.weapon))
15 
16     def __shot(self):
17         print('%s shooting'%self.name)
18 
19     def got_shot(self):  #运行一次，value就减少20
20         self.__life_value -= 20 #私有属性-20
21         print('%s : I got shot...   '%self.name)
22 
23     def show_status(self):
24         print('name:%s weapon:%s life_value：%s'%(self.name,self.weapon,self.__life_value))
25 r1=role('qiangql','ploice','m4')
26 r2=role('w33','T','b12')
27 
28 print(r1.n,r1.name)
29 print(role.n)
30 r1.n ='333'
31 print(r1.n)  #r1里n=333，但是r2里的n还是123
32 print(r2.n)
33 r1.n_list.append('444')
34 print('r1.n_list添加了444',r1.n_list,r2.n_list)
35 r2.n_list.append('5555')
36 print('r2.n_list 添加了5555',r1.n_list,r2.n_list,role.n_list)
37 r1.n_list.append('www')   #先用r1.list添加www,
38 r1.n_list=['313','33156'] #给r1.list 赋值
39 role.n_list.append('yy')
40 print('打印赋值后的r1.list，以及用r1添加www，用role.n_list 添加yy',r1.n_list,r2.n_list,role.n_list)
41 #没有赋值就用就用默认参数，如果单独赋值，就等于创建了一个单独的参数保存
42 r1.buy_gun() #买枪
43 r1.show_status() #打印状态
44 r1.got_shot() #收到伤害
45 r1.got_shot() #收到伤害
46 r1.show_status() #打印状态

 1 C:\Users\qiangql\AppData\Local\Programs\Python\Python36-32\python.exe C:/Users/qiangql/PycharmProjects/untitled1/lei.py
 2 123 qiangql
 3 123
 4 这里让r1=333 333
 5 123
 6 r1.n_list添加了444 ['444'] ['444']
 7 r2.n_list 添加了5555 ['444', '5555'] ['444', '5555'] ['444', '5555']
 8 打印赋值后的r1.list，以及用r1添加www，用role.n_list 添加yy ['313', '33156'] ['444', '5555', 'www', 'yy'] ['444', '5555', 'www', 'yy']
 9 qiangql buy gun m4
10 name:qiangql weapon:m4 life_value：100
11 qiangql : I got shot...   
12 qiangql : I got shot...   
13 name:qiangql weapon:m4 life_value：60
14 
15 Process finished with exit code 0

执行结果

继承实例

里边有重构父类的方法，继承父类的方法。还有通过第三个类，将两个子类联系在一起。

class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.friends=[]
    def sleep(self):  #父类里边有睡觉吃饭的共有属性
        print('%s sleeping'%self.name)
    def eat(self):
        print('%s chi TMD'%self.name)

class Relation(object): #交朋友
    def make_friends(self,obj): #这里obj指的是一个实例
        print('%s is making friends with %s'%(self.name,obj.name))
        self.friends.append(obj)  #将obj所有的信息添加到表里

class Man(People,Relation):  #这里继承两个类，把两个子类链接起来，relation里边没有名字参数，但是people有
    def __init__(self,name,age,money):
        #People.__init__(self,name,age)    #这里经典类的继承方法，统一用新式类的
        super(Man,self).__init__(name,age)  #这里是新式类的继承方法
        self.money=money                  #因为多了一个属性，重构了一下。如果没有多余的属性，就不需要额外重构
    def piao(self):  #特定的属性
        print('%s go heiheihei'%self.name)
    def sleep(self):
        People.sleep(self)  #重构了方法,先执行父类的
        print('%s with woman sleeping'%self.name)

class Woman(People,Relation):
    def huazhuang(self): #特定的属性
        print('%s go change haed '%self.name)
    def sleep(self):
        print('%s with man sleeping'%self.name)

m1=Man('qiangql',17,20)
m1.piao()
m1.eat()  #继承父类的吃
m1.sleep() #这里sleep有一个是执行了父类，一个是重构的

w1=Woman('dadagouquan',23)
w1.huazhuang()
w1.sleep()


m1.make_friends(w1)  #本来两个子类没有联系，通过一个共有的方法，联系在了一起
print(m1.friends[0],'里边储存的是所有信息')
print(m1.friends[0].name) #可以额外调用名字，年龄等
print(m1.friends[0].age)

w1.make_friends(m1)
print(w1.friends[0].name)

多态实例1

 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         pass
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 def talk_animal(obj):  # 一个接口，多种形态
23     obj.talk()
24 
25 
26 d=Dog('www')
27 c=Cat('mmm')
28 d.talk()  　　　　　　　　#一种接口
29 
30 talk_animal(d)  　　　  #另一个接口
31 talk_animal(c)

多态实例2，类里开了接口

 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         pass
10     @staticmethod  #还没讲，这是个装饰器
11     def talk_animal(obj):  # 这里加了个接口，放到类里了
12         obj.talk()
13 
14 class Cat(Animal):
15     def talk(self):
16         print('%s: 喵喵喵!' % self.name)
17 
18 
19 class Dog(Animal):
20     def talk(self):
21         print('%s: 汪！汪！汪！' % self.name)
22 
23 
24 d=Dog('www')
25 c=Cat('mmm')
26 d.talk()  #一种接口
27 
28 Animal.talk_animal(d)
29 Animal.talk_animal(c)