9月
29

面向对象p1

面向对象介绍（它是编程的日常，特别重要）
世界万物，皆可分类。
世界万物，皆为对象。
只要是对象就肯定属于某种类。
只要是对象就肯定有属性。
存在三种编程范式，面向过程，面向对象，函数式编程
特性
Class类
对一组相同属性对象的抽象，定义了共同的属性和方法。
Object对象

1.封装:把一些功能的实现细节不对外暴露
2.继承：代码的重用
3.多态:
一种接口多种实现，允许子类指针赋值给父类，为了实现接口的重用，

语法
1.属性
实例变量
类变量：
类变量用途：大家共用的属性，节省开销
私有属性： __var
2.方法:
构造方法
析构函数
3.构造函数：在实例化时做一些初始化的工作。
4.析构函数：在实例释放销毁的时候执行的，通常用于做一些收尾工作，如关闭一些数据库链接打开的临时文件
5.私有方法，私有属性都是前面加两个下划线，外部不可直接访问，必须通过内部调用
7.实例变量
8.单继承，多继承
9.静态方法：
只是名义上归类管理，实际上在静态方法里访问
简单的类

#  Author: Diedline

class Dog:
    def __init__(self,name):   #构造函数 
        self.name = name


    def bu1(self):      #类的方法
        print("%s: wang wang wang！"%self.name)




d1 = Dog("狗1")
d2 = Dog("狗2")  #传参
d3 = Dog("狗3")

d1.bu1()   #调用
d2.bu1()
d3.bu1()

Cs 类

 #  Author: Diedline
__author__ = "Alex Li"


class Role:
    n = 123 #类变量
    n_list = []
    name = "我是类name"
    def __init__(self, name, role, weapon, life_value=100, money=15000):
        #构造函数
        #在实例化时做一些类的初始化的工作
        self.name = name #r1.name=name实例变量(静态属性),作用域就是实例本身
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value
        self.money = money
    def __del__(self):
        pass #print("%s 彻底死了。。。。" %self.name)

    def show_status(self):
        print("name:%s weapon:%s life_val:%s" %(self.name,
                                                 self.weapon,
                                                self.__life_value))
    def __shot(self): # 类的方法，功能 （动态属性）
        print("shooting...")

    def got_shot(self):
        self.__life_value -=50
        print("%s:ah...,I got shot..."% self.name)

    def buy_gun(self, gun_name):
        print("%s just bought %s" % (self.name,gun_name) )



r1 = Role('Chenronghua','police','AK47') # Role(r1,'Alex', 'police',  'AK47')把一个类变成一个具体对象的过程叫 实例化(初始化一个类，造了一个对象)
r1.buy_gun("AK47")
r1.got_shot()

print(r1.show_status())



r2 = Role('jack', 'terrorist', 'B22')  #生成一个角色
r2.got_shot()
# r1.name = "陈荣华"
# r1.n_list.append("from r1")
# r1.bullet_prove = True
# r1.n = "改类变量"
# print("r1:",r1.weapon,r1.n )
# #del r1.weapon
#
#
#
#
# #print(r1.n,r1.name,r1.bullet_prove,r1.weapon)
#
# #
# r2 = Role('jack', 'terrorist', 'B22')  #生成一个角色
# r2.name = "徐良伟"
# r2.n_list.append("from r2")
# print("r2:",r2.name,r2.n,r2.n_list)
# # r2.got_shot() #Role.got_shot(r2)
#
# Role.n = "ABC"
# print(Role.n_list)
#
# print(r1.n ,r2.n )

类的继承
子类直接和父类用同名方法子类默认覆盖父类，当你重构时需要父类的方法或属性时可以直接调用父类的方法或属性。

#  Author: Diedline
class person(object):
    def __init__(self,name):
        self.name =name
    def walk(self):
        print('%s is goto walk'%self.name)
    def talk(self):
        print("dasndwkduansd")



class chinese(person):
    def __init__(self,age,name,high):
        person.__init__(self,name)               #当你需要父类中不存在的参数时可以重构并调用父类的构造函数
        self.age = age
        self.high = high
    def talk(self):                     #直接调用父类的方法就能相当于修改父类
        person.talk(self.name)
        print('%s is talking%s%s'%(self.name,self.age,self.high))

c = chinese("23","朱斌","2.0")
c.walk()
c.talk()

也可以通过super方法调用父类的构造函数
super(子类,self).init(属性) super更方便，因为可以会有多继承所有可以不用写多个父类，而只需要写一个super

class chinese(person):
    def __init__(self,age,name,high):
        # person.__init__(self,name)               #当你需要父类中不存在的参数时可以重构并调用父类的构造函数
        super(chinese,self).__init__(name)
        self.age = age
        self.high = high

经典类
class preson:

新式类
class person(object):
区别：多继承的顺序问题
Py2 经典类是按深度优先来继承的，新式类是按照广度优先来继承的
Py3 经典类和新式类都是按照广度优先来继承的


class A:
    def __init__(self):
        print("A")
class B(A):
    pass
    # def __init__(self):
    #     print("B")
class C(A):
    pass
    # def __init__(self):
    #     print("C")
class D(B,C):
    pass
    # def __init__(self):
    #     print("D")


obj = D()

Died line