python oop培训文档里面的 正宗oop、多个函数间反复return传参、多个文件无限复制粘贴扣字、无效废物滑稽类4种方式的例子。（2）

时间  2019-11-06
标签 python oop 培训 文档 里面 正宗 多个 函数 反复 return 文件 无限 复制 粘贴 无效 废物 滑稽 方式 例子 栏目 Python 繁體版
原文   原文链接

python编程范式培训文档，主要是结合4种代码和，对oop和面向过程编程区别和oop转化公式培训。 html

接这一篇。python

 

 

 

把文档里面说的几种范式发出来。程序员

 4种编程范式实现一我的吃喝拉撒长身体的代码。语法很简单，思想模拟了全部程序员写代码时候的代码规划设计想法。算法

 

0.我不反对复制粘贴的写法，能够百度搜索复制粘贴网上现有的，但反对总是写新代码就把本身的旧代码整个复制几亿次，而后在代码文件里面扣字造成新代码，我不肯意接受这样的项目。若是写代码是使用这样的方式，那就不能好高骛远装逼搞leetcode算法，实际上咱们项目代码里面我看也没有任何算法，反而是不会设计模式 面向对象会对项目形成不少严重不利影响和拖累任务进度。编程

 

 

一、开门见山，发正宗oop设计模式

# coding=utf8
"""
一、实现人的功能。oop写法，使用类/对象 加 方法。
二、重要是要理解面向对象里面的封装，封装是最重要的特色，写出没有体现出封装特色的类就是无效废物类就是面向过程的类。
三、这种写法清晰明了，类/对象 加 方法 的写法 几乎和模块文件加全局变量加函数的写法思路是如出一辙的，只是把命名空间下沉了一级，就能毫无曲折的实现了多实例的要求。继不继承都是次要的，最最最重要是看封装，不要把注意力重点放在这里面的继承了，只是顺便演示一个继承是如何减小代码实现不一样点而已。继承不是面向对象必须的，封装才是。
四、使用oop时候，在实现时候更为简单，几乎行云流水，不须要考虑频繁的考虑传参和return
出状态（变量）给外部。在调用时候也更具有一致性，在调用处只须要一个实例化出一个对象，类的外部只须要一个变量表明此实例便可。不然使用面向过程还须要模拟多实例，在调用处最少须要保存 名字 体重 身高三个变量，而且每次调用函数都须要传入和保存return出来的值，这样调用起来反复传参和return修改外部变量，调用起来复杂和看起来乱七八糟的调用形式不具有一致性。
"""

"""
得出转化公式的规律：
1、针对全局变量加函数无限复制粘贴扣字的写法，
1） 模块级降级为类名
2） 全局变量改为实例属性
3） 函数改成方法

2、针对频繁return和大量重复传参的写法
一、转化公式1
0）在脑壳中重构，把写法形式改为全局变量加函数的写法，此时不用担忧全局变量是惟一的，不用大量重复传参和return，全部须要传参和return的都想象成使用全局变量和操做全局变量。
1） 模块级降级为类名
2） 全局变量改为实例属性
3） 函数改成方法
后面三个步骤是同样的。全局变量变为实例属性后，每次实例化后每一个对象的实例属性都是互不干扰的。每一个对象能够看做为一个模块级写法的 模块文件的无限深拷贝。

二、转化公式2
1） 新增一个类
2）把重复传参和return的形参，全都去掉，改为实例属性
3） 函数改成方法。

对任何面向过程写法，使用转化公式，必定就能够修改为oop，然来的代码思惟不须要作任何改变，只要按这个公式就能够改造。（前提是知足须要使用oop的两个条件，才须要改造）
对新写的代码，也能够按然来的想法写，说的是在脑壳里面那么写（否则真那么写，再修改，浪费花时间），而后按照此公式转化后写在ide里面。
"""

"""
最重要是理解：  命名空间  全局变量  实例属性  多实例需求  函数和方法 的关系，搞清楚了，写oop十分之简单，不会形成极端面向过程的曲折写法。
在word文档中会写更详细的解释。
"""

"""
常见问题解答
一、是否是全部代码都要用oop？
答：不是，按照上面的方式判断用那种方式好，目的是要简单代码少就能够，便于维护扩展就好。
二、函数和类上面区别？
没有区别，就像问人和走路有什么区别，猪和吃饭有什么区别，问得牛头不对马嘴的伪问题，函数和方法才能够比较。类（对象）和模块才有可比性，必需要搞清楚缘由，否则脑壳中有这个比较的想法那就不可能写得了oop。
面向过程是 文件模块名.eat(狗的名字，shit)
oop是  狗.eat(shit)
"""


"""
编程范式
1.1 方式一，平铺指令。 从上往下叠加指令，适合简单的独立脚本。不须要和没机会被别的模块导入。
1.2 方式二，面向过程函数式编程。适合实现独立的转化功能，基本原理是要实现转化 y = f(x)，适合函数无依赖状态（不须要在多个函数中频繁的传入和return相赞成义的参数）。
1.3 方式三，oop编程.适合多个函数间须要使用同一个变量，而且须要多实例（若是使在使用面向过程时候须要使用函数频繁的return各类状态/变量由类外使用多个参数来保存这些值和传入这些值，那就是也判断为须要多实例），必须同时知足这两个条件，才使用oop好，不然不须要oop。（但单例模式为了控制灵活的初始化传参，通常也用类的方式）
1.4 网上说的简单用面向过程，复杂的用面向对象，这简直是错误的废话。简单和复杂界定不了，即便是一个简单的查询价格，通过大量平台的重写对比，oop都能比面向过程减小70%行以上的代码，因此用网上这句话来判断用什么方式来写代码是错误的。只要严格使用上面描述的判断方式，就能很容易知道在什么场景何时使用哪一种方式好了，不须要oop嗨写成类就是没理解好oop能更好地解决什么。
1.5 要多使用oop，但不要写成纯静态或者半静态的无效废物类。 面向过程必定能够搞定一切，可是实现麻烦、调用更麻烦，那就不适合面向过程了。好比猴子补丁能够搞定继承，闭包能够搞定封装，可是没什么好处，实现麻烦。先要转oop，只有放弃极端面向过程，不对面向过程过度的偏执和喜欢，才能开始学习更多设计模式。
"""


class Person:

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

    def show_weight(self):
        print(f'{self.name} 的体重是： {self.weight} 千克')

    def show_height(self):
        print(f'{self.name} 的身高是： {self.height} 厘米')

    def grow_weight(self, growing_weight):   # 增长的体重是可变的外界传来的，须要做为方法的参数传进来，不可避免。
        print(f'{self.name} 的体重增长 {growing_weight} 千克')
        self.weight += growing_weight

    def grow_height(self, growing_height):
        print(f'{self.name} 的身高增长 {growing_height} 厘米')
        self.height += growing_height

    def pee(self):
        """
        举个影响属性的例子，上卫生间小便,会致使体重减小。
        :return:
        """
        self._reduce_weight_because_of_pee()

    def _reduce_weight_because_of_pee(self):
        self.weight = self.weight - 0.1


class Boy(Person):
    # REMIND 须要实现不一样之处
    def pee(self):
        print(f'{self.name} 站着小便')
        super(Boy, self).pee()


class Girl(Person):
    # REMIND 须要实现不一样之处
    def pee(self):
        print(f'{self.name} 蹲着小便')
        super(Girl, self).pee()


if __name__ == "__main__":
    # 在调用处只须要实例化一个对象，不须要学极端面向过程编程，保存不少个变量。
    xiaomin = Boy('小明', 120, 30)
    xiaowang = Boy('小王', 130, 32)
    xiaomin.grow_height(5)
    xiaomin.grow_weight(1)
    xiaomin.show_height()
    xiaomin.show_weight()
    xiaomin.pee()
    xiaomin.show_weight()
    # REMIND 这里实例化两个男孩，缘由是模拟须要多实例，模拟每一个对象的属性是互不干扰的，小明增加体重不会影响到小王的体重。
    # REMIND 若是是使用全局变量 + 函数 或者类名加静态属性（类属性），则会发生互相干扰，正由于这样行不通再加上不使用oop面向对象，就会形成须要写成在一组函数中频繁return和传参，实现上复杂曲折，也很差读懂。这种写法现象在可预订平台的酒店价格解析里面体现得十分之严重，因为多个函数中频繁传参和return，有的参数命名是同一个东西，可是在各个函数中形参的名字取得又不同，不只在维护代码时候难以搞懂，在实现的时候也是麻烦曲折不少。
    print('— ' * 30)
    xiaowang.show_height()
    xiaowang.show_weight()
    xiaowang.grow_height(6)
    xiaowang.grow_weight(2)
    xiaowang.show_height()
    xiaowang.show_weight()
    xiaowang.pee()
    xiaowang.show_weight()

    print('* ' * 30)
    xiaohong = Boy('小红', 110, 25)
    xiaohong.grow_height(3)
    xiaohong.grow_weight(0.5)
    xiaohong.show_height()
    xiaohong.show_weight()
    xiaohong.pee()
    xiaohong.show_weight()
View Code

 

如下为模拟low写法闭包

二、多个函数间反复频繁return 传参.即便实现男女不复制文件扣字来实现，那也要多加一个性别参数，若是撒尿被不少函数调用了，那不少函数都要入参加性别。ide

实现男的函数式编程

# -*- coding: utf-8 -*-
# @Author  : ydf

"""
演示使用极端面向过程来写，因为没有封装，没有成员变量和全局变量，因此形成须要在多个函数中频繁重复传参和return
不管是实现仍是调用都更为复杂。
"""


def show_weight(name, weight):
    print(f'{name} 的体重是： {weight} 千克')


def show_height(xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形参不是name，面向过程就会有这种搞不清楚一个参数在不一样函数中是否是同一个意义的大缺点。
    print(f'{xingmin} 的身高是： {height} 厘米')


def grow_weight(name, weight, growing_weight):
    weight += growing_weight
    print(f'{name} 的体重增长 {growing_weight} 千克')
    return weight  # 必须把结果return到外部保存


def grow_height(xinmin, height, growing_height):
    print(f'{xinmin} 的身高增长 {growing_height} 厘米')
    height += growing_height
    return height  # 必须把结果return到外部保存



def pee(name, weight):
    """
    由于小便会致使体重发生变化，必须把原来的体重传进来。
    """
    print(f'{name} 站着小便')
    return _reduce_weight_because_of_pee(weight)  # 必须把结果return到外部保存


def _reduce_weight_because_of_pee(tizhong):
    tizhong = tizhong - 0.1  # 体重的别名tizhong和weight是同样的，面向过程不使用实例属性，在不少函数中大量重复传参，形参就会可能不一致，致使看不懂代码。
    return tizhong


if __name__ == '__main__':
    # 极端面向过程不只须要致使频繁传参和return，还要在调用时候设置不少个外部变量来保存状态，若是属性/状态越多，须要外部保存的变量就越多。
    xiaomin_name = '小明'
    xioamin_height = 120
    xiaomin_weight = 30
    show_height(xiaomin_name, xioamin_height)
    show_weight(xiaomin_name, xiaomin_weight)
    xioamin_height = grow_height(xiaomin_name, xioamin_height, 5)
    xiaomin_weight = grow_weight(xiaomin_name, xiaomin_weight, 1)  # 体重发生了变化，必须把结果return出来保存
    show_height(xiaomin_name, xioamin_height)
    show_weight(xiaomin_name, xiaomin_weight)  # 展现体重，须要把变化后的体重传进来
    xiaomin_weight = pee(xiaomin_name, xiaomin_weight)  # 连上个厕所都须要把体重参数传进来，这样大量传参简直不要太low
    show_weight(xiaomin_name, xiaomin_weight)

    print('& ' * 100)

    # 频繁重复传参和retutn主要是为了多实例，否则全局变量加函数就搞定了。演示面向过程实现多实例的需求，因为各类变量都是在调用地方传入和保存，因此这种面向过程的地方能够实现多实例，为了实现多实例致使重复传参和频繁return，致使代码不管在自己实现写法仍是调用上，都极为复杂。例如演示这种方式实现多实例小王

    # xiaowang_name = '小王'
    # xioamin_height = 130
    # xiaowang_weight = 35
    # show_height(xiaowang_name, xioamin_height)
    # show_weight(xiaowang_name, xiaowang_weight)
    # xioamin_height = grow_height(xiaowang_name, xioamin_height, 6)
    # xiaowang_weight = grow_weight(xiaowang_name, xiaowang_weight, 2)
    # show_height(xiaowang_name, xioamin_height)
    # show_weight(xiaowang_name, xiaowang_weight)
    # xiaowang_weight = pee(xiaowang_name, xiaowang_weight)
    # show_weight(xiaowang_name, xiaowang_weight)

    # 这样的写法，若是要实现小红，那就十分麻烦了，由于小红的pee函数确定不能这么运行。若是直接在此处修改函数,那代码就不能兼容小明 小王。致使又要全盘复制文件，庵后扣字，来重写pee函数。
View Code

实现女的函数

# -*- coding: utf-8 -*-
# @Author  : ydf

"""
复制粘贴扣字实现不一样之处
演示使用极端面向过程来写，因为没有封装，没有成员变量和全局变量，因此形成须要频繁传参和return.对于实现不一样点全盘容易陷入复制文件全流程。
女得有的函数不一样。

"""


def show_weight(name, weight):
    print(f'{name} 的体重是： {weight} 千克')


def show_height(xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形参不是name，面向过程就会有这种搞不清楚一个参数在不一样函数中是否是同一个意义的大缺点。
    print(f'{xingmin} 的身高是： {height} 厘米')


def grow_weight(name, weight, growing_weight):
    weight += growing_weight
    print(f'{name} 的体重增长 {growing_weight} 千克')
    return weight  # 必须把结果return到外部保存


def grow_height(xinmin, height, growing_height):
    print(f'{xinmin} 的身高增长 {growing_height} 厘米')
    height += growing_height
    return height  # 必须把结果return到外部保存


def pee(name, weight):
    """
    由于小便会致使体重发生变化，必须把原来的体重传进来。
    """
    print(f'{name} 蹲着小便')
    return _reduce_weight_because_of_pee(weight)  # 必须把结果return到外部保存


def _reduce_weight_because_of_pee(tizhong):
    tizhong = tizhong - 0.001  # 体重的别名tizhong和weight是同样的，面向过程不使用实例属性，在不少函数中大量重复传参，形参就会可能不一致，致使看不懂代码。
    return tizhong


if __name__ == '__main__':
    xiaohong_name = '小红'
    xiaohong_height = 110
    xiaohong_weight = 25
    show_height(xiaohong_name, xiaohong_height)
    show_weight(xiaohong_name, xiaohong_weight)
    xiaohong_height = grow_height(xiaohong_name, xiaohong_height, 5)
    xiaohong_weight = grow_weight(xiaohong_name, xiaohong_weight, 1)  # 体重发生了变化，必须把结果return出来保存
    show_height(xiaohong_name, xiaohong_height)
    show_weight(xiaohong_name, xiaohong_weight)  # 展现体重，须要把变化后的体重传进来
    xiaohong_weight = pee(xiaohong_name, xiaohong_weight)  # 连上个厕所都须要把体重参数传进来，而后还要保存新结果，这样大量传参简直不要太low
    show_weight(xiaohong_name, xiaohong_weight)
View Code

 

三、全局变量 加 函数的写法，比上面反复return传参 容易理解和写，但因为模块是单例，赞成解释器上下文中要实现多我的，须要不由自主的无限复制粘贴扣字。

xiaohong.py

# -*- coding: utf-8 -*-
# @Author  : ydf
"""
模拟无限复制粘贴扣字low模式
全局变量加函数写法，能够作到少传参 少return，看起来也很简洁，实现简单清晰。
但模块是惟一的，全局变量在模块也是惟一的，没法进行多实例方面的需求，通常都不多这样写，但有不用oop，因此会形成通常喜欢使用频繁return和大量重复传参的写法。
"""

name = '小红'
height = 100
weight = 28


def show_weight():
    print(f'{name} 的体重是： {weight} 千克')


def show_height():
    print(f'{name} 的身高是： {height} 厘米')


def grow_weight(growing_weight):
    global weight
    print(f'{name} 的体重增长 {growing_weight} 千克')
    weight += growing_weight


def grow_height(growing_height):
    global height
    print(f'{name} 的身高增长 {growing_height} 厘米')
    height += growing_height


def pee():
    """
    举个影响属性的例子，上卫生间小便,会致使体重减小。
    :return:
    """
    # REMIND 女得不一样，须要复制粘贴扣字整个流程。
    print(f'{name} 蹲着小便')
    _reduce_weight_because_of_pee()


def _reduce_weight_because_of_pee():
    global weight
    weight = weight - 0.1


if __name__ == '__main__':
    show_height()
    show_weight()
    grow_height(5)
    grow_weight(1)
    show_height()
    show_weight()
    pee()
    show_weight()
View Code

xiaoming.py

# -*- coding: utf-8 -*-
# @Author  : ydf

"""
模拟无限复制粘贴扣字low模式
全局变量加函数写法，能够作到少传参 少return，看起来也很简洁，实现简单清晰。
但模块是惟一的，全局变量在模块也是惟一的，没法进行多实例方面的需求，通常都不多这样写，但有不用oop，因此会形成通常喜欢使用频繁return和大量重复传参的写法。

"""

name = '小明'
height = 130
weight = 30


def show_weight():
    print(f'{name} 的体重是： {weight} 千克')


def show_height():
    print(f'{name} 的身高是： {height} 厘米')


def grow_weight(growing_weight):
    global weight
    print(f'{name} 的体重增长 {growing_weight} 千克')
    weight += growing_weight


def grow_height(growing_height):
    global height
    print(f'{name} 的身高增长 {growing_height} 厘米')
    height += growing_height


def pee():
    """
    举个影响属性的例子，上卫生间小便,会致使体重减小。
    :return:
    """
    print(f'{name} 站着小便')
    _reduce_weight_because_of_pee()


def _reduce_weight_because_of_pee():
    global weight
    weight = weight - 0.1


if __name__ == '__main__':
    show_height()
    show_weight()
    grow_height(5)
    grow_weight(1)
    show_height()
    show_weight()
    pee()
    show_weight()

    # REMIND 因为是使用的全局变量，只能完成一个单例的状况，只能完成小明这一我的，没法同时完成小明和小王，若是须要使用小王，必须复制粘贴扣字。
View Code

xiaowang.py

# -*- coding: utf-8 -*-
# @Author  : ydf
"""
模拟无限复制粘贴扣字low模式
全局变量加函数写法，能够作到少传参 少return，看起来也很简洁，实现简单清晰。
但模块是惟一的，全局变量在模块也是惟一的，没法进行多实例方面的需求，通常都不多这样写，但有不用oop，因此会形成通常喜欢使用频繁return和大量重复传参的写法。

"""

name = '小王'
height = 140
weight = 32


def show_weight():
    print(f'{name} 的体重是： {weight} 千克')


def show_height():
    print(f'{name} 的身高是： {height} 厘米')


def grow_weight(growing_weight):
    global weight
    print(f'{name} 的体重增长 {growing_weight} 千克')
    weight += growing_weight


def grow_height(growing_height):
    global height
    print(f'{name} 的身高增长 {growing_height} 厘米')
    height += growing_height


def pee():
    """
    举个影响属性的例子，上卫生间小便,会致使体重减小。
    :return:
    """
    print(f'{name} 站着小便')
    _reduce_weight_because_of_pee()


def _reduce_weight_because_of_pee():
    global weight
    weight = weight - 0.1


if __name__ == '__main__':
    show_height()
    show_weight()
    grow_height(5)
    grow_weight(1)
    show_height()
    show_weight()
    pee()
    show_weight()

    # REMIND 因为是使用的全局变量，只能完成一个单例的状况，只能完成小明这一我的，没法同时完成小明和小王，若是须要使用小王，必须复制粘贴扣字。
View Code

 

四、无效废物装逼类。 有些人发现第三方包的大神那么流弊，里面那么多类，以为类确定狠流弊，没有理解到封装这一最基本要义的内涵，致使写出来的类是废物滑稽类，没做用。

这三个类如此轻易的使用静态方法类方法 实例方法自由转化代码能正常运行，这种九成九是废物类。仍然使用反复return 频繁传参的方式来实现，没有封装的特色，因此是废物类。不能心太急着写类，致使写出这样的滑稽类，或者即便没例子里面的这么极端，但也存在oo不完全的状况。再次印证了，我从没说写类就流弊了，是要写有用的类才能够。

# -*- coding: utf-8 -*-
# @Author  : ydf
"""
面向过程写得无效废物类，没有封装，大量rentun，这样写的类没有任何做用。
和person_f文件的写法是同样的。
"""


class Person:
    def show_weight(self, name, weight):
        print(f'{name} 的体重是： {weight} 千克')

    def show_height(self, xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形参不是name，面向过程就会有这种搞不清楚一个参数在不一样函数中是否是同一个意义的大缺点。
        print(f'{xingmin} 的身高是： {height} 厘米')

    def grow_weight(self, name, weight, growing_weight):
        weight += growing_weight
        print(f'{name} 的体重增长 {growing_weight} 千克')
        return weight  # 必须把结果return到外部保存

    def grow_height(self, xinmin, height, growing_height):
        print(f'{xinmin} 的身高增长 {growing_height} 厘米')
        height += growing_height
        return height  # 必须把结果return到外部保存

    def pee(self, name, weight):
        """
        由于小便会致使体重发生变化，必须把原来的体重传进来。
        """
        print(f'{name} 蹲着小便')
        return self._reduce_weight_because_of_pee(weight)  # 必须把结果return到外部保存

    def _reduce_weight_because_of_pee(self, tizhong):
        tizhong = tizhong - 0.1  # 体重的别名tizhong和weight是同样的，面向过程不使用实例属性，在不少函数中大量重复传参，形参就会可能不一致，致使看不懂代码。
        return tizhong


class Person2:
    @classmethod
    def show_weight(cls, name, weight):
        print(f'{name} 的体重是： {weight} 千克')

    @classmethod
    def show_height(cls, xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形参不是name，面向过程就会有这种搞不清楚一个参数在不一样函数中是否是同一个意义的大缺点。
        print(f'{xingmin} 的身高是： {height} 厘米')

    @classmethod
    def grow_weight(cls, name, weight, growing_weight):
        weight += growing_weight
        print(f'{name} 的体重增长 {growing_weight} 千克')
        return weight  # 必须把结果return到外部保存

    @classmethod
    def grow_height(cls, xinmin, height, growing_height):
        print(f'{xinmin} 的身高增长 {growing_height} 厘米')
        height += growing_height
        return height  # 必须把结果return到外部保存

    @classmethod
    def pee(cls, name, weight):
        """
        由于小便会致使体重发生变化，必须把原来的体重传进来。
        """
        print(f'{name} 蹲着小便')
        return cls._reduce_weight_because_of_pee(weight)  # 必须把结果return到外部保存

    @classmethod
    def _reduce_weight_because_of_pee(cls, tizhong):
        tizhong = tizhong - 0.1  # 体重的别名tizhong和weight是同样的，面向过程不使用实例属性，在不少函数中大量重复传参，形参就会可能不一致，致使看不懂代码。
        return tizhong


class Person3:
    @staticmethod
    def show_weight(name, weight):
        print(f'{name} 的体重是： {weight} 千克')

    @staticmethod
    def show_height(xingmin, height):  # xingmin: xingmin也是表明姓名，故意弄成形参不是name，面向过程就会有这种搞不清楚一个参数在不一样函数中是否是同一个意义的大缺点。
        print(f'{xingmin} 的身高是： {height} 厘米')

    @staticmethod
    def grow_weight(name, weight, growing_weight):
        weight += growing_weight
        print(f'{name} 的体重增长 {growing_weight} 千克')
        return weight  # 必须把结果return到外部保存

    @staticmethod
    def grow_height(xinmin, height, growing_height):
        print(f'{xinmin} 的身高增长 {growing_height} 厘米')
        height += growing_height
        return height  # 必须把结果return到外部保存

    @staticmethod
    def pee(name, weight):
        """
        由于小便会致使体重发生变化，必须把原来的体重传进来。
        """
        print(f'{name} 蹲着小便')
        return Person3._reduce_weight_because_of_pee(weight)  # 必须把结果return到外部保存

    @staticmethod
    def _reduce_weight_because_of_pee(tizhong):
        tizhong = tizhong - 0.1  # 体重的别名tizhong和weight是同样的，面向过程不使用实例属性，在不少函数中大量重复传参，形参就会可能不一致，致使看不懂代码。
        return tizhong


if __name__ == '__main__':
    """
    person1是无效废物类，由于他改为  person2 person3，下面的调用还能正常运行，因此是个废物类。
    """
    xiaohong = Person3()
    xiaohong_name = '小红'
    xiaohong_height = 110
    xiaohong_weight = 25
    xiaohong.show_height(xiaohong_name, xiaohong_height)
    xiaohong.show_weight(xiaohong_name, xiaohong_weight)
    xiaohong_height = xiaohong.grow_height(xiaohong_name, xiaohong_height, 5)
    xiaohong_weight = xiaohong.grow_weight(xiaohong_name, xiaohong_weight, 1)  # 体重发生了变化，必须把结果return出来保存
    xiaohong.show_height(xiaohong_name, xiaohong_height)
    xiaohong.show_weight(xiaohong_name, xiaohong_weight)  # 展现体重，须要把变化后的体重传进来
    xiaohong_weight = xiaohong.pee(xiaohong_name, xiaohong_weight)  # 连上个厕所都须要把体重参数传进来，而后还要保存新结果，这样大量传参简直不要太low
    xiaohong.show_weight(xiaohong_name, xiaohong_weight)
View Code

 

 

五、具体4种写法分别表明什么范式的编程，能够见注释。而后根据对例子来掌握万能oop转化公式。

 

六、因为咱们是多平台开发，公司里每一个项目都是多个业务平台，每一个项目至少是5个到30个平台左右，因此真实例子远比例子里面那几个实现小红小王小明的代码类似重复程度吓人数十倍，代码太长了就不贴这里了。主要是不掌握oop 和不了解设计模式形成的。这也是我写代码常常减小百分之八九十行的主要缘由。

 

七、真实编程时候，不精通oop和面向过程区别，几乎很难抽象一个类，由于我这里举例的是一我的，真正写代码时候不可能那么巧恰好业务中须要抽象出一个动物，而后想着围绕这个动物类型写他的属性和方法。因此必定要学习oop转化公式，和知道oop和面向过程编程的本质区别，这样在 写代码时候才会不纠结怎么抽象，和写类仍是写函数，不会不由自主的复制粘贴扣字，不会写新代码开不了头，能够下笔如流水。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程