1. 首页
  2. 文章中心
  3. python

python下的面向对象及其三大特点面向对象的基础语法类的设计内置方法面向对象三大特征封装继承多继承多态

153 阅读 0 评论
我是靠谱客的博主 老实跳跳糖，这篇文章主要介绍python下的面向对象及其三大特点面向对象的基础语法类的设计内置方法面向对象三大特征封装继承多继承多态，现在分享给大家，希望可以做个参考。

面向对象的基础语法

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

复制代码
1
2
3
4
5
class 类名：
    def 方法1(self,参数列表)：
        pass
    def 方法2(self,参数列表)：
        pass

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

复制代码
1
对象变量 = 类名()

类的设计

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

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

例如：

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

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

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

复制代码
1
2
3
4
5
6
7
8
9
10
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__方法

例如：

复制代码
1
2
3
4
5
6
7
8
9
10
11
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__这个内置方法了
例如：

复制代码
1
2
3
4
5
6
7
8
9
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公斤

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
摆放家具
需求：
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 '户型：%sn总面积：%.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

结果

继承

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

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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. 代码其他的位置针对子类的需求，编写子类特有的代码实现

示例：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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.覆盖父类的方法

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

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

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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()

覆盖父类

多继承

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

语法：

复制代码
1
2
class 子类名(父类名1, 父类名2...)
    pass

示例：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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()

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

多态

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

示例：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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)

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

最后

以上就是老实跳跳糖最近收集整理的关于python下的面向对象及其三大特点面向对象的基础语法类的设计内置方法面向对象三大特征封装继承多继承多态的全部内容，更多相关python下内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(101)

相关文章

python面向对象（一）- 面向对象基础
python面向对象（一）- 面向对象基础
类和对象类和对象
类和对象类和对象
Python 面向对象基础（一）
Python 面向对象基础（一）
Python基础学习之面向对象基础1.面向对象2.类和对象3.构造函数__init__4.析构函数__del__
Python基础学习之面向对象基础1.面向对象2.类和对象3.构造函数__init__4.析构函数__del__
python下的面向对象及其三大特点面向对象的基础语法类的设计内置方法面向对象三大特征封装继承多继承多态
python下的面向对象及其三大特点面向对象的基础语法类的设计内置方法面向对象三大特征封装继承多继承多态
象棋为什么不多不少刚好有五个兵？
象棋为什么不多不少刚好有五个兵？
Java与对象
Java与对象
Java 基本一：类、对象
Java 基本一：类、对象

评论列表共有 0 条评论

立即
投稿
返回
顶部