如何理解面向对象？

17bang.ren，一起提供帮助，快速解决您无法解决的问题

44个人同意答案

首先，我不建议新手“深入”理解面向对象. 所谓的“深层”可能是基于“设计模式”. 通常，只有不到两年工作经验的“新人”学习“设计模式”才是中途（这很好），或者是在报废自己（发疯）.

近年来，谈论“设计模式”的人越来越少了，头两天我看到一个问题: 面向对象（OOP）是否在编程语言的开发中绕道而行？为什么？

这有点无情，呵呵. 不能谈论“弯曲”，只能说现在“面向对象”已经从祭坛上撤下来某些过程化程序设计语言也可实现面向对象系统，恢复了正常状态: 它不再是对“一切都是对象”的狂热，但是应该在适合面向对象的地方实现面向对象.

我不知道是否每个人都同意: 设计模式本质上是针对传统的面向对象“缺点”的解决方案？这会更深入一些，新手只需看看.

说实话，新程序员应该如何理解“面向对象”？

首先，面向对象仍然是处理复杂业务逻辑的最主流和最有效的方法. 不要过度使用它，请听一些人吹嘘“面向对象已死”之类的东西. 这么多以前不支持面向对象的语言（例如PHP / JavaScript）都试图依靠对象，这就是证明. 当然，要学习面向对象，最好使用对本地对象（例如C#和Java）的纯本机支持. 强烈建议不要通过JavaScript学习面向对象，因为它太破烂，太拧紧，太难过...

第二，每个人都应该了解“面向对象”或其使用的场景要解决的问题. 面向对象不适合您在学习各种语言语法（例如“气泡排序”，“书/课程管理系统”等）时编写的那些Demo程序，甚至不适合大多数小型开发项目（例如普通企业网站，个人博客）不适合. 面向对象适用于具有复杂业务逻辑（更实际，更“复杂”）的大型项目. 所谓繁琐，多指，混乱，混乱的项目，可以表示为: 功能上的许多变化，所以代码量大，开发人员数量大，开发/维护时间长……

接下来我将继续谈论这一点，但是每个人都必须首先具有这种意识. 否则，您总是使用“面向对象”来覆盖您的几个小项目，那么抽象和封装的方式肯定会更加令人头晕. 在小型项目中，“面向对象”是没有用的，这并不能反映“面向对象”的好处-这就是为什么我说“不建议新手”在此阶段深入理解“面向对象”的原因您接触到的项目是有限的，并且对代码复杂性的理解也受到限制. 很难实现“面向对象”的作用.

最后，我概述了从浅层到深层的对面向对象的理解的几个层次.

1. 学习面向对象的语法. 类声明和继承，接口和抽象类，方法和属性，访问修饰符...这没什么好说的，它非常简单，应该掌握.

2. 我想了解为什么出现“班级”. 我建议如何以一种易于理解的方式来说明“面向对象”和“面向过程”之间的区别？这里匿名用户的高度赞扬的回答只是说功能太多，需要在“类”中进行管理. 这就足够了，然后在实际的开发工作中，尝试对类别进行分类，清晰和有组织.

3. 了解“对象”是方法（功能）和数据的组合. 因为如果仅了解点2，则所有类实际上都是静态类，而所有方法都是静态方法. 但是该类的主要特征之一是它包含数据本身，并且不同的数据可以创建不同的实例（对象）. 您会看到，直到现在，我们可以说是面向对象的，而不是面向类的.

4. 启动“继承”. 请注意，从这里可能会有陷阱. 继承实际上带来两个结果: 重用和多态. 重用非常容易理解. 子类可以使用父类的所有非私有属性和方法，因此许多学生在使用继承后立即开始“重用”. 例如，狗有四条腿，而猫有四条腿. 然后抽象一个有四只脚的父母: 动物……但是问题是: 桌子上也有四只脚. 由于事物之间复杂的共性/特征关系，很容易对多重继承进行分类，例如，您开始以这种方式构想:

一切都很好，但是接下来的“鸭子”呢？您认为它应该是鸟，但是请注意，它也可以游泳（代码中需要此功能）. 同样，有一只公鸡也可以生产肉，该怎么办？还有漂亮的鹅口疮，仅供观赏. 随着越来越多的动物，这个系统崩溃了……

因此，这里实际上是批评“面向对象”的第一个点或层次. 但是，您永远不应该轻易放弃，因为技术存在这样的问题. 随着学习的深入，您将有更深入的了解.

5. 与组成一起重用，具有继承的多态性. 这实际上是对第4条的“修正”（注意: 不是“颠覆”）. 我个人认为这实际上是“设计模式”的基础或核心. 对于初学者来说，这里的理解几乎是相同的. 谈论起来非常非常困难. 费格坦言，这几乎已经上升到“艺术”的范畴，我对这种理解的理解也许是可以理解的，但是应用仍然很紧张，不是很滑. 就像您知道很多公式一样，您无法解决数学问题.

问题出在哪里？我称其为“保持复杂性”. 有些学生可能听说过“面向对象的设计可以降低复杂性”……但实际上并非如此. 除非更改需求，否则永远无法降低业务逻辑的复杂性. 需求就是这样，那么复杂性在哪里，如何降低它们呢？无论是面向对象还是设计模式，与非面向对象的程序设计（例如结构化程序设计）相比，其实质是将复杂度转换为类的关系复杂度.

我觉得我讲得更深了吗？让我们再停一点. 也许有些学生知道工厂模式并且可以摆脱丑陋的开关...情况...，但是开关...情况的逻辑真的消失了吗？没有！同学，只有通过类继承和多态性才能实现. 您认为，如果... else ...嵌套非常复杂，但是无数类的关系同样复杂！

我这样说，如果您是新人，您甚至可能没有意识到. 也许……否则……仍然不了解嵌套的复杂性，更不用说其他了. 所以到此为止. 我认为新手可以精通第三级，了解第四级，并触摸第五级的边缘，这非常好.

一些学生可能会读4和5并认为: “面向对象”确实毫无价值！即使达到了第五级，也仅仅是复杂性的“转移”. 由于if ... else ...的嵌套与子类的父级一样复杂，为什么我应该选择子类的父级的复杂性？

好问题！

出于两个原因，我可以为您提供最简单的答案:

1. “人脑”的局限性. 面对复杂的事物，处理人脑的自然方法是“抽象”和“屏蔽细节”.

假设您现在是一名元帅，要指挥一场战斗，您如何指挥？这仅仅是一个简单的命令: 第14军必须在第15军之前占领第23高原吗？至于第十四军如何占领这个高地，如何部署部队，如何部署火力，需要什么样的后勤资源……一堆细节，您只能忽略它们吗？

2. 从“将代码写入计算机”到“可以看到代码”的过渡.

在计算机开发的早期，该程序非常简单，并且计算机无法理解高级和复杂的信息-实际上，这是一条“类似于自然语言的”指令. 许多程序员的工作是“翻译”计算机要理解的要求. 并执行低级指令，例如Stone Age二进制打孔，汇编和C语言等，该图像是“的”来教计算机如何操作某些过程化程序设计语言也可实现面向对象系统，具体可以“分配32个”字节”并将其存储在CPU“寄存器”中.

这种方法原始且效率低下，根本无法满足软件开发不断增长的需求. 最有效的对接解决方案之一是将翻译（编译）工作交给计算机来完成，从而为程序员腾出了时间和精力来解决业务逻辑需求. 因此，编程语言变得越来越``先进''，越来越类似于人类自然语言.

实际上，如果... else ...结构化编程非常接近人类语言，但还不够. 结果，“面向对象”应运而生. 语言是思维的载体: 结构化语言仍然对应于具体的，逐步的执行思维；面向对象对应于抽象的，面向目标的思维，而不管细节如何！

以战斗命令为例，面对这一过程，可能是:

32名士兵轰炸了当地阵地5分钟. 16名士兵与2辆坦克合作，向前进的1架直升机充电，以提供空中支援...

面向对象是:

第二家公司担任当地职位.

如何占领？第二家公司将自己实现！

如此之多的初学者可能不接受它，他的心在摇摆. 他总是想着: 第二公司如何担任这个职位？最重要的是，他仍然必须最后编写此过程，因此他本能地抵制或感到困惑: 面向对象的封装，抽象等，脱裤子和放屁，这是一件多余的事情！ O（∩_∩）O〜

我很偶然地写了很多东西. 但是效果如何呢，我的心却挂了. 因此，回到我之前所说的那样，我仍然不建议初学者深入研究“面向对象”. 后来，凭借在大型项目中的工作经验，团队合作和合作，很自然地就会明白，“面向对象”是强制性的，而不是设计出来的！这实际上非常重要.

收藏夹中的内容: 狂野的程序员，欢迎关注.

+++++++++++++++++

欢迎访问并关注，o（* ￣︶￣ *）o如果您是农民或对编程了解感兴趣，则可以添加组: 729600626，每个人都可以学习和交流O（∩_∩）O哈哈~~

发布于2019-11-01

多语种编程爱好者，一切都会有些

74个人同意答案

暂时不了解并不重要. 面向对象是一种编程思想. 了解这些内容后，您将在编程学习上迈出非常重要的一步.

了解面向对象，首先要了解所需的基本概念:

面向对象（Object Oriented）是建立实际问题之间的关系，然后抽象为一个类（类），为该类定义属性和方法，然后通过访问将该类实例化为实例（实例）实例的属性和要使用的调用方法.

在不同的语言中，对象定义的范围是不同的. 在Python中，“类”和“类的实例”称为对象（Object），因为Python类是更高级的类型实例化的对象，通常被称为“ Python中的所有事物都是对象”. 在Java等静态语言中，类的实例通常称为对象.

了解理论知识后，通过示例，然后了解面向对象的三个主要特征: 封装，继承，多态性.

下面，我们将使用Python的面向对象代码来描述“努瓦人造人”的神话故事:

假设我们是Nuwa（程序设计师），我们突然有一个想法来创建一组与我们相似的恶棍. 恶棍需要具有性别，并且在外观和行为上也存在一些差异. 首先，我们分析了，无论性别，都应该有四肢，所以我们首先模仿自己的结构，在脑海中构思出粘土雕像的外观（抽象为基类），然后再给粘土雕像一些常见行为（定义类实例方法）:

class Human(object):
    def __init__(self, name):
        # 有个名字，有两只手，两条腿
        self._name = name
        self.hands = 2
        self.legs = 2
    def introduce_self(self):
        # 介绍自己
        print(我是%s % self._name)
    def work(self):
        # 工作，但还没有定义具体的行为
        raise NotImplementedError

然后，我们先捏三个粘土小雕像（实例化的对象），然后给它们指定不同的名称（初始化实例属性）:

>>> a = Human(大强子)
>>> b = Human(二狗子)
>>> c = Human(三愣子)

我们让其中一个介绍自己（调用实例方法）:

>>> a.introduce_self()
我是大强子

在此处解释人员代码. 尽管每个人都必须工作，但是如何工作需要针对不同类型的人，因此在基类中，我们没有定义工作方法的内容. 引发异常.

另外一点，当在上面定义属性时，我们在self._name的前面加了下划线，因为Python使用下划线规定这是一个受保护的变量（对应于Java中的protected变量），我们不希望外界直接要访问name属性，您必须通过一个名为Introduction_self（）的对象进行自我介绍. 他人可以知道此行为. 此过程称为封装.

然后，我们继续完善这个想法，我们需要在粘土俑中添加两个性别，然后才能在异性之间结婚. 我们开始基于黏土小雕像模型（继承自基类）来设想两种性别之间的差异. 设置不同的属性），然后让它们全部起作用，但是工作的内容不同（调用相同的方法会产生不同的结果，即多态），并决定男人可以嫁给女人（将此行为定义为男人的方法）

import random
class Female(Human):
    def __init__(self, name):
        # 调用父类的初始化方法，依然有名字、两只手、两条腿
        super().__init__(name)
        # 头发和力量进行随机取值
        self.hair = random.randint(3, 5)
        self.power = random.randint(1, 3)
        # 是否已婚
        self.married = False
    def work():
        print(%s采摘了一些 % self.name)
class Male(Human):
    def __init__(self, name):
        super().__init__(name)
        self.hair = random.randint(0, 2)
        self.power = random.randint(2, 5)
        self.married = False
    def work():
        print(%s出去打猎了一天 % self.name)
    def marry(self, other):
        # 判断自己或对方是否已结婚，否则抛出异常
        if self.married is True or other.married is True:
            raise ValueError(法律不支持多次结婚)
        # 判断对方是否是女性，否则抛出异常
        if isinstance(other, Female):
            self.married = True
            other.married = True
        else:
            raise TypeError(法律不支持同性结婚)

然后我们可以使反派活跃:

>>> a = Male(大强子)
>>> b = Male(二狗子)
>>> c = Female(翠花)
>>> for h in [a, b, c]:
...     # 调用父类的方法
...     h.introduce_self()
我是大强子
我是二狗子
我是翠花
>>> for h in [a, b, c]:
...     # 多态性使相同的方法产生不同的结果
...     h.work()
大强子出去打猎了一天
二狗子出去打猎了一天
翠花采摘了一些
>>> a.marry(c)
>>> a.married
True
>>> c.married
True
>>> b.marry(c)
ValueError: 法律不支持多次结婚
>>> b.marry(a)
TypeError: 法律不支持同性结婚

这是设计的结尾. 让我们回顾一下整个过程.

我们首先将人类的共同特征抽象为人类基类. 此基类不用于实例化，而是用于让Female和Male继承它并实现不同的行为. 这样，我们避免重复在多个类中定义的一些常见行为. 如果我们想在将来改变人类的行为，我们只需要修改人类. 继承Human的子类将自动获得新的行为. 这是由继承带来的. 的好处.

我们将名称设计为受保护的变量，外界无法直接访问此属性，因此可以保证每个人的隐私（某些不必要的行为可以控制），这是封装的好处.

同时，我们保留了“人”的工作方法，并在女性和男性中取得了不同的效果. 然后我们知道每个人都有一个工作方法，因此我们可以像loop_introduce_self这样批量调用该工作方法. 多态性的好处.

您应该在这里了解一些知识: 面向对象是将客观的事物和某些关系抽象为具体的模型（类），并为它们设计属性和方法，即object =属性（功能）+方法（行为）.

如果有复杂关系的需求，我们应该尝试将相关行为抽象为类别，例如每个网页，网页中的每个组件等. 实际上，面向对象可以帮助我们进行大型项目正因为如此，成千上万行代码仍然可以放心使用，以便发展成为使用最广泛的编程思想.

但这并不意味着您必须始终“面向对象”. 过多的封装和抽象还将降低代码的可读性和操作效率. 因此，我们应该需要抽象事物. 面向对象.

最后，无论是面向哪种编程，毕竟仍然必须面向生活

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-200183-1.html