姓名:汪尧 学号：1402120715原文：Object landsc

姓名:汪尧 学号：1402120715
原文：
Object landscapes and lifetimes
Technically, OOP[1] is just about abstract data typing, inheritance, and polymorphism, but other issues can be at least as important. The remainder of this section will cover these issues.
One of the most important factors is the way objects are created and destroyed. Where is the data for an object and how is the lifetime of the object controlled? There are different philosophies at work here. C++ takes the approach that control of efficiency is the most important issue, so it gives the programmer a choice. For[2] maximum run-time speed, the storage and lifetime can be determined while the program is being written, by placing[2] the objects on the stack (these are sometimes called automatic or scoped variables) or in the static storage area. This places a priority on the speed of storage allocation and release, and control of these can be very valuable in some situations. However, you sacrifice flexibility because you must know the exact quantity, lifetime, and type of objects while[3] you're writing the program. If you are trying to solve a more general problem such as[4] computer-aided design, warehouse management, or air-traffic control, this is too restrictive.
The second approach is to create objects dynamically in a pool of memory called the heap. In this approach, you don't know how many objects you need, what their lifetime is, or what their exact type is until[3] the program is running. Those are determined at the spur of the moment while the program is running. If you need a new object, you simply make it on the heap at the point that you need it. Because the storage is managed dynamically, at run-time, the amount of time required[5] to allocate storage on the heap is significantly longer than the time to create storage on the stack. (Creating storage on the stack[6] is often a single assembly instruction to move the stack pointer down, and another to move it back up.) The dynamic approach makes the generally logical assumption that objects tend to be complicated, so the extra overhead of finding storage and releasing that storage will not have an important impact on the creation of an object. In addition, the greater flexibility is essential to solve the general programming problem.
Java uses the second approach, exclusively[7]. Every time you want to create an object, you use the new keyword to build a dynamic instance of that object.
There's another issue, however[8], and that's the lifetime of an object. With[9] languages that allow objects to be created on the stack, the compiler determines how long the object lasts and can automatically destroy it. However, if you create it on the heap the compiler has no knowledge of its lifetime. In a language like C++, you must determine programmatically when to destroy the object, which[10] can lead to memory leaks if you don’t do it correctly (and this is a common problem in C++ programs). Java provides a feature called[5] a garbage collector that automatically discovers when an object is no longer in use and destroys it. A[1] garbage collector is much more convenient because it reduces the number of issues that you must track and the code to be written[12]. More important, the garbage collector provides a much higher level of insurance against the insidious problem of memory leaks (which has brought many a C++ project to its knees).
The rest of this section looks at additional factors concerning object lifetimes and landscapes.
1 Collections and iterators
If you don’t know how many objects you’re going to need to solve a particular problem, or how long they will last, you also don’t know how to store those objects. How can you know how much space to create for those objects? You can’t, since that information isn’t known until run-time.
The solution to most problems in object-oriented design seems flippant: you create another type of object. The new type of object that solves this particular problem holds references to other objects. Of course, you can do the same thing with an array, which is available in most languages. But there’s more. This new object, generally called a container (also called a collection, but the Java library uses that term in a different sense so this book will use “container”), will expand itself whenever necessary to accommodate everything you place inside it. So you don’t need to know how manyobjects you’re going to hold in a container. Just create a container object and let it take care of the details.
Fortunately, a good OOP language comes with a set of containers as part of the package. In C++, it’s part of the Standard C++ Library and is sometimes called the Standard Template Library (STL). Object Pascal has containers in its Visual Component Library (VCL). Smalltalk has a very complete set of containers. Java also has containers in its standard library. In some libraries, a generic container is considered good enough for all needs, and in others (Java, for example) the library has different types of containers for different needs: a vector (called an ArrayList in Java) for consistent access to all elements, and a linked list for consistent insertion at all elements, for example, so you can choose the particular type that fits your needs. Container libraries may also include sets, queues, hash tables, trees, stacks, etc.
All containers have some way to put things in and get things out; there are usually functions to add elements to a container, and others to fetch those elements back out. But fetching elements can be more problematic, because a single-selection function is restrictive. What if you want to manipulate or compare a set of elements in the container instead of just one?
The solution is an iterator, which[10] is an object whose job is to select the elements within a container and present them to the user of the iterator. As a class, it also provides a level of abstraction. This abstraction can be used to separate the details of the container from the code that’s accessing that container. The container, via the iterator, is abstracted to be simply a sequence. The iterator allows you to traverse that sequence without worrying about the underlying structure—that is, whether it’s an ArrayList, a LinkedList, a Stack, or something else. This gives you the flexibility to easily change the underlying data structure without disturbing the code in your program. Java began (in version 1.0 and 1.1) with a standard iterator, called Enumeration, for all of its container classes. Java 2 has added a much more complete container library that contains an iterator called Iterator that does more than the older Enumeration.
From a design standpoint, all you really want[10] is a sequence that can be manipulated to solve your problem. If a single type of sequence satisfied all of your needs, there’d be no reason to have different kinds.[11] There are two reasons that you need a choice of containers. First, containers provide different types of interfaces and external behavior. A stack has a different interface and behavior than that of a queue, which is different from that of a set or a list. One of these might provide a more flexible solution to your problem than the other. Second, different containers have different efficiencies for certain operations. The best example is an ArrayList and a LinkedList. Both are simple sequences that can have identical interfaces and external behaviors. But certain operations can have radically different costs. Randomly accessing elements in an ArrayList is a constant-time operation; it takes the same amount of time regardless of the element you select. However, in a LinkedList it is expensive to move through the list to randomly select an element, and it takes longer to find an element that is further down the list. On the other hand, if you want to insert an element in the middle of a sequence, it’s much cheaper in a LinkedList than in an ArrayList. These and other operations have different efficiencies depending on the underlying structure of the sequence. In the design phase, you might start with a LinkedList and, when tuning for performance, change to an ArrayList. Because of the abstraction via iterators, you can change from one to the other with minimal impact on your code.
In the end, remember that a container is only a storage cabinet to put objects in. If that cabinet solves all of your needs, it doesn’t really matter how it is implemented (a basic concept with most types of objects). If you’re working in a programming environment that has built-in overhead due to other factors, then the cost difference between an ArrayList and a LinkedList might not matter. You might need only one type of sequence. You can even imagine the “perfect” container abstraction, which can automatically change its underlying implementation according to the way it is used.
2 The singly rooted hierarchy
One of the issues in OOP that has become especially prominent since the introduction of C++ is whether all classes should ultimately be inherited from a single base class. In Java (as with virtually all other OOP languages) the answer is “yes” and the name of this ultimate base class is simply Object. It turns out that the benefits of the singly rooted hierarchy are many.
There is no doubt that[12] all objects in a singly rooted hierarchy have an interface in common, so they are all ultimately the same type. The alternative (provided by C++) is that you don’t know that everything is the same fundamental type. From a backward-compatibility standpoint this fits the model of C better and can be thought of as less restrictive, but when you want to do full-on object-oriented programming you must then build your own hierarchy to provide the same convenience that’s built into other OOP languages. And in any new class library you acquire, some other incompatible interface will be used. It requires effort (and possibly m

結果 (中文) 1:

姓名：汪尧学号：1402120715 姓名:汪尧学号：1402120715原文：原文：对象的风景状语从句：生存期对象的风景和生存期严格来说，OOP [1]只是抽象数据类型，严格来说，OOP [1] 只是抽象数据类型、 继承和多态性，但其他的问题可以得到至少同样重要。本节的其余部分将涵盖这些问题。最重要的因素之一就是创建和销毁对象的方式。对象和如何是控制对象的生存期的数据在哪里？在这里工作有不同的哲学。++采用的方法控制的效率是最重要的问题，所以它使程序员可以选择。C + + 采用的方法控制的效率是最重要的问题，所以它使程序员可以选择。[2] [2]在堆栈上的对象（这些有时被称为自动或范围的变量）[2] 的最大运行时间速度的存储及使用寿命可以确定当该程序在编写时，通过放置 [2] 在堆栈上的对象 （这些有时被称为自动或范围的变量） 或静态的存储区中。这对速度的内存分配和释放，重视和这些控件可以在某些情况下非常宝贵。一生中和类型的对象，当你[3]在写程序。然而，你牺牲了灵活性，因为你必须知道的确切数量、 一生中和类型的对象，当你 [3] 在写程序。如果你试图解决一个更普遍的问题，如[4]的计算机辅助设计，如果你试图解决一个更普遍的问题，如 [4] 的计算机辅助设计、 仓库管理或空中交通控制，这是限制性太强。第二种方法是内存的在一个叫做堆池中动态创建对象。[3] 在这种方法，你不知道多少的对象，您需要，他们的一生是什么，或者它们的精确类型直到 [3] 的程序正在运行。当程序正在运行时，那些决意在一时心血来潮。如果你需要一个新的对象，你只是让它堆点你需要它。[5]，将存储在堆上的分配量显着长于创建存储在堆栈上的时间。因为存储在运行时动态地管理所需时间 [5]，将存储在堆上的分配量显著长于创建存储在堆栈上的时间。（[6] （[6] 堆栈上创建存储通常是单个程序集指令堆栈指针向下移动，和另一个移动它备份）。动态方法使得一般逻辑的假设，认为对象往往是复杂的所以找到存储并释放存储额外的开销不会对创建的对象有重要的影响。此外，必须解决一般的编程问题是更大的灵活性。完全使用第二种方法，[7]。Java 完全使用第二种方法，[7]。每次你想要创建的对象，使用新的关键字来建立一个动态的该对象实例每次你想要创建的对象，使用 new 关键字来建立一个动态的该对象实例。然而还有另一个问题，[8]这是对象的生存期。然而还有另一个问题，[8] 这是对象的生存期。允许对象在堆栈上创建的[9] 允许对象在堆栈上创建的 [9] 语言，编译器确定该对象能持续多久，并可以自动销毁它。然而，如果你在堆上创建它编译器有其生命周期内的没有知识。C ++语言中，您必须以编程方式确定何时销毁的对象的[10]可以导致内存泄漏，如果你不正确（这是C ++程序中常见的问题）。在像 c + + 语言中，您必须以编程方式确定何时销毁的对象的 [10] 可以导致内存泄漏，如果你不正确 （这是 c + + 程序中常见的问题）。的Java提供了一个功能叫做[ 5]一个垃圾收集器是自动发现当一个对象不再是在使用和破坏它。Java 提供了一个功能叫做 [5] 一个垃圾收集器是自动发现当一个对象不再是在使用和破坏它。[1]的垃圾回收器就方便得多，因为它可以减少您必须跟踪的问题和要写入[12]的代码的次数。[1] 的垃圾回收器就方便得多，因为它可以减少您必须跟踪的问题和要写入 [12] 的代码的次数。更重要的是，垃圾收集器提供了针对潜伏的内存泄漏问题（给带来了许多C ++项目其膝盖）的保险要高得多。更重要的是，垃圾收集器提供了针对潜伏的内存泄漏问题 （给带来了许多 c + + 项目其膝盖） 的保险要高得多。本节的其余看关于对象生存期和景观的其他因素。本节的其余看关于对象生存期和景观的其他因素。1 1 集合和迭代器如果你不知道你要解决一个特定的问题，或他们将会持续多长时间的多少对象，你也不知道如何存储这些对象。你怎么能为这些对象创建多少空间呢？你不能，因为这些信息还不知道直到运行时。面向对象设计中的大多数问题的解决似乎轻浮： 你创建另一种类型的对象。解决了这一特定问题的对象的新类型包含对其他对象的引用。当然，你可以做同样的事情与一个数组，并在大多数语言中可用。但还有更多。这个新的对象，通常被称为一种容器 （也称为一个集合，但 Java 库在不同意义上使用这个词，所以这本书将使用"容器"），将扩大本身每当需要容纳一切你里面它的地方。所以你不需要知道如何 manyobjects 你将要举行一个容器。只是创建一个容器对象，让它照顾的细节。幸运的是，一种好的 OOP 语言带有一组容器作为一揽子计划的一部分。在 c + +，它是标准的 c + + 库的一部分，有时被称为标准模板库 (STL)。帕斯卡有容器，其视觉组件库 （VCL） 的对象。Smalltalk 拥有一套非常完整的容器。Java 还在其标准库容器。一些图书馆在泛型容器被认为是不够好，满足所有的需要，和其他人 （例如 Java） 图书馆拥有不同类型的容器的不同的需求： 一个向量 （称为一个 ArrayList 中 Java） 一致享有一致插入时的例子，所以你可以选择适合您需要的特定类型的所有元素，所有元素和一个链接的列表。容器库也可能包括集、 队列、 哈希表、 树木、 栈等。所有容器都有一些方法来把事情放在和把事情出来 所有容器都有一些方法来把事情放在和把事情出来 ；通常是函数以将元素添加到容器中，和别人去取那些元素打退堂鼓。但取元素可更成问题，因为一个单一选择函数是限制性。如果你想操纵或比较一组而不是只是一个容器中的元素吗？[10] 该解决方案是一个迭代器，其中 [10] 是一个对象，其工作是要选择一个容器内的元素并将其呈现给用户的迭代器。作为一个阶级，它还提供了一个抽象层。这种抽象可以用于从正在访问该容器的代码分离容器的详细信息。抽象的容器，通过迭代器，只是一个序列。- -那就是，是否它是一个数组列表，链表 迭代器允许您无需担心的底层结构遍历该序列 — — 那就是，是否它是一个 ArrayList、 LinkedList、 一个栈，或别的东西。这使您很容易改变底层数据结构而不会干扰您的程序中的代码的灵活性。（在版本1.0和1.1）。与标准的迭代器，呼吁所有的容器类的枚举，在爪哇开始 (在版本 1.0 和 1.1)。的Java 2 Java 2 添加了一个更完整的容器图书馆包含一个迭代器，称为迭代器可以完成更多比年长的枚举。从设计的角度来看，所有你真的想 [10] 是一个序列，可以被修改来解决你的问题。如果某一类型的序列满足您所有的需求，将没有理由要有不同的种类。[11] 有两个原因您需要选择容器。第一，容器提供不同类型的接口和外部行为。栈有一个不同的接口和行为表现比一个队列，是不同的一组或列表。其中之一可能会提供给你的问题比其他更灵活的解决方案。第二，不同的容器具有不同的效率，为某些操作。最好的例子是一个 ArrayList 和 LinkedList。两者都是可以有完全相同的接口和外部行为的简单序列。但是某些操作可以有完全不同的费用。随机访问数组中的元素是一个常量时间的操作 ；它花费同样的时间无论你选择的元素。然而，LinkedList 是贵，将通过列表中随机选择的元素，和需要更长的时间来查找是下去列表中的元素。另一方面，如果你想要插入序列中间的元素，它是中比在 ArrayList 中 LinkedList 便宜得多。这些和其他业务具有不同的效率取决于基础结构的序列。在设计阶段中，你可能会启动与 LinkedList 以及时调整性能，更改到一个 ArrayList。通过迭代器抽象，因为您可以对您的代码更改从一个去其他影响最小。最后，请记住一个容器是只有一个存储柜，将对象放在。如果那内阁可以解决你所有的需求，真的没关系这是如何实现 （与大多数类型的对象的基本概念）。如果你正处于一个已经因其他因素导致的内置开销的编程环境中，然后一个 ArrayList 和 LinkedList 之间的成本差异可能并不重要。您可能需要只有一种类型的序列。你甚至可以想象的"完美"容器抽象，可以自动更改其底层的实现，它用这种方式。2 单根的层次结构在面向对象的 c + + 推行以来，已成为特别突出的问题之一就是是否所有类最终都应该从一个基类都继承。在 Java 中 （如与几乎所有其他面向对象语言） 的答案是"是"，这最终的基类的名称是简单对象。原来单根层次结构的好处很多。毫无疑问的是，[12] 的所有单根的层次结构中的对象具有接口共同之处，所以他们都最终都是同一类型。（由 c + + 提供） 另一种方法是你不知道一切都是相同的基本类型。从向后兼容性的角度来看这适合 C 更好的模型，可以认为尽可能少的限制，但当你想要做全面的面向对象编程时您必须然后生成您自己的层次结构，以方便其他面向对象语言中内置的相同。并且在你获得的任何新的类库，会使用一些其他不兼容的接口。它需要付出努力 （和可能 m

結果 (中文) 3:

姓名：汪尧学号：1402120715
原文：
对象景观和寿命
技术，面向对象程序设计[ 1 ]是抽象数据类型，继承和多态性等问题，但是，至少可以作为重要的。本节将就这些问题。
最重要的因素之一是创建和销毁对象的方式。哪里是一个对象的数据和控制对象的生命周期如何？在工作中有不同的理念，在这里。C以控制效率是最重要的问题，所以它让程序员选择。为[ 2 ]的最大运行速度，存储空间和生命周期可在编写程序时决定，通过将[ 2 ]对堆栈的对象（有时称为自动或域变量）或者静态存储区。这摆在一个重要的内存分配和释放的速度，并控制这些可以在某些情况下非常有用。然而，你牺牲了灵活性，因为你必须知道准确的数量，寿命，而[ 3 ]你在写程序的对象类型。如果你试图解决一个更一般的问题，如[ 4 ]计算机辅助设计，仓库管理，或空中交通控制，这是限制太多了。
第二种方法是动态创建对象，在一个称为堆的内存池。在这种方法中，你不知道你需要多少个对象，他们的一生是什么，或者它们的准确类型直到[ 3 ]程序运行。这些都取决于一时的运行程序时。如果你需要一个新的对象，你只是让它在堆上，你需要它。由于存储是动态管理，在运行时，需要[ 5 ]在堆中分配存储的时间是显着的时间长于在堆栈中创建存储。（创建堆栈上的[ 6 ]存储通常是一个单一的汇编指令将堆栈指针向下移动，而另一回了。）动态方法使对象可以更复杂的逻辑假设，所以找到储存和释放存储的额外开销，也不会对一个对象的创作的重要影响。此外，更大的灵活性来解决一般的编程问题的根本。
Java使用第二种方法，只[ 7 ]。每次你想创建一个对象，你用新的关键字来建立这个对象的一个动态实例。
还有一个问题，但是[ 8 ]，这就是对象的生命周期。与[ 9 ]语言允许对象被创建在堆栈，编译器确定该对象的持续时间并能自动销毁它。然而，如果你创建在堆编译器不知道其寿命。在一个像C语言编程时，你必须确定摧毁目标，这[ 10 ]会导致内存泄漏，如果你不这样做是正确的（这是C程序中的常见问题）。Java提供了一个功能叫做[ 5 ]一个垃圾收集器会自动发现当一个对象不再被使用并摧毁它。一个[ 1 ]垃圾收集器是方便多了，因为它减少了你必须跟踪问题数量和代码写的[ 12 ]。更重要的是，垃圾回收器提供了一种更高对内存泄漏的阴险的问题保险水平（这带来了许多的C项目的膝盖）。
其余的本节讨论操纵对象时要考虑的其他因素。
1集合和迭代器
如果你不知道你要解决一个具体问题多少对象，或者他们将持续多久，也不知道如何存储这些对象。你怎么能知道多少空间来创建这些对象？你不能，因为信息不知道运行时。
在面向对象的设计问题的解决方案似乎是最轻率的：你创造了另一种类型的对象。新类型的对象，解决特定问题持有对其他对象的引用。当然，你可以用数组做同样的事情，这在大多数语言中都可用。但还有更多。这个新的对象，通常称为容器（也被称为一个集合，但Java库使用，长期在一个不同的意义，所以这本书将使用“容器”），将自身扩展必要时容纳一切里面放置。所以你不需要知道多的事物要保持在一个容器。只创建一个对象的容器，让它照顾细节。
幸运的是，一个好的面向对象语言是一套容器的一部分。在C，这是标准C库的一部分，有时也被称为标准模板库（STL）。Object Pascal在可视化组件库中的容器（VCL）。你有非常完整的容器。Java也有它的标准库中的容器。在一些图书馆，一个通用的容器被认为是足够好的为所有需要，和别人（Java，例如）图书馆有不同的需求，不同类型的集合的矢量（称为Java ArrayList）一致的访问所有的元素，和一个链表的所有元素，例如插入一致，所以你可以选择适合你需要的特定类型。其中包括集，队列，哈希表，树，栈，等
所有的容器都有办法把东西拿出来的东西；通常有功能向容器中添加元素，这些元素和其他取出来。但取元素可以有更多的问题，因为一个单一的选择功能的限制。如果你想操纵或比较一组容器中的元素而不是一个？
溶液是迭代器，这[ 10 ]是一个对象的工作是选择容器中的元素和他们的迭代器的用户。作为一类，它也提供了一个抽象层。这种抽象可以用于分离从代码的访问，在容器的细节。通过容器，迭代器，抽象为一个简单的序列。迭代器可以遍历序列，而不必担心基础结构是，不管它是一个矢量，一个链表，堆栈，或其他的东西。这使您在不影响代码的程序很容易改变底层数据结构。Java开始（在版本1和1.1）与一个标准的迭代器，称为枚举，对所有的容器类。Java 2新增一个更完整的容器库包含一个迭代器调用迭代器不超过旧的枚举。
从设计的角度来看，你真正想要的[ 10 ]是一个序列，可以解决你的问题。如果一种类型的序列满足您所有的需求，就没有理由有不同。【11】有两个原因，你需要选择一个容器。第一，容器提供不同类型的接口和外部行为。一堆具有不同的接口和行为比一个队列，这是不同的一组或一个列表。其中的一个可以提供更灵活的解决你的问题比其他。第二，不同的容器有一定的操作不同的效率。最好的例子是一个ArrayList和LinkedList。无论是简单的序列，具有相同的接口和外部行为。但是，某些操作可以有完全不同的成本。随机访问在一个ArrayList元素是常量时间的操作；它花费的时间相同无论你选择的元素。然而，在一个链表是在列表中移动随机选择一个元素和昂贵的，它需要更长的时间才能找到一个元素，还列出。另一方面，如果你想在序列中部插入一个元素，这是更便宜比一个ArrayList LinkedList。这些和其他的操作都有不同的效率取决于序列的基础结构。在设计阶段，你可能会开始一个列表，当调谐性能，改变ArrayList。因为通过迭代器的抽象，你可以改变从一个到另一个具有最小的影响你的代码。
最后，记住，一个容器只是一个储藏柜把对象。如果内阁解决您所有的需求，它并不真正的问题是如何实现的（大多数类型对象的一个基本概念）。如果你是一个编程环境，具有内置的开销，由于其他因素的工作，然后一个ArrayList和LinkedList之间的成本差异可能并不重要。你可能只需要一种类型的序列。你甚至可以想象“完美”的容器的抽象，它可以自动根据使用它的方式改变其底层的实现。
2单根结构
的问题之一在OOP中，自从引入C是否所有类最终应该从一个基类继承变得尤为突出。在Java（与其他几乎所有OOP语言）的回答是“是”，这个终极基类的名称是简单的物体。原来的单根结构的好处是很多的。
毫无疑问，[ 12 ]单根结构中的所有对象都有一个通用接口，所以它们最终都属于相同的类型。替代（由C）是你不知道一切都是相同的基本类型。从向后兼容的角度看这符合C更好，该模型可以作为限制较少的思想，但是当你想做纯粹的面向对象编程，你必须构建自己的结构提供相同的便利，建成其他OOP语言。在任何新的类库，你获得，另一些不兼容的接口将被使用。这需要努力（可能是M