码迷,mamicode.com
首页 > 其他好文 > 详细

面向对象之继承

时间:2018-10-12 01:35:56      阅读:29      评论:0      收藏:0      [点我收藏+]

标签:工作   分享图片   abc   优点   字符串   自己   深度   ssr   根据   

标签(空格分隔): 继承


什么是继承:
继承是指类与类之间的关系,是一种什么“是”什么的关系,继承的功能之一就是用来解决代买重用问题,继承是一种创建新类的方式,在python中,新建的类是可以继承多个父类,父类又可以成为基类或者超类,新建的类称为派生类或者子类;

  • python中的继承分为:单继承和多继承:
    技术分享图片

技术分享图片
技术分享图片

派生

派生:是在继承中,子类有自己的特点,有自己的东西,即使是同一个方法,子类也可以有自己的特色;

继承的实现原理:

技术分享图片
继承的原则:
深度优先,广度优先;

子类继承后,对方法重写

技术分享图片
如果子类中有的方法,并且重写了,在实例化的时候,还是先用子类的方法,如果子类找不到就用,继承来的;

  • 继承是指的类与类之间的关系;

例如:选课系统:
选课系统里面:有老师,学生,这些可以定义为类;


class Teacher:
    school ='luffycity'
    def __init__(self,name,age,sex,level,salary):
        self.name=name
        self.age=age
        self.sex=sex
        self.level=level
        self.salary=salary
        
    def teach(self):
        print('%s is teaching '%self.name)
class Student:
    school ='luffycity'
    def __init__(self,name,age,sex,class_time):
        self.name=name
        self.age=age
        self.sex=sex
        self.class_time=class_time
    def learn(self):
        print(%s is learning '%self.name)

上述代码会发现我们这里面有很多的重复代码,会有很多的重复的代码,所以针对类之间的重复的代码,我们可以使用继承,把相同的功能,封装,然后继承,如上述我们可以,定义一个people,然后老师和学生继承就好了;

so:如下代码;

class People:
    school = 'luffycity'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        
class Teacher(People):
    def __init__(self,name,age,sex,level,salary):
        super().__init__(name,age,sex)
        self.level=level
        self.salary=salary
        
    def teach(self):
        print('%s is teaching '%self.name)
class Student:
    school ='luffycity'
    def __init__(self,name,age,sex,class_time):
        super().__init__(name,age,sex)
        self.class_time=class_time
    def learn(self):
        print(%s is learning '%self.name)
    
teacher1 = Teacher('www',18,'male',10,3000)
student1=Student('zhangsan',28,'feamal','18:34:45')

如上的代码如果:老师有课程,课程周期,课程价格的属性的时候,怎么办呢,代码如下:我们可以给__init__增加属性

class People:
    school = 'luffycity'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        
class Teacher(People):
    def __init__(self,name,age,sex,level,salary,course_name,course_price,course_period):
        super().__init__(name,age,sex)
        self.level=level
        self.salary=salary
        self.course_name=course_name
        self.course_price=course_price
        self.course_period=course_period
        
    def teach(self):
        print('%s is teaching '%self.name)
class Student:
    school ='luffycity'
    def __init__(self,name,age,sex,class_time):
        super().__init__(name,age,sex)
        self.class_time=class_time
    def learn(self):
        print(%s is learning '%self.name)
    
teacher1 = Teacher('www',18,'male',10,3000,'python',3000,'dkkd')
teacher1 = Teacher('aaa',18,'male',10,3000,'python',3000,'dkkd')

如上述的代码会有很多,关于课程的信息,写了很多重复的代码;

这样我们可以把课程单独的定义一个类:

class People:
    school = 'luffycity'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        
class Teacher(People):
    def __init__(self,name,age,sex,level,salary,):
        super().__init__(name,age,sex)
        self.level=level
        self.salary=salary
        
        
    def teach(self):
        print('%s is teaching '%self.name)
class Student:
    school ='luffycity'
    def __init__(self,name,age,sex,class_time):
        super().__init__(name,age,sex)
        self.class_time=class_time
    def learn(self):
        print(%s is learning '%self.name)
        
class Course:
    def __init__(self,course_name,course_price,course_period)
        self.course_name =course_name
        self.course_price=course_price
        self.course_period =course_period
    def tell_info(self):
        print('课程名称<%s> 课程价格<%s> 可传给你周期<%s>'%(self.course_name,self.course_price,self.course))
teacher1.course.tell_info()

这就是组合

teacher1 =Teacher(‘alex‘,18,‘male‘,10,3000,)
teacher1.course=‘python‘
teacher2.course=‘python‘

```;

多态

多态指的是一类事物有多种形态,比如动物有多种形态:人,狗,猪

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

研究多态,就是研究同一种事物多种状态,

多态性:指的是可以在不考虑实例的类型的情况下,而直接使用对象,
peo1=People()
dog1=Dog()
pig1=Pig()

peo1.talk()
dog1.talk()
pig1.talk()

以上的多态性,指的是动态的多态性,多态性,不用考虑具体的实例类型,就可以直接用;

def func(animal):
    animal.talk()
func(peo1)
func(pig1)
func(dog1)

二 为什么要用多态性(多态性的好处)

其实大家从上面多态性的例子可以看出,我们并没有增加什么新的知识,也就是说python本身就是支持多态性的,这么做的好处是什么呢?

1.增加了程序的灵活性

  以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如func(animal)

2.增加了程序额可扩展性

 通过继承animal类创建了一个新的类,使用者无需更改自己的代码,还是用func(animal)去调用  
 
 Python崇尚鸭子类型,即‘如果看起来像、叫声像而且走起路来像鸭子,那么它就是鸭子’

python程序员通常根据这种行为来编写程序。例如,如果想编写现有对象的自定义版本,可以继承该对象

也可以创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度。

例1:利用标准库中定义的各种‘与文件类似’的对象,尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

例2:序列类型有多种形态:字符串,列表,元组,但他们直接没有直接的继承关系

#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)

封装

从封装本身的意思去理解,封装就好像是拿来一个麻袋,把小猫,小狗,小王八,还有alex一起装进麻袋,然后把麻袋封上口子。照这种逻辑看,封装=‘隐藏’,这种理解是相当片面的

如何实现隐藏:

  • 在python中用双下划线开头的方式将属性隐藏起来(设置成私有的)
class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo()
        print('from bar')
        #只有在类内部才可以通过__foo的形式访问到.
#A._A__N是可以访问到的,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形

注意:以上的__N是隐藏的属性,注意python里面,以__开头的是隐藏,以__开头,__结尾是python内置的属性和方法,这点大家切记!,不要搞混了;

变形的特点:
1.外部无法直接访问obj.__attrName
2.在类的内部可不可以obj.__AttriName,答案是可以的
3.子类无法覆盖父类__开头的属性;(因为他两个不是一个名字)

封装的意义

1.封装数据属性:明确的区分内外

class People:
    def __init__(self,name,age):
        self.__name =name
        self.__age=age
p=People('egon',18)
P.__name

数据属性分装之后外部是不可以访问的,在内部是可以,但是外部可以间接的访问,我们可以在类的内部开一个接口,通过接口访问,

class People:
    def __init__(self,name,age):
        self.__name =name
        self.__age=age
    def tell_info(self):
        print('Name:<%s> Age:<%s>' %(self.__name , self.__age))
        
p=People('egon',18)
p.tell_info()

如上述的代码,我们把隐藏的属性放在:tell_info()中,外部的实例化对象,要想访问,就通过实例对象.tell_info()这种方法,这就要通过接口方法来访问的,方便快捷;

2.同样上述的代码,用户不能对name,age直接进行修改了,我们需要开一个接口可以供用户进行修改;

class People:
    def __init__(self,name,age):
        self.__name =name
        self.__age=age
    def tell_info(self):
        print('Name:<%s> Age:<%s>' %(self.__name , self.__age))
    def set_info(self,name,age):
        if not isinstance(name,str):
            print("名字是字符串")
            return
        if not isinstance(age,str):
            print("年龄是字符串")
            return
        self.__name =name
        self.__age=age
        
        
p=People('egon',18)
p.tell_info()
P.set_info('EGON',38)#这里我们用的开的接口来修改的
P.set_info('egon','12')
  • 这就是我们数据属性的封装,明确的区分内外,控制外部对影藏属性的操作行为;

封装方法的目的

  • 为了:隔离复杂度;

例如我有一个取款的例子:

class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print——bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')
    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()
    a=ATM()
    a.withdraw()
>* 如上述的代码可以看出,我们外部的实例通过,withdraw可以访问完全;

封装与扩展性:

以前我们说过:面向对象的优点有:可扩展性高,其实封装也是可扩展性的高的一个方面;

class Room:
    def __init__(self,namek,owner,height,weight,length)
        self.name = name
        self.owner=owner
        #如果只想让用户访问:房间的长度和宽度,这里我们就可以把宽度和长度变为隐藏;
        self.__weight=weight
        self.__length=length
r=Room('房间','wo',10,10)

1.如果问题来了,我们要只想访问房间的面积而不是房间的属性呢?

class Room:
    def __init__(self,namek,owner,height,weight,length)
        self.name = name
        self.owner=owner
        #如果只想让用户访问:房间的长度和宽度,这里我们就可以把宽度和长度变为隐藏;
        self.__weight=weight
        self.__length=length
        
    def tell_area(self):
        return self._weight*self.__length
        
r=Room('房间','wo',10,10)
print(r.tell_area())

如上述我们使用者,只需要关心的是:r.tell_area()究竟里面的逻辑如何我们不用管,这就为我们提供了方便,类的扩展性;

  • 如果计算房间的体积呢?
class Room:
    def __init__(self,namek,owner,height,weight,length,height)
        self.name = name
        self.owner=owner
        #如果只想让用户访问:房间的长度和宽度,这里我们就可以把宽度和长度变为隐藏;
        self.__weight=weight
        self.__length=length
        self.__height=height
        
        
    def tell_area(self):
        return self._weight*self.__length*self.__height
        
r=Room('房间','wo',10,10)
print(r.tell_area())

同样对于使用者来说,他们不需关心内部的处理逻辑,他们只需要调用就好了;

property的使用:

例如:如下描述:
技术分享图片
实现BMI指数程序:

class People:
    def __init__(self,name,weiht,height):
        self.name=name
        self.weight=weigth
        self.height=height
P=People('ll',1.81,75)
bmi=p.weight/(p.height ** 2)
#或者可以写成如下的:
p.bmi =p.weight / (p.height **2)
print(p.bmi)

问题:
如上述的方法bmi,虽然我们实现了,但是我们每次都要定义bmi,是不是很麻烦,而且bmi不是固定的,是随着人的身高体重变化的,而不是一成不变的,那么问题来了,我们怎么实现简单化呢?

  • 这里我们可以把bmi,定义成为方法,然后放置在类里面 ,这样以后的实例只需要调用这个方法就好了,不用每次实例化去计算了;
class People:
    def __init__(self,name,weiht,height):
        self.name=name
        self.weight=weigth
        self.height=height
    def bmi(self):
        return self.weight/(p.height ** 2)
        
        
P=People('ll',1.81,75)
print(p.bmi())#bmi后边的()意味着调用函数

如上述的代码,对于用户而言,他把bmi看成指数,加()他们反而不懂,或者说是会误解,对于用户他们就把指数bmi当成了一个名词,而不是()的方法;用户最终想实现的其实就是p.bmi
所以要实现p.bmi我要在class类里面,bmi()上边加个,装饰器:

class People:
    def __init__(self,name,weiht,height):
        self.name=name
        self.weight=weigth
        self.height=height
    @property
    def bmi(self):
        return self.weight/(p.height ** 2)
P=People('ll',1.81,75)
print(p.bmi())#bmi后边的()意味着调用函数

补充一个知识点:property的使用:
比如自己定义一个property的用法;

class People:
    def __init__(sefl,name):
        self.__name=name
p =People('egon') 

如上述我们肯定获取不到名字怎么办呢?

答案:我们肯定要通过接口来获取名字

class People:
    def __init__(sefl,name):
        self.__name=name
    def get_name(self):
        return self.__name
        
p =People('egon') 
print(p.get_name())

然后对于使用者而言:他们就想访问属性而已,不用通过方法,要不然用户会懵逼;

那么问题来了,我们怎么来搞呢?(答案只有加装饰器了,如下图代码)

class People:
    def __init__(sefl,name):
        self.__name=name
    @property
    def get_name(self):
        return self.__name
        
p =People('egon') 
print(p.name)

这里我们通过property来说明,另一个property的用法:

class People:
    def __init__(sefl,name):
        self.__name=name
        
    @property
    def name(sefl):
        return self.__name
    @name.setter
    def name(self,val):
        if not isinstance(val,str):
            print('名字必须是字符串类型的')
            return
        self.__name =val
    @name.deleter
    def name(self):
        print('不让删除')
    
        
p =People('egon') 
p.name #这里触发的是第一个,return self.__name
p.name='DDD'#这个是访问行为,触发的是def name(self,val),如上述的修改的逻辑

del p.name#删除属性

如上述所述:我们之要掌握,不需要掌握太多;

@property
    def name(sefl):
        return self.__name
  • 总结,如果说一些东西不能像属性一样,需要定一个方法来实现,但是用户又想把这些当做属性来访问,而不是方法,()之类的东西,所以要这里我们需要使用property装饰之类东西来满足需要;
    这里上述的
@property
    def name(sefl):
        return self.__name
  • 就是一些东西无法通过属性直接访问的,所以就定义一个方法,然后呢,我们用户又不懂什么方法不方法的,用户要按照属性一个的访问,所以这时候就用到了装饰器;

面向对象之继承

标签:工作   分享图片   abc   优点   字符串   自己   深度   ssr   根据   

原文地址:https://www.cnblogs.com/surewing/p/9775694.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 mamicode.com 版权所有 京ICP备13008772号-2
迷上了代码!