python 面向对象编程

-- 面向过程：根据业务逻辑从上到下写代码。

-- 函数时：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可。

-- 面向对象：对函数进行分类和封装。

1.创建类和对象

面向对象是一种编程方式，这个编程方式的完成需要使用“类”和“对象”来实现，所以，面向对象编程其实就是对“类”和“对象”的使用。

1.1 类

-- 类是对一群具有相同特征或者行为的事物的统称，是抽象的，不能直接使用

　　-- 特征被称为属性

　　-- 行为被称为方法

-- 类就相当于制造飞机时的图纸，是一个模板，是负责创建对象的。

1.2对象

-- 对象是由类创建出来的一个具体存在，可以直接使用。

-- 由哪个类创建出来的对象，就拥有在哪个类中定义的：属性和方法。

-- 对象就相当于用图纸制造的飞机。

1.3.类和对象的关系

--类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象。

--类只有一个，而对象可以有很多个；不同的对象之间的属性可能会各有不同。

--类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少。

1.4.类的设计

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

-- 类名这类事物的名字，满足大驼峰命名法----每一个单词的首字母大写；单词与单词之间没有下划线。

-- 属性这类事物具有什么样的特征。

-- 方法这类事物具有什么样的行为

class是关键字，表示类。

class 类名:

    def 方法1(self, 参数列表):
        pass
    
    def 方法2(self, 参数列表):
        pass

# 创建类
class Foo:
    def person(self):
        print('钢铁侠')

    def hello(self, name):
        print('i am %s' % name)


obj = Foo()
obj.person()
obj.hello('iron man')

2.面向对象的三大特性

面向对象的三大特性是指：封装、继承和多态。

2.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):
        """跑步"""

        print("%s 爱跑步，跑步锻炼身体" % self.name)
        self.weight -= 0.5

    def eat(self):
        """吃东西"""

        print("%s 是吃货，吃完这顿再减肥" % self.name)
        self.weight += 1


xiaoming = Person("小明", 75)

xiaoming.run()
xiaoming.eat()
xiaoming.eat()

print(xiaoming)

实例

2.2继承

--继承，面向对象中的继承和现实中的继承相同，即：子可以继承父的内容。

例如：猫可以：喵喵叫、吃、喝、拉、撒

狗可以：汪汪叫、吃、喝、拉、撒

如果我们分别为猫和狗创建一个类，那么就需要为猫和狗实现它们所有的功能：

class 猫：

    def 喵喵叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 汪汪叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

伪代码

从以上代码可以看出，吃、喝、拉、撒是猫和狗都具有的功能，所有可以使用继承的方法来简化。

# 继承
class Animal:
    def eat(self):
        print("%s 吃" % self.name)

    def drink(self):
        print("%s 喝" % self.name)

    def shit(self):
        print("%s 拉" % self.name)

    def pee(self):
        print("%s 撒" % self.name)


class Cat(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def yell(self):
        print("喵喵叫")


class Dog(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = '狗'

    def yell(self):
        print("汪汪叫")


c1 = Cat('Tom')
c1.eat()
c1.drink()
d = Dog('Spike')
d.yell()

多继承：python的类可以继承多个类；python的类如果继承多个类，那么其寻找方法的方式有两种，分别是深度优先和广度优先。

-- 当类是经典类时，多继承情况下，会按照深度优先方式寻找。

-- 当类是新式类时，多继承情况下，会按照广度优先方式寻找。

2.3多态

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

-- 多态可以增加代码的灵活度

-- 以继承和重写父类方法为前提

-- 是调用方法的技巧，不会影响到类的内部设计。

实例：

　1.在Dog类中封装方法game

2.定义xiaotianDog继承Dog，并且重写game方法。

3.定义person类，并且封装一个和狗玩的方法。

class Dog(object):

    def __init__(self, name):
        self.name = name

    def game(self):
        print("%s 蹦蹦跳跳的玩耍..." % self.name)


class XiaoTianDog(Dog):

    def game(self):
        print("%s 飞到天上去玩耍..." % self.name)


class Person(object):

    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):

        print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))

        # 让狗玩耍
        dog.game()


# 1. 创建一个狗对象
# wangcai = Dog("旺财")
wangcai = XiaoTianDog("飞天旺财")

# 2. 创建一个小明对象
xiaoming = Person("小明")

# 3. 让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)

小结：person类中需要让狗调用game方法，而不是关心具体是什么狗。

　　　　--game方法是在Dog父类中定义的。

在程序执行时，传入不同的狗对象实参，就会产生不同的执行效果

多态更容易编写出通用的代码，做出通用的编辑，以适应需求的不断变化。

部分参考http://www.cnblogs.com/wupeiqi/

posted @ 2019-04-28 11:14 LAworker 阅读(156) 评论(0) 收藏举报

刷新页面返回顶部

python 面向对象编程

公告