python第三十一天-----类的封装、继承,多态.....

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

 

class dog(object):
    nationality='ch'#公有属性
    def __init__(self,name,food,leven):#构造函数,方法,初始化方法
        self.name=name #实例指针,指向 属性  对象成员
        self.food=food
        self.leven=leven
        self.__haot='hhh'#前面双下划线定义为私有属性

    def get_hoat(self):#定义方法为私有属性提供接口
        return self.__haot
    def say(self):#类中的方法  都是公有方法
        print('hello,my name is ',self.name)
    def eat(self,foods):
        print("my food is %s,but my eat %s"%(self.food,foods))
    def leve(self):
        print("my leve is ",self.leven)

    def __del__(self):
        print("删除中...")


d=dog("liili",'gl',"5")
d.say()
d.eat('kkk')
d.leve()
print(d.get_hoat())#通用接口访问私有属性

print(d._dog__haot)#强制访问私有属性
print(d.nationality)

dog.nationality='chan'
print(d.nationality)
d.nationality='us'
print(d.nationality)

class F1(object):
    def __init__(self,n):
        self.N = n
        print('F1')

class F2(object):
    def __init__(self,arg1):
        self.a = arg1
        print('F2')

class F3(object):
    def __init__(self,arg2):
        self.b = arg2
        print('F3')



c1=F1('yjj')
c2=F2(c1)#可以封装一个对象
c3=F3(c2)#可以封装多层的对象
print(c3.b.a.N)#通过  .  调用

继承

继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

 

class studen(object):#定义类  学生 基类
    def __init__(self,name,age,clas):#名字,年龄,班级
        self.name=name
        self.age=age
        self.clas=clas
    def talk(self):
        print('%stalk one.....'%self.name)
    def walk(self):
        print('%s walk....'%self.name)
    def info_user(self):
        print('name is %s, age is %s,clas is  %s'%(self.name,self.age,self.clas))

class clas_one(studen):#继承studen
    def __init__(self,name,age,clas,score):#重构构造方法
        #studen.__init__(self,name,age,clas)#先继承, 再重构
        super(clas_one,self).__init__(name,age,clas)#新式类
        self.score=score#增加新对象成员
    def talk(self):#重写方法
        print('is new talk ,%s'%self.name)
    def score_info(self):#新增加 子类方法
        print(self.score,'分')

p=clas_one('学生一',36,'一年三班',178)
p.talk()
p.score_info()

class F1(object):
    def __init__(self):
        print('F1')
    def a1(self):
        print('F1a1')
    def a2(self):
        print('F1a2')

class F2(F1):
    def __init__(self):
        print('F2')
    def a1(self):
        self.a2()
        print('F2a1')
    def a2(self):
        print('F2a2')

class F3(F2):
    def __init__(self):
        print('F3')
    def a11(self):
        print('F3a1')
    def a2(self):
        print('F3a2')

obj=F3()
obj.a1()#调用时,self指向当前对象

多态

class Animal(object):
    def __init__(self,name):
        self.name=name
    def talk(self):
        raise NotImplementedError('提示出错')


class c(Animal):#继承Animal
    def talk(self):
        print('%s 1111'%self.name)

class d(Animal):#继承Animal
    def talk(self):
        print('%s 2222'%self.name)


def talk_all(obj):#用函数来模拟多态
    obj.talk()

c1=c('猫')
d1=d("狗")

talk_all(c1)
talk_all(d1)