面向对象

面向对象编程

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

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

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

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 多态
一种接口多种实现。

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

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

class role:
    n=123  #默认参数
    n_list=[]
    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


    def buy_gun(self): #类的方法，功能，动态属性
        print('%s buy gun %s'%(self.name,self.weapon))

    def __shot(self):
        print('%s shooting'%self.name)

    def got_shot(self):  #运行一次，value就减少20
        self.__life_value -= 20 #私有属性-20
        print('%s : I got shot...   '%self.name)

    def show_status(self):
        print('name:%s weapon:%s life_value：%s'%(self.name,self.weapon,self.__life_value))
r1=role('qiangql','ploice','m4')
r2=role('w33','T','b12')

print(r1.n,r1.name)
print(role.n)
r1.n ='333'
print(r1.n)  #r1里n=333，但是r2里的n还是123
print(r2.n)
r1.n_list.append('444')
print('r1.n_list添加了444',r1.n_list,r2.n_list)
r2.n_list.append('5555')
print('r2.n_list 添加了5555',r1.n_list,r2.n_list,role.n_list)
r1.n_list.append('www')   #先用r1.list添加www,
r1.n_list=['313','33156'] #给r1.list 赋值
role.n_list.append('yy')
print('打印赋值后的r1.list，以及用r1添加www，用role.n_list 添加yy',r1.n_list,r2.n_list,role.n_list)
#没有赋值就用就用默认参数，如果单独赋值，就等于创建了一个单独的参数保存
r1.buy_gun() #买枪
r1.show_status() #打印状态
r1.got_shot() #收到伤害
r1.got_shot() #收到伤害
r1.show_status() #打印状态

C:UsersqiangqlAppDataLocalProgramsPythonPython36-32python.exe C:/Users/qiangql/PycharmProjects/untitled1/lei.py
123 qiangql
123
这里让r1=333 333
123
r1.n_list添加了444 ['444'] ['444']
r2.n_list 添加了5555 ['444', '5555'] ['444', '5555'] ['444', '5555']
打印赋值后的r1.list，以及用r1添加www，用role.n_list 添加yy ['313', '33156'] ['444', '5555', 'www', 'yy'] ['444', '5555', 'www', 'yy']
qiangql buy gun m4
name:qiangql weapon:m4 life_value：100
qiangql : I got shot...   
qiangql : I got shot...   
name:qiangql weapon:m4 life_value：60

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

# _*_coding:utf-8_*_


class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        pass


class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)


class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)


def talk_animal(obj):  # 一个接口，多种形态
    obj.talk()


d=Dog('www')
c=Cat('mmm')
d.talk()  　　　　　　　　#一种接口

talk_animal(d)  　　　  #另一个接口
talk_animal(c)

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

# _*_coding:utf-8_*_


class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        pass
    @staticmethod  #还没讲，这是个装饰器
    def talk_animal(obj):  # 这里加了个接口，放到类里了
        obj.talk()

class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)


class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)


d=Dog('www')
c=Cat('mmm')
d.talk()  #一种接口

Animal.talk_animal(d)
Animal.talk_animal(c)