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

面向对象的自我总结

时间:2018-10-21 15:15:27      阅读:170      评论:0      收藏:0      [点我收藏+]

标签:关注   pytho   def   包含   __str__   数据   cme   面向过程   程序设计   

面向过程是一种以过程为中心的编程思想。
面向对象程序设计主要针对大型软件设计提出的,次编程方式的实现是基于对类和对象的使用。
总结3大特点:封装,继承,多态

class Car():
    def __init__(self,pp="宝马",ys="红色",jg="35W"):#类中的构造方法
        self.pp=pp         #__init__()为构造函数,在创建一个对象时被调用,第一个参数是self
        self.ys=ys         #实例属性
        self.jg=jg

    def jia_shi(self):  #公有方法
        print("我正驾驶一辆%s色的%s车"%(self.ys,self.pp))

    def setter_name(self,n):  #调用该方法可以重置该值
        self.pp = n

    def getter(self):         #调用该方法可以获取该值
        return self.pp

    def __str__(self):        #该方法是魔法方法,可以返回这个对象包含的信息
        return ‘你的%s爱车要定期保养‘%self.pp

    def __del__(self):
        print(‘我已被删除‘)     #该方法为析构方法,每次创建对象后Python解释器默认调用该方法,无需手动调用

    car1=Car("奔弛","黑色","40W")  #实例化对象

    car1.jia_shi()                #实例对象调用实例方法
    #我正驾驶一辆黑色色的奔弛车

    print(car1.pp)                #实例对象调用实例属性
     #奔弛

    print(car1)                   #调用__str__方法返回字符串
    #你的奔弛爱车要定期保养

    def car1                      #删除对象后无法再调用该对象

总结:实例方法,属性只能被被实例对象调用,类无法调用!这些方法也叫做公有方法。

私有方法

    def jia_shi(self):       #公有方法
        self.__woshijingtai()#私有方法只能在类中通过self调用,对象无法调用

    def __woshijingtai(self): #私有方法以双下划线开始
        __n = 100   #私有属性
        print(‘我是静态‘)
    car1.jia_shi()            #可以间接通过公有方法调用
    #我是静态

总结:私有方法和私有属性只能在类中被调用!

类中的属性与方法
    class Car():
        a = ‘我是类的属性‘
    def jia_shi(self):         #公有方法
        print(self.a)

    @classmethod               #类方法,用该装饰器进行装饰
    def setleifangfa(cls,i):   #一般以cls作为第一个参数
        cls.a = i
    @classmethod
    def getleifangfa(cls):
        return cls.a

    car1.setleifangfa(‘我要改变私有‘)  
    #我要改变私有

    print(car1.getleifangfa())
    #我要改变私有

总结:实例对象可以调用类的方法与属性,同样可以被类在自身中调用

静态方法

静态方法中不需要额外添加定义参数,因此在静态方法中必须通过类对象来引用
静态方法是一种普通函数,位于定义的命名空间中,它不会对任何实例类进行操作。

class Car():
    a = ‘我是静态方法‘
    @staticmethod
    def get():
        print(Car.a)
    car1=Car()
    car1.get()
#我是静态方法

总结:静态方法用 @staticmethod装饰器装饰,它可以被类,实例对象调用!

继承

父类可以是一个或者多个,不用继承则空着
继承分为多继承与单继承 注意:父类的属性,方法可以继承给子类,父类的私有属性,方法无法被继承!

class Super_A(object):
    def __init__(self):
        self.name = ‘jack‘
   def info_a(self):
        print(‘我是父类‘)

class Super_B(Super_A):
    def __init__(self):
        Super_A.__init__(self) #调用父类的init函数
    super().__init__()         #也可以用super方法继承过来
        self.age = 18
    def info_b(self):
        print(self.name,self.age)

car2 = Super_B()
car2.info_a()  
car2.info_b()  
#我是父类
#jack 18

总结:派生类定义 init()时,不会自动调用基类的_init_()函数,想要得到基类的_init()中的信息,由派生类调用基类的_init()函数来对它进行恰当的初始化。

多继承

class Person():

    def run(self):   # 公开方法在子类中可以直接访问,也可以被覆盖
        print(‘Person 会跑‘)

    def eat(self):
        print(‘Person 会吃‘)

class Man(Person):
    def fight(self): 
        print(‘Man 打架‘)

class Woman(Person):
    def taobao(self):
        print(‘Woman 淘宝‘)

class NvHanzi(Woman, Man):  # Hanzi继承了Man、Woman的函数和属性
    pass   # 空,什么都不做

hanzi = NvHanzi()
hanzi.run()
hanzi.eat()
hanzi.taobao()
hanzi.fight()

运行结果:
Person 会跑
Person 会吃
Woman 淘宝
Man 打架

修改父类的方法,也叫重写

class Person(): 
     def run(self):   # 公开方法在子类中可以直接访问,也可以被覆盖
          print(‘Person 会跑‘)

     def eat(self):
          print(‘Person 会吃‘)

class Man(Person):
     def run(self):  # 在子类中修改父类的方法,会覆盖Person类(父类)的run函数
         print(‘Man在跑‘)

 m = Man()  # 自动调用父类的构造函数
 m.run()    #  Man类中覆盖父类中的run函数,m调用的是Man类中的run函数
运行结果:
Man在跑

多态

多态是面向对象语言的一个基本特性,多态意味着变量并不知道引用的对象是谁,根据引用对象的不同表现不同的行为方式。

class ChuiFengJi:   # 我们叫具有吹风功能的事物,叫吹风机
    def chui(self):   # 吹风功能
        print("吹风机 能吹风")

class MeiDi(ChuiFengJi):
    def chui(self):
        print("美的   能吹风")

class FeiLiPu(ChuiFengJi):
    pass

def who_zai_chui(arg):  
    arg.chui()  

c = ChuiFengJi()
m = MeiDi()
f = FeiLiPu()

who_zai_chui(c)
who_zai_chui(m)
who_zai_chui(f)
运行结果:

吹风机 能吹风
美的   能吹风
吹风机 能吹风
由于Python是动态语言,所以,传递给函数 who_zai_chui(a)的参数 a 不一定是 ChuiFengJi 或 ChuiFengJi 的子类型。
任何数据类型的实例都可以,只要它有一个chui()的方法即可,这就是多态。

鸭子类型

鸭子类型:
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”
在鸭子类型中,不关注对象的类型,只关注它是如何使用的。
比如:吹风机吹风这个功能,在鸭子类型中,只关注它能不能打吹风,而不关心它是谁。
class ChuiFengJi:   # 我们叫具有吹风功能的事物,叫吹风机
    def chui(self):   # 吹风功能
        print("吹风机 能吹风")

class MeiDi(ChuiFengJi):
    def chui(self):
        print("美的   能吹风")

class FeiLiPu(ChuiFengJi):
    pass

class PiXie:   # PiXie具有吹风的功能,我们就称PiXie是吹风机,这就是鸭子类型
    def chui(self):
        print("皮鞋   能吹风")

class WenQuXing:  # 不具有吹风的功能,就不是吹风机
    pass

def who_zai_chui(arg):  # 测试函数,test只接受参数,但是不关心参数arg的类型
    arg.chui()   # 只关心arg能不能调用call函数,不关心它的类型

c = ChuiFengJi()
m = MeiDi()
f = FeiLiPu()
p = PiXie()
w = WenQuXing()

who_zai_chui(c)
who_zai_chui(m)
who_zai_chui(f)
who_zai_chui(p)

面向对象的自我总结

标签:关注   pytho   def   包含   __str__   数据   cme   面向过程   程序设计   

原文地址:https://www.cnblogs.com/gaosai/p/9825056.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!