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',"")
 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)