python下的面向对象及其三大特点

其他 2018-07-24 05:10:53 阅读次数: 0

面向对象的基础语法

定义简单的类：
定义只包含方法的类：

class 类名：
    def 方法1(self,参数列表)：
        pass
    def 方法2(self,参数列表)：
        pass

当一个类定义完成之后，要使用这个类来创建对象，语法格式如下：

对象变量 = 类名()

类的设计

在程序开发中，要设计一个类，通常需要满足以下三个要求：

  1. 类名 这类事物的名字，满足大驼峰命名法
  2. 属性 这类事物具有什么样的特征
  3. 方法 这类事物具有什么样的行为

例如：

小明今年18岁，身高1.75，每天早上要跑步，会去吃东西
小美今年17岁，身高1.65，小美不跑步，小美喜欢吃东西
类名：Person( )
属性：name age height
方法：run( ) eat( )

一只黄颜色的狗狗叫大黄
看见生人汪汪叫
看见家人摇尾巴
类名：Dog( )
属性：color name
方法：shout( ) shake( )

示例：需求：
小猫爱喝水，小猫爱吃鱼

class Cat():
    def drink(self):
        print '小猫爱喝水'
    def eat(self):
        print '小猫爱吃鱼'

# 创建猫对象
Tom = Cat()
Tom.drink()
Tom.eat()

小猫爱喝水，小猫爱吃鱼
self：哪一个对象调用的方法，self就是哪一个对象的引用
self

初始化方法

我们现在已经知道了使用 类名( ) 就可以创建一个对象
当使用类名( )创建对象时，python的解释器会自动执行以下操作：

  1. 为对象在内存中分配空间——创建对象
  2. 调用初始化方法为对象的属性设置初始值–初始化方法(__init__)

这个初始化方法就是__init__方法，__init__是对象的内置方法
__init__方法是专门用来定义一个类具有哪些属性的方法
初始化方法
使用类名()创建对象的时候，会自动调用初始化方法 __init__

内置方法

__del__方法：

在python中
当使用类名( )创建对象时，为对象分配完空间后，自动调用__init__
当一个对象被从内存中销毁前，会自动调用__del__方法

例如：

class Cat():
    def __init__(self,name):
        self.name = name
        print '%s来了' % self.name
    def __del__(self):
        print '%s走了' % self.name

tom = Cat('tom')
print tom.name
del tom
print '#' * 50

__del__

__str__方法:

在python中，使用python输出对象变量，
默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，
以及在内存中的地址(十六进制表示)

如果在开发中，希望使用print输出对象变量时，
能够打印自定义的内容，就可以利用__str__这个内置方法了
例如：

class Cat():
    def __init__(self,name):
        self.name = name
    def __str__(self):
        # 必须返回一个字符串
        return '我是%s' % self.name

tom = Cat('tom')
print tom

__str__

面向对象三大特征

封装:根据职责将属性和方法封装到一个抽象的类中
继承:实现代码的重用，相同的代码不需要重复的编写
多态:不同对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

封装

封装

  1. 封装是面向对象编程的一大特点
  2. 面向对象编程的第一步 将属性和方法封装到一个抽象的类中
  3. 外界使用类创建对象，然后让对象调用方法
  4. 对象方法的细节都被封装在类的内部

示例：
XX爱跑步
1.XX体重75.0公斤
2.XX每次跑步会减肥0.5公斤
3.XX每次吃东西体重会增加1公斤

class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def __str__(self):
        return '我是%s,体重%.2f' % (self.name, self.weight)

    def run(self):
        self.weight -= 0.5
        print '%s跑步减肥0.5公斤' % self.name

    def eat(self):
        self.weight += 1
        print '%s吃胖了1公斤' % self.name

XX = Person('XX', 75.0)
print XX
XX.run()
XX.eat()
XX.eat()
print XX

print ''
print '*' * 50
print ''

XX2 = Person('XX2', 45.0)
print XX2
XX2.eat()
print XX2

代码
结果

练习：

1.士兵瑞恩有一把AK47
2.士兵可以开火（士兵开火扣动的时扳机）
3.枪 能够 发射子弹（把子弹发射出去）
4.枪 能够 装填子弹 ——增加子弹的数量
Soldier                 Gun
————————————            ————————————
name                    model
gun                     bullet_count #子弹数量足够多才能完成射击的动作
————————————            ————————————
__init__(self):         __init__(self):
fire(self):             add_bullet(self,count):# 装填子弹的方法
                        shoot(self):

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
        self.bullet_count -= 1
        print '%s 突突突 %d' % (self.model, self.bullet_count)

class Soldier:
    def __init__(self, name):
        self.name = name
        self.gun = None
    def bullet_add(self, count):
        self.gun.add_bullet(count)
    def fire(self):
        if self.gun == None:
            print '%s没有枪' % self.name
            return
        print 'go!!!'

        ryan.gun.shoot()

ak47 = Gun('AK47')

ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.bullet_add(50)
ryan.fire()
ryan.fire()
ryan.fire()
print ryan.gun

结果
练习：

摆放家具
需求：
1.房子有户型，总面积和家具名称列表
    新房子没有任何的家具
2.家具有名字和占地面积，其中
    床：占4平米
    衣柜：占2平米
    餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出：户型，总面积，剩余面积，家具名称列表

class Fur:                                                     
    def __init__(self, name, area):                            
        self.name = name                                       
        self.area = area                                       
    def __str__(self):                                         
        return '[%s]占地%.2f' % (self.name, self.area)           

bed = Fur('bed', 4)                                            
clothes = Fur('clothes', 2)                                    
table = Fur('table', 1.5)                                      

class House:                                                   
    def __init__(self, type, area):                            
        self.type = type                                       
        self.area = area                                       
        self.free = area                                       
        self.fur = []                                          
    def __str__(self):                                         
        return '户型：%s\n总面积：%.2f[剩余%.2f]\n家具:%s' % \            
               (self.type, self.area, self.free, self.fur)     
    def add_fur(self, fur):                                    
        if fur.area > self.free:                               
            print '%s的面积太大了，无法添加' % fur.name                   
            return                                             
        self.fur.append(fur.name)                              
        self.free -= fur.area                                  
        print '添加%s' % fur                                     
my_house = House('两室一厅', 60)                                    
my_house.add_fur(bed)                                          
my_house.add_fur(clothes)                                      
my_house.add_fur(table)                                        
print ''                                                       
print my_house

结果

继承

实现代码的重用，相同的代码不需要重复的编写
例如：

class Animal():
    def eat(self):
        print 'eat'
    def drink(self):
        print 'drink'
    def run(self):
        print 'run'
    def sleep(self):
        print 'sleep'

class Cat(Animal):
    def call(self):
        print 'miao'

class HelloKitty(Cat):
    def speak(self):
        print "kou'ni'ji'wa"

hellokitty = HelloKitty()
hellokitty.speak()
hellokitty.call()
hellokitty.eat()
hellokitty.drink()
hellokitty.run()
hellokitty.sleep()

继承01
重写父类方法有两种情况：

  1. 对父类方法进行扩展
  2. 覆盖父类的方法

1.对父类方法进行扩展

如果在开发中，子类的方法实现包含有父类的方法实现
（父类原本封装的方法实现是子类方法实现的一部分就可以使用扩展方法）

  1. 在子类中重写父类的方法
  2. 在需要的位置使用 父类名.方法（self）来调用父类方法的执行（使用父类名称调用父类方法）
  3. 代码其他的位置针对子类的需求，编写子类特有的代码实现

示例：

class Cat():
    def call(self):
        print 'miao'

class HelloKitty(Cat):
    def speak(self):
        print "kou'ni'ji'wa"
    def call(self):
        print "ou'ha'you"
        # 调用原本在父类中封装的方法
        Cat.call(self)
        print '@^&$@'

hellokitty = HelloKitty()

hellokitty.call()

扩展

2.覆盖父类的方法

如果在开发中，父类的方法实现和子类方法的实现完全不同，就可以用覆盖的方式，
在子类中重写编写父类的方法

具体实现方式，就相当于在子类中定义了一个和父类同名的方法并且实现
重写之后，在运行时，只会调用子类的重写凡方法，而不会再调用父类封装的方法
示例：

class Bird:
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print 'Guu...'
            self.hungry = False
        else:
            print 'noo'
class Sing_bird(Bird):
    def __init__(self):
        self.sound = 'zierwazierwa'
        Bird.__init__(self)
    def song(self):
        print self.sound

bird = Sing_bird()
bird.eat()
bird.song()

覆盖父类

多继承

子类拥有一个父类叫做单继承
子类可以拥有多个父类，并且具有所有父类的属性和方法
例如：孩子会继承自己父亲和母亲的特性

语法：

class 子类名(父类名1, 父类名2...)
    pass

示例：

class A(object):
    def test(self):
        print 'A---TEST'
    def demo(self):
        print 'A---DEMO'
class B():
    def test(self):
        print 'B---TEST'
    def demo(self):
        print 'B---DEMO'

class C(B, A):
    # 多继承可以让子类对象，同时具有多个父类的属性和方法
    pass
c=C()
c.test()
c.demo()

多继承
多继承时优先继承写在前面的父类

多态

不同的子类对象调用相同的方法，产生不同的执行结果

示例：

class Dog(object):
    def __init__(self, name):
        self.name = name
    def game(self):
        print '%s蹦蹦跳跳的玩' % self.name
class xiaotian(Dog):
    def game(self):
        print '%s上天' % self.name
class Preson(object):
    def __init__(self, name):
        self.name = name
    def game_with_dog(self, dog):
        print '%s和%s玩' % (self.name, dog.name)
        dog.game()
wangcai=xiaotian('WANGCAI')
xiaoming=Preson('XIAOMING')
xiaoming.game_with_dog(wangcai)

多态
不同的子类对象调用相同的方法，产生不同的执行结果

猜你喜欢

转载自blog.csdn.net/qq_40303205/article/details/81168956
今日推荐
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
最强开源大模型 Llama 3 上架 Gitee AI
周排行
自媒体文章如何提高原创度以及如何检测原创度
开启qq邮箱的smtp服务
Qt程序单次启动（QSingleApplication类）
国外的外包网站
更新IDEA主题——放飞代码风格
cocos2dx 实现搓牌效果（翻牌效果），包括铺平动画
dict和json之间的互相转换
angular的一些思考
. Fibonacci数列是这样定义的： F[0] = 0 F[1] = 1 for each i ≥ 2: F[i] = F[i-1] + F[i-2] 因此，Fibonacci数列就形如：0, 1
洛谷P1064 金明的预算方案
每日归档
更多
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)
2024-04-16(70)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022