Like many ideas that sound good in theory but are clumsy in practice, object-oriented
programming (OOP) offers benefits only in a specialized context—namely, group programming.
And even in that circumstance the benefits are dubious, though the proponents of OOP would
have you believe otherwise. Some shops claim OOP success, but many I've spoken with are still
"working on it." Still trying to get OOP right after ten years? Something strange is going on here.
Certainly for the great majority of programmers—amateurs working alone to create
programs such as a quick sales tax utility for a small business or a geography quiz for
Junior—the machinery of OOP is almost always far more trouble than it's worth. OOP just
introduces an unnecessary layer of complexity to procedure-oriented design. That's why very few
programming books I've read use OOP techniques (classes, etc.) in their code examples. The
examples are written as functions, not as methods within objects. Programming books are trying
to teach programming—not the primarily clerical and taxonomic essence of OOP. Those few
books that do superimpose the OOP mechanisms on their code are, not surprisingly, teaching
about the mysteries of OOP itself.
Of course professional gang programming has specialized requirements. Chief among them
is that the programmers don't step on each other's toes. For instance, a friend who programs for
one of the world's largest software companies told me he knows precisely what he'll be working
on in one year. Obviously, OOP makes sense in such a bureaucratic system because it needs to be
intensely clerical. Helping to manage large-scale, complex-programming jobs like the one in
which my friend is involved is the primary value of OOP. It's a clerical system with some built-in
security features. In my view, confusing OOP with programming is a mistake.
Contradiction Leads to Confusion
Consider the profound contradiction between the OOP practices of encapsulation and
inheritance. To keep your code bug-free, encapsulation hides procedures (and sometimes even
data) from other programmers and doesn't allow them to edit it. Inheritance then asks these same
programmers to inherit, modify, and reuse this code that they cannot see—they see what goes in
and what comes out, but they must remain ignorant of what's going on inside. In effect, a
programmer with no knowledge of the specific inner workings of your encapsulated class is
asked to reuse it and modify its members. True, OOP includes features to help deal with this
problem, but why does OOP generate problems it must then deal with later?
All this leads to the familiar granularity paradox in OOP: should you create only extremely
small and simple classes for stability (some computer science professors say yes), or should you
make them large and abstract for flexibility (other professors say yes). Which is it?
A frequent argument for OOP is it helps with code reusability, but one can reuse code
without OOP—often by simply copying and pasting. There's no need to superimpose some
elaborate structure of interacting, instantiated objects, with all the messaging and fragility that itintroduces into a program. Further, most programming is done by individuals. Hiding code from
oneself just seems weird. Obviously, some kind of structure must be imposed on people
programming together in groups, but is OOP—with all its baggage and inefficiency—the right solution?

結果 (中文) 1:

的许多想法一样的声音在理论上不错，但在实践中是笨拙的，面向对象的
编程（OOP）提供的好处，只有在一个专门的上下文 - 组英镑AMELY，编程。
，即使在这种情况好处是半信半疑，虽然支持者接力
你相信，否则。一些店铺声称接力成功，但许多我讲的仍然是
“的工作就可以了。”仍然试图获得接力经过十多年？一些奇怪的事情是怎么回事，对于大多数程序员单独工作的业余爱好者创建
方案，如快速销售税实用为小型企业或地理测验

肯定初中接力机械几乎总是远远更多的麻烦比它的价值。 OOP只是
面向过程的设计中引入了不必要的复杂层。这就是为什么极少数
编程的书我读过他们的代码示例使用OOP技术（类等）。
的例子被写入功能，而不是对象的方法内。编程书籍试图
教编程主要是文书和分类精髓接力。那几个
书籍叠加接力机制，对他们的代码，这并不奇怪，空中接力本身的奥秘教学

当然，专业团伙编程有特殊的要求。其中最主要的
程序员不踩对方的脚趾。例如，一个朋友，谁节目
世界上最大的软件公司之一告诉我，他确切地知道什么，他将工作
在一年内。显然，OOP是有道理的，因为它需要在这样一个官僚体系
强烈文书。像一个
，我的朋友参与帮助管理大型，复杂的编程工作是OOP的主要价值。它是一个系统的一些内置的文书
安全功能。在我看来，混淆编程接力是一个错误。
矛盾导致混乱

继承封装和之间的空中接力的做法考虑的深刻矛盾。让你的代码错误，封装隐藏程序（有时甚至
数据）不允许从其他程序员和他们编辑它。继承，然后要求这些相同
程序员继承，修改，重用他们无法看到这个代码，他们看到什么
和什么出来，但里面发生了什么事情，他们必须保持无知。没有知识封装类的内部运作的具体效果，
程序员
问重用它，修改它的成员。真实，接力包括功能，以帮助处理这个问题
但为什么接力生成问题，就必须再处理以后呢？
这一切导致熟悉的粒度接力悖论：你应该创建只有极
小而简单的类稳定（一些计算机科学教授说是），或者你应该
使他们大和抽象的灵活性（其他教授说是）。这是什么？
OOP一个常见的​​争论是它有助于代码的可重用性，但没有一个可以重用代码
接力往往通过简单的复制和粘贴。有没有必要叠加的相互作用的一些
精心结构，实例化的对象，所有的消息和脆弱到程序itintroduces的。进一步，大多数编程是通过个人。隐藏代码
自己只是似乎不可思议。显然，某种形式的结构必须被征收人
编程组一起，但接力其所有行李和低效正确的解决方案吗？

結果 (中文) 2:

        
  

      
     
        
  
像许多想法在理论上听起来不错但笨拙的实践中，面向对象编程（OOP）
提供的好处，只有在特定的语境即，集团规划。
甚至在这种情况下，好处是可疑的，尽管OOP的支持者会
你相信。有些商店要求OOP的成功，但是我已经和仍然
”的工作。“仍在十年后得到面向对象？一些奇怪的事。
当然大多数程序员业余工作独自创造
程序如为小型企业或地理测验快速销售税的实用
初中OOP的机械几乎总是远比它的价值更麻烦。OOP只是
介绍了面向过程设计的复杂性的一种不必要的层。这就是为什么很少
编程的书我读了利用面向对象技术（类，等）在他们的代码示例。该
例子写的函数，没有在对象的方法。编程的书正在
教编程不是主要文书和面向对象分类的本质。这几
本书将面向对象机制做他们的代码，毫不奇怪，对面向对象本身的奥秘的教学
。
当然职业团伙编程有专门要求。其中最主要的
是程序员不踩着别人的脚。例如，一个朋友计划
一个世界上最大的软件公司告诉我，他知道他将在一年
。显然，OOP的感觉这样的官僚系统因为它需要
强烈的文书。帮助管理大型，复杂的编程工作就像一个在
我朋友是OOP的首要价值。这是一个带有内置
办公系统安全特性。在我看来，混乱的面向对象编程是一个错误。
矛盾导致混乱
考虑之间的深刻矛盾的OOP的封装和
继承。保持您的代码错误的自由，封闭隐藏程序（有时甚至是
数据）从其他程序员不允许他们编辑。继承然后问这些
程序员继承，修改和重用这些代码，他们看不到他们看到的是
什么出来，但他们必须保持无知里发生了什么。实际上，不知道你的封装类的特定的内部运作一个
程序员
要求重用和修改它的成员。真的，面向对象的功能包括帮助解决这一问题
，但为什么面向对象的产生必须再处理问题？
所有这一切导致了熟悉的粒度的悖论：你要建立的OOP只有极
稳定小而简单的类（计算机科学教授说吧），你还是应该
使他们的灵活性大、摘要（其他教授说的是的）。这是什么呢？
一种面向对象的频繁的说法是它有助于代码的可重用性，但可以重用代码
没有OOP往往通过简单地复制和粘贴。没有必要把一些
精细结构的相互作用，实例化的对象，以提供到一个程序的所有消息和脆弱性。此外，大多数的编程是通过个人。隐藏代码从
自己似乎只是奇怪。显然，某种结构必须对人
编程在一起实行，但OOP和它所有的行李和效率低下的正确的解决方案？

結果 (中文) 3:








喜欢听起来很好的理论，但在实践中笨拙的很多想法，面向对象
编程 (OOP) 提供了只有在专业方面的好处 — — 即组编程。
和即使在这种情况下的好处是令人怀疑，虽然 OOP 的拥护者会
让你相信不然。一些商店索赔 OOP 的成功，但许多人跟我谈过仍然是
「 工作它。仍想要 OOP 右后十年?奇怪的事情发生在这里。
当然，绝大多数的程序员 — — 业余爱好者独自努力创建
程序如快速开徵销售税实用程序，用于小型企业或地理常识问答比赛为
初中 — — OOP 的机械是几乎总是比它更多的麻烦是值得。OOP 只
引入了一个不必要的复杂性到面向过程的设计层。这就是为什么很少
编程我读过的书在他们的代码示例中使用面向对象技术 （类等）。
例子被写为函数，不是作为内的对象的方法。编程书籍正在
教编程 — — 不的 OOP 的主要文书和分类学本质。那些几个
做叠加的 OOP 机制在他们的代码上的书，不令人惊讶的是，教学
关于 OOP 本身的奥秘.
当然编程专业帮派有专门的要求。其中主要
是程序员不要踩在对方的脚趾。例如，一位为程序的朋友
世界上最大的软件公司之一，告诉我他知道正是什么他会工作
在上一年。很明显，OOP 意义在这种官僚制度，因为它需要
激烈文书。帮助管理大型、 复杂编程作业像一个在
，我的朋友是涉及是 OOP 的主要价值。它是具有一些内置的文书系统
安全功能。在我看来，混淆 OOP 编程是一个错误。
矛盾导致混乱
考虑封装的 OOP 做法之间的深刻矛盾和
继承。为了保持您的代码无 bug，封装将隐藏的程序 (有时甚至
数据） 从其他程序员并不允许他们来编辑它。继承然后问这些相同
程序员要继承，修改和重新使用此代码，他们看不到 — — 他们看到发生的事情
和出来的但他们必须保持无知的怎么在里面。实际上，
程序员没有您的封装类的特定内部工作原理的知识是
问重用它并修改它的成员。为 true，OOP 包括功能，可帮助处理这
的问题，OOP 为什么不生成它然后必须稍后处理的问题，但?
所有这一切导致了 OOP 的熟悉粒度悖论： 极端只应创建
小和简单类的稳定性 （一些计算机科学教授说是），或应您
使他们大和抽象的灵活性 （其他教授说是）。到底是不是?
OOP 一个频繁的论点是它有助于代码的可重用性，但其中一个可重用的代码
没有 OOP — — 往往通过简单地复制和粘贴。有没有需要叠加一些
拟订结构的相互作用、 实例化的对象，其中的所有消息和脆弱，那 itintroduces 到程序中。此外，最编程是通过个人。隐藏代码从
自己只是看起来很奇怪。很明显，必须对人民实行某种结构
一起编程在群体中，但是是 OOP — — 与所有的行李和低效率 — — 正确的解决方案吗？