面向对象三大特性编写面向对象程序,self到底是谁

一、函数式编程和面向对象的对比

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

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

　　面向对象：对函数进行分类和封装，让开发“更快更好更强...”；

　　面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。

　　round 1 请开发一个消息提醒的功能（邮件/短信/微信）

 函数式

 面向对象

　　通过第一轮对比，我们发现：

　　　　函数式的特点是：定义简单，调用简单；

　　　　面向对象的特点是：定义复杂，调用复杂，其好处是进行了归类，将某些类似的函数写在了一起。

总结：1、函数式编程可能会比面向对象好；

2、python中支持两种编程方式；

3、面向对象编程方式格式如下：

定义：

class 类名:                        -- 定义了一个类

def 函数名(self):        -- 在类中编写了一个"方法"

pass

调用：

x1 = 类名()                        -- 创建了一个对象/实例化一个对象

x1.函数名()                         -- 通过对象调用其中一个方法.

4、面向对象编程示例：

    class Account:
        def login(self):
            user = input('请输入用户名:')
            pwd = input('请输入密码:')
            if user == 'alex' and pwd == 'sb':
                print('登录成功')
            else:
                print('登录失败')

    obj = Account()
    obj.login()

　　round 2 打印：完成以下功能：

老狗/20岁/男/上山去砍柴

老狗/20岁/男/开车去东北

老狗/20岁/男/喜欢大宝剑

 函数版本

 面向对象版本

总结：1、构造方法

　　# 示例一：
　　class Foo:

    　　def __init__(self,name):     # 构造方法,目的是进行数据初始化.
        　　self.name = name
        　　self.age = 18    # 也可以指定值，不一定非要传参

　　obj = Foo("alex")
　　# 通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可.

    # 示例二：
　　class Bar:
    　　pass
　　obj = Bar()

　　  2、面向对象编程应用：

2.1 将数据封装到对象中，以供自己在方法中调用，如下示例：

　　class FileHandler:
    　　def __init__(self, file_path):
        　　self.file_path = file_path
        　　self.f = open(self.file_path, 'rb')

    　　def read_first(self):
        　　# self.f.read()
        　　# ...

    　　def read_last(self):
        　　# self.f.read()
        　　# ...

    　　def read_second(self):
        　　# self.f...
        　　# ...

　　obj = FileHandler('C:/xx/xx.log')
　　obj.read_first()
　　obj.read_last()
　　obj.read_second()
　　obj.f.close()

　　　　2.2 将数据封装到对象中，以供其他函数调用，如下示例：

　　def new_func(arg):
    　　arg.k1
    　　arg.k2
    　　arg.k6

　　class Foo:
    　　def __init__(self,k1,k2,k6):
        　　self.k1 = k1
        　　self.k2 = k2
        　　self.k6 = k6

　　obj = Foo(11,22,66)
　　new_func(obj)

　　注：Java和C#只支持面向对象编程，而python比较灵活既支持面向对象编程也支持函数式编程。

二、面向对象代码如何编写

1、面向对象代码语法规则，如下示例：

　　class Foo:

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

    　　def detail(self, msg):
        　　print(self.name, msg)

　　obj = Foo("alex")
　　obj.detail("hello world")

　　2、什么时候写面向对象代码？如何写？

2.1 反向：归类 + 提取公共值；

2.2 正向：在指定类中编写和当前类相关的所有代码 + 提取公共值；如下示例：

　　class Person:
    　　def __init__(self, na, gen, age, fig):
        　　self.name = na
        　　self.gender = gen
        　　self.age = age
        　　self.fight = fig

    　　def grassland(self):
        　　self.fight = self.fight - 10

    　　def practice(self):
        　　self.fight = self.fight + 90

    　　def incest(self):
        　　self.fight = self.fight - 666

　　cang = Person('苍井井', '女', 18, 1000)  # 创建苍井井角色
　　dong = Person('东尼木木', '男', 20, 1800)  # 创建东尼木木角色
　　bo = Person('波多多', '女', 19, 2500)  # 创建波多多角色

　　dong.grassland()

二、面向对象三大特征：封装、继承、多态

1、封装

1.1 将相关方法封装到一个类中，如下示例：

　　class Message:
    　　def email(self):pass
    　　def msg(self):pass
    　　def wechat(self):pass

　　　　1.2 将数据封装到一个对象中，如下示例：

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

　　obj = Person('alex', 18, '男')

　　2、继承（原则：先在自己类中找，没有就去父类中找），如下示例：

　　class SuperBase:
    　　def f3(self):
        　　print('f3')

　　class Base(SuperBase):  # 父类, 也称基类
    　　def f2(self):
        　　print('f2')

　　class Foo(Base):  # 子类,也称派生类
    　　def f1(self):
        　　print('f1')

　　obj = Foo()
　　obj.f1()
　　obj.f2()
　　obj.f3()
　　# 父类和子类都是相对的，此例中Base是SupperBase的子类，是Foo的父类

总结：1）继承编写规则，如下：

　　　　         class Foo(父类名):

　　　　　　　　pass

　　   2）支持多继承，即一个子类可以有多个父类（先找左边父类，再找右边）；

3）为什么要有继承和多继承？提高代码的可重用性；

继承的相关练习题：

　　class Base1:
    　　def f1(self):
        　　print('base1.f1')
    　　def f2(self):
        　　print('base1.f2')

　　class Base2:
    　　def f1(self):
        　　print('base2.f1')

    　　def f2(self):
        　　print('base2.f2')

    　　def f3(self):
        　　print('base2.f3')
        　　self.f1()

　　class Foo(Base1,Base2):
    　　def f0(self):
        　　print('foo.f0')
        　　self.f3()
　　obj = Foo()   # 实例化Foo类的一个obj对象
　　obj.f0()
　　# 结果为：
　　# foo.f0
　　# base2.f3
　　# base1.f1

总结：1）多继承先找左边；

2）明确self到底是谁，self是哪个类的对象，那么就从该类开始找(自己没有就找父类)；

　　3、多态

鸭子模型，只要可以嘎嘎叫就是鸭子。由于Python函数传参时，无需指定类型。

    def func(arg): # arg可以是多种类型,只要其中有send方法即可.
        arg.send()

多态就是多种形态或多种状态，由于python原生支持多态，所以没有特殊性，如下是体现python原生多态的示例：

 python原生多态示例