必威体育Betway必威体育官网
当前位置:首页 > IT技术

面向对象三大特点

时间:2019-09-30 15:44:46来源:IT技术作者:seo实验室小编阅读:71次「手机版」
 

面向对象的特征

封装:
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步,将属性和方法封装到一个抽象的类中(抽象是因为类不能被直接使用)
3.外界使用类创建对象,然后让那个对象调用方法
4.对象方法的细节都被封在类的内部
需求
1.小明体重75.0公斤
2.每次跑步会减肥0.5公斤
3每次吃东西体重会增加1公斤
4.小美的体重是45.0公斤
class Person:
    def  __init__(self,name,weight):
        #初始化方法中增加两个参数由外界传值
        #self.属性=形参
        self.name = name
        self.weight = weight
    def __str__(self):
        return '%s的体重是%.2f' %(self.name,self.weight)
    def run(self):
        #在对象的内部可以直接访问对象的属性
        print '%s爱跑步' %self.name
        self.weight -= 0.5
    def eat(self):
        print '%s吃东西'%self.name
        self.weight +=1
xm = Person('小明',75.0)
xm.run()
xm.eat()
print xm

案例2:摆放家具
需求:
1.房子有户型,总面积和家具名称列表
   新房子没有任何的家具
2.家具有名字和占地面积,其中
   床:占4平米
   衣柜:占2平面
   餐桌:占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时,要求输出:户型,总面积,剩余面积,家具名称列表
被使用的类应该先开发
class Furniture:
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self,*args):
        return '[%s] 占地 %.2f'%(self.name,self.area)
class House:
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        self.free_area = area
        self.item_list = []
    def __str__(self):
        return '户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s'\
            %(self.house_type,self.area,self.free_area,self.item_list)
    def add_item(self,item):
        if self.free_area < item.area:
            print '%s 的面积太大了,无法添加' %item.name
            return
        self.item_list.APPend(item.name)
        self.free_area -= item.area

bed = Furniture('bed',4)
chest = Furniture('chest',2)
table = Furniture('table',1.5)
# print bed
# print chest
# print table
my_house = House('两室一厅',60)
my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
print my_house

需求:
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
class Gun:
    def __init__(self,model):
        self.model = model
        self.bullet_count = 0
    def add_bullet(self,count):
        self.bullet_count += count
    def shoot(self):
        if self.bullet_count <= 0:
            print '[%s]没有子弹了。。。' %self.model
            return
        else:
            self.bullet_count -= 1
        print '[%s]tututu ,,,[%d]' %(self.model,self.bullet_count)

class Soldier:
    def __init__(self,name):
        self.name = name
    def fire(self):
        if self.gun == None:
            print '没有枪'
            return
        print 'go'
        self.gun.add_bullet(50)
        self.gun.shoot()
ak47=Gun('AK47')
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print ryan.gun

私有属性和私有方法
应用场景及定义方式
应用场景
   在实际开发中,对象的某些属性或方法可能只希望在对象的内部使用,而不希望在外部被访问到
   私有属性 就是 对象 不希望公开的 属性
   私有方法 就是 方法 不希望公开的 方法
定义方法
   在定义属性或方法时,在属性名或者方法名前增加两个下划线,定义的就是私有属性或方法
class Women:
    def __init__(self,name):
        self.name = name
        self.__age = 18
    def __secret(self):
        print '%s 的年龄是 %d' %(self.name,self.__age)

lily = Women('lily')
print lily.name
# 私有属性,外界不能直接访问
#print lily.age
# 私有方法,外界不能直接调用
lily.secret()

面向对象的特征
    1.封装:根据职责将属性和方法封装到一个抽象的类中
    2.继承:实现代码的重用,相同代码不需要重复的写
    3.多态:(以封装和继承为基础)不同的子类对象调用相同的方法产生不同的结果
单继承
继承:子类拥有父类的所有属性和方法
class 类名(父类):
    def  子类特有方法
子类也叫派生类
父类也叫基类
class Animal(object):
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def  run(self):
        print '跑'
    def  sleep(self):
        print '睡'


class Cat(Animal):
    #子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵'
class Dog(Animal):
    def bark(self):
        print '汪汪'
class Hellokitty(Cat):
    def speak(self):
        print  '我可以说日语'
#创建一个猫对象,继承Animal的所有属性和方法
mao = Cat()
mao.call()
#创建一个狗对象,继承Animal的所有属性和方法
gou = Dog()
gou.run()
gou.bark()
#创建一个hellokitty对象,继承Cat的所有属性和方法
"""
继承的传递性:(爷爷 父亲 儿子)
1.c类从b类继承,b类又从a类继承
2.那么c类就具有b类和a类的所有属性和方法
子类拥有父亲以及父类的父类中的封装的所有属性和方法
"""
kt=Hellokitty()
kt.speak()
kt.run()
kt.call()
#子类继承自父类,可以直接享受父类中已经封装好的方法
#子类中应该根据自己的职责,封装子类特有的属性和方法

重写父类方法:
    1.覆盖父类的方法
    2.扩展父类的方法
class Animal:
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def  run(self):
        print '跑'
class  Cat(Animal):
    #子类拥有父类的所有方法和属性
    def call(self):
        print '喵喵'
class Hellokitty(Cat):
    def speak(self):
        print '我可以说日语'
    def call(self):
        #针对子类特有的需求,编写代码
        print '你好'
        #调用原本在父类中封装的代码
        Cat.call(self)
        #增加其他的子类的代码
        print '####'
kt = Hellokitty()
#如果子类中,重写了父类的方法
#在运行中,只会调用子类中重写的父类的方法而不会调用父类的方法
kt.call()

注意init方法也可以被覆盖所以要就加上

Bird.__init__(self)
class Bird:
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print '吃....'
            self.hungry = False
        else:
            print  'No thants'
class SongBird(Bird):
    def __init__(self):
        Bird.__init__(self)
        self.sound = 'Squawk!'
    def sing(self):
        print self.sound
littlebird = SongBird()
littlebird.eat()
littlebird.sing()

多继承的顺序

class C(A,B)  继承A(如果A,B的方法名称一样)

class C(B,A)继承B(如果A,B的方法名称一样)

类的私有属性和私有方法
    1.子类对象不能在自动的方法内部,直接访问对象的私有属性和私有方法
    2.子类对象可以通过父类的公有方法直接访问到私有属性和私有u方法
私有属性,私有方法,私有方法是对象的隐私,不对外公开,外界以及子类都不能直接访问
私有属性,私有方法常用做一些内部的事情
class A:
    def __init__(self):
        self.num1 = 100
        self.__num2 = 200
    def __test(self):
        print '私有方法 %d %d' % (self.num1, self.__num2)
    def test(self):
        print '父类的共有方法 %d' % self.__num2
        self.__test()
class B(A):
    def demo(self):
        # 在子类的对象方法中,不能访问父类的私有属性
        # # print '访问父类的私有属性 %d '%self.__num2
        # 在子类对象的方法中,不能调用父类的私有方法
        # # self.__test()
        self.test()

b = B()
b.demo()

# 在外界不能直接访问对象的私有属性/调用私有方法
print b.__num2
b.__test()

多态

3.多态:(以封装和继承为基础)不同的子类对象调用相同的方法产生不同的结果
比如人类由一个方法:work(self):
程序设计师调用这个相同的方法得到不同的结果
class Dog(object):
    def __init__(self, name):
        self.name = name
    def play(self):
        print '%s 玩皮球' % self.name

class Xiaotiandog(Dog):
    #父类方法不能满足子类方法,重写play方法
    def play(self):
        #在使用继承时,子类拥有父类的所有属性和方法
        print '%s 飞到天上' % self.name
class Person(object):
    def __init__(self, name):
        self.name = name
    def play_with_dog(self,dog):
        print '%s 和 %s 玩得很开心' %(self.name,dog.name)
        dog.play()
#1.创建一个狗对象
# wangcai = Dog('旺财')
wangcai = Xiaotiandog('旺财')
#2.创建一个小明对象(小明是一个人)
xiaoming =Person('小明')
#3.让小明调用和狗玩的方法(把之前创建的狗对象传递出去)
xiaoming.play_with_dog(wangcai)

相关阅读

香农三大定理

香农三大定理是信息论的基础理论。香农三大定理是存在性定理,虽然并没有提供具体的编码实现方法,但为通信信息的研究指明了方向。香

互联网三大巨头银行,网商银行、微众银行和新网银行有什

话说腾讯,小米和阿里巴巴在各自的领域都取得了巨大的成功,但是三家企业都想在对方优势行业打一个伏击战,微信通过红包这个功能在支付

三大数学危机——人类思想的发展史

第一次数学危机——无理数的发现。以前人们公认所有的数都可以表示成2个整数的比值。然后有了毕达哥拉斯定理,取最简单的情形,2个直

面向对象:斯人若彩虹,遇上方知有

各位男生如果看

联想中国区架构调整:聚焦大客户、中小企业客户及消费客

A5创业网(公众号:iadmin5)1月9日报道,1月7日晚,联想集团执行副总裁兼中国区总裁刘军发布内部邮件,宣布联想中国区进行组织架构调整。此

分享到:

栏目导航

推荐阅读

热门阅读