面向对象笔记

类的特性:

a.封装

　　　　1.防止数据被随意修改  2.使外部程序不需要关注对象内部的构造，只需要通过对象，对外提供的接口进行直接访问即可

b.继承

　　　1.子类通过继承父类的方式，以最小代码量的方式，实现不同角色的共同点，和不同点

　　　2.多继承时，继承顺序的区别  其中python2 就是深度查询,python3就是广度查询

C.多态

　　　pass

什么是类？

　　其实类就是一个函数的集合即

class 类：

　　　def 函数1()：

　　　　　pass

　　　def 函数2()：

　　　　　pass
对象=类()                    #这就是实例化的过程
对象.函数1()                 #这就是实力

所以说对象就是一个类的实例化后实例

属性：

　　1.公有属性:在类里直接定义的属性，即是公有属性

　　2.私有属性:只能在内部访问，外部不能访问

注:如果外部需要访问的需求，就需要在内部在定义一个关注 这个属性的函数

def get_heart(self):
    return self._heart

如果需要强制访问
r1._Role__heart    

类的写法:

这里就要提新式类和旧式类的对比了，在python3中 采用新式类的方法

经典类 VS 新式类

　用法：   经典类写法:    Persion.__int__(self,name,age)                                #其中Persion 是父类

　　　　　　新式类写法:　 super(Teacger，self).__init__(slef,name,age)       #其中Teacger是子类

言归正传 类如何写:

类的命名规范class Persion(object):                            # Persion 是类的名称 ，首字母必须大写 object后面再提

如果要给类传参数，就必须要使用__init__方法:

__init__是啥？ 

　　　　__init__：传参数必须用__init__ 是在类中独特的构造函数，在类被调用时，这个方法会自动执行,进行一些初始化的动作，所以这里可以设置很多属性，

slef是啥？　

　　　　其实self,就是实例本身！你实例化时python会自动把这个实例本身通过self参数传进去

光记录没意思，贴代码吧

class Persion(object):
    def __init__(self,name,age,sex):  #初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
        self.NAME = name
        self.AGE = age
        self.SEX = sex　　def sayhai(self):　　　　 print(‘you name is %s ‘ %self.name)r1 = Persion(‘zcq‘，‘23‘,‘test‘)      # 这里就是讲zcq 23 test 封装到了name,age,sex 中 r1.sayhai()

总结3点:

　　1.上面的r1 = Persion(‘zcq‘，‘23‘,‘test‘) 这个动作，叫做类的“实例化”

　　2.上面的r1.sayhai() 就是把一个虚拟的抽象的类，通过这个动作，变成一个具体的对象了，这个对象就叫做实例

　　3.刚才定义的这个类体现了面向对象的第一个基本特性，封装，其实就是使用构造方法将内容封装到某个具体对象中，然后通过对象直接或者self间接获取被封装的内容

帖实验代码分析最好了...

class Dog(object):
    member = 100                           #公有属性
    def __init__(self,name,age):      # 构造函数
        self.NAME =name                     #构造函数属性
        self.AGE = age
        self._heart = ‘yes‘
    def sayhai(self):
        print(‘my name is %s , age is %s‘ %(self.NAME,self.AGE))
        self._heart = ‘no‘          #修改私有属性
        print(‘状态 %s‘ %self._heart)
    def b_heart(self):
        return self._heart            #外部调用接口查询私有属性

    def eat(self,food):
        print(‘%s    is eating    状态%s    %s‘ %(self.NAME,self._heart,food))
    def __del__(self):                #析构函数
        print(‘del..........‘)

d=Dog(‘dahong‘,‘5‘)            #实例化
d2=Dog(‘xiaoming‘,‘30‘)      #实例化
print(‘访问__init__的name属性:‘,d.NAME)
d.NAME=‘zcq‘                     #修改构造函数属性
print(‘查询修改构造函数的属性:‘,d.NAME)
print(‘打印私有属性:‘,d.b_heart())

d.sayhai()                            #实例
print(d.b_heart())
d2.sayhai()                          #实例
d2.eat(‘banna‘)                   #传入eat定义的food对应的值
print(d.member)                  # 打印公有属性
Dog.member = 20                #修改公有属性
print(‘第一个实例化的私有属性‘,d.member)
print(‘弟二个实例化的私有属性‘,d2.member)
>>输出

访问__init__的name属性: dahong
查询修改构造函数的属性: zcq
打印私有属性: yes
my name is zcq , age is 5
状态 no
no
my name is xiaoming , age is 30
状态 no
xiaoming is eating 状态no banna
100
第一个实例化的私有属性 20
弟二个实例化的私有属性 20
del..........
del..........

其中__del__析构函数:无论函数有没有被调用都会被执行，   因为 类在被实例化的时候，就已经在内存中开辟了一片空间，用来存放类，这个方法就是用来删除这个实例化的参数，

垃圾回收机制: python3内部会在规定的时间内去，检测内存里没有被变量命名的参数，如果没有就删除  

类的继承代码:

class Persion(object):
    def __init__(self,name,age):
        self.name =name
        self.age = age
        self.sex = ‘noraml‘
    def talk(self):
        print(‘调用talk函数  person is talking ......‘)

class BlackPerson(Persion):

    def __init__(self,name,age,strength): #先继承，在重构   继承父类的时候 ，如果父类有构造函数，子类也必须有 所以这里写了__init__
        self.strength = strength          # 继承父类后，子类也添加构造函数，如果新增功能，子类也必须在self.新方法
        Persion.__init__(self,name,age)
        print(self.name,self.age,self.sex,self.strength)
    def tal(self):
        print(‘调用父类中的talk函数‘ )
        Persion.talk(self.name)           #父类.方法
    def walk(self):
        print(‘is walking......‘)
b=BlackPerson(‘翟超群‘,‘24‘,‘good‘)    #因为调用父类  父类中有构造函数，所以必须穿参
b.tal()
b.walk()>>

翟超群 24 noraml good
调用父类中的talk函数
调用talk函数 person is talking ......
is walking......

加强版类的继承

class Persion(object):          #新式类写法
    ‘‘‘学习成员属性父类‘‘‘
    member = 0
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.enroll()          #这里也可以这样写，可以直接调用enroll函数

    def enroll(self):
        ‘‘‘注册‘‘‘
        print(‘欢迎注册%s成功‘ %self.name)
        Persion.member += 1
    def tell(self):
        print(‘------info----%s‘ % self.name)
       # print(self.__dict__)
        for i,j in self.__dict__.items():
            print(i,j)
        print(‘------end----‘)
class Techer(Persion):

    def __init__(self,name,age,sex,salary,course):      #先继承，在重构，这里加了salary,course 2个属性
        #Persion.__init__(self,name,age,sex)   旧式类写法
        super(Techer,self).__init__(name,age,sex)  #新式类写法
        self.salary = salary
        self.course = course
    def techering(self):
        print(‘注册老师为%s，讲解课程为%s‘ %(self.name,self.course))

class Student(Persion):
    def __init__(self,name,age,sex,course,tutian):       #先继承，在重构，这里加了,course,tutian2个属性
        #Persion.__init__(self,name,age,sex) 旧式类的写法
        super(Student,self).__init__(name,age,sex)          #新式类的写法
        self.course = course
        self.tutian = tutian
    def studenting(self):
        print(‘注册学生%s,课程%s，学费%s‘ %(self.name,self.tutian,self.course))
        Persion.member += 1

t1=Techer(‘alex‘,‘25‘,‘F‘,‘1000000‘,‘Python‘)
t2=Student(‘翟超群‘,‘24‘,‘F‘,‘Python‘,‘10001‘)
# ---------- 因为子类调用的父类 所以用父类中的tell 函数执行出结果
t1.tell()
t2.tell()

忘了一点，关于类多继承

class D(object):      #只列出新式类

    def bar(self):
        print ‘D.bar‘

class C(D):

    def bar(self):
        print ‘C.bar‘

class B(D):

    def bar(self):
        print ‘B.bar‘

class A(B, C):

    def bar(self):
        print ‘A.bar‘

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

类的静态方法： (后续再总结)

class Person(object):
    @staticmethod
    def a1():
        print(‘yes‘)
Person.a1()