高分求助，来者有分，翻译得好，给RMB!!!(100分)

1. Apart from bugs in programs, memory leakage, and fragmentation, it is also possible that conscious design decisions actually cause unnecessary or unexpected footprint problems.
<中文>
</中文>
As we have seen before, part of the runtime footprint is used during the execution of the program for storing (intermediate) data.
<中文>
</中文>
How the program handles this intermediate data determines its behavior when the data set grows. It is fairly likely that a routine used for transforming a certain set of data will, at some point, cause the original data and the transformed data to be in memory at the same time.
<中文>
</中文>
An example of this is the aforementioned decompression routine. Designed very badly, this decompression routine might keep all the compressed data in memory while it allocates yet more memory to store all the decompressed data.
<中文>
</中文>
This will not pose a problem for small files;
in fact it is a very fast way of working due to the low level of instruction overhead. Consequently, this routine will seem to work fine during a test phase that used only small files.
<中文>
</中文>
However, as the program is called on to decompress ever larger files in the field, the problem becomes apparent. A better designed program would first take into account the amount of memory available and then
determine the appropriate amount of input data to load.
<中文>
</中文>

2. Java objects can be produced dynamically during execution, for example by object = new ClassName ()
<中文>
</中文>
These objects are stored on the heap and removed by the garbage collector when no longer needed. In this way, storage management in Java is handled by the system, with no need for the dreaded malloc and free procedures, or even for explicit pointers, for that matter.
<中文>
</中文>
Each class is based on another class. A newly defined class is said to be a subclass of the class on which it is based, the superclass. A (sub) class always inherits the methods of its superclass. It may or may not have direct access to the superclass’ internal variables, depending on whether or not the superclass wants that.
<中文>
</中文>
For example, if a superclass, A, has methods M1, M2, and M3, and a subclass, B, defines a new method, M4, then
objects created from B, will have methods M1, M2, M3, and M4.
<中文>
</中文>
The property of a class automatically acquiring all the methods of its superclass is called inheritance, and is an import property of Java. Adding new methods to the superclass’ methods is called extending the superclass.
<中文>
</中文>
As an aside, some object-oriented languages allow classes to inherit methods from two or more superclasses (multiple inheritance), but the Java designers thought this property to be too messy and intentionally left it out.
<中文>
</中文>

As an aside, some object-oriented languages allow classes to inherit methods from two or more superclasses (multiple inheritance), but the Java designers thought this property to be too messy and intentionally left it out.
说句题外话，一些面向对象的语言允许从两个或者多个超类（多继承）继承，但是JAVA程序的设计人员认为这样可能会导致混乱而有意的避开它

倒数第二段
The property of a class automatically acquiring all the methods of its superclass is called inheritance, and is an import property of Java. Adding new methods to the superclass’ methods is called extending the superclass.
一个类自动从它的超类中获取方法的特性称之为继承，该属性也是Java语言的引入特性。将一个新的方法添加到超类的方法（系列）中称为超类的扩充。

倒数第三段：
For example, if a superclass, A, has methods M1, M2, and M3, and a subclass, B, defines a new method, M4, then
objects created from B, will have methods M1, M2, M3, and M4.
举个例子，如果一个超类A,拥有方法M1,m2,m3和一个子类B,B定义了一个新方法M4，那么从B创建的对象将会拥有M1,M2,M3,M4这些方法。
倒数第4段
Each class is based on another class. A newly defined class is said to be a subclass of the class on which it is based, the superclass. A (sub) class always inherits the methods of its superclass. It may or may not have direct access to the superclass’ internal variables, depending on whether or not the superclass wants that.
每一个类都是以其他的类为基础建立的。一个新定义的类被称作它基类（超类）的子类。一个子类总是继承它超类的方法。能否存取超类的内置变量取决于超类认为这样做是有必要的

翻译得不好,请别笑我!
1. Apart from bugs in programs, memory leakage, and fragmentation, it is also possible that conscious design decisions
actually cause unnecessary or unexpected footprint problems.
<中文>
1. "臭虫"除了在程序中，内存泄漏和分裂中之外，它也可能是有意识的设计决定实际上引起不必要的或料想不到的足迹问题。
</中文>
As we have seen before, part of the runtime footprint is used during the execution of the program for storing (intermediate)
data.
<中文>
当我们以前已经看到的时候,运行时足迹的部份被用在程序存储(中间的) 数据的过程中。
</中文>
How the program handles this intermediate data determines its behavior when the data set grows. It is fairly likely that a
routine used for transforming a certain set of data will, at some point, cause the original data and the transformed data to
be in memory at the same time.
<中文>
程序如何处理这个中间数据生长时所决定的行为。 很可能是公平的, 一个程序转换某一组数据将会，在一些点上，引起最初的数据和被转换的
数据同时在内存中。
</中文>
An example of this is the aforementioned decompression routine. Designed very badly, this decompression routine might keep
all the compressed data in memory while it allocates yet more memory to store all the decompressed data.
<中文>
一个上述的解压程序的例子。这个解压程序设计得非常遭,当它分派较多的内存用于存储所有的被解压缩的数据时, 可能仍然把所有被解压的数
据放在内存中。
</中文>
This will not pose a problem for small files;
in fact it is a very fast way of working due to the low level of instruction
overhead. Consequently, this routine will seem to work fine during a test phase that used only small files.
<中文>
对于小的文件,这将不会造成问题；事实上它是工作在低水准的指令上面的一个非常快速的方法。 结果，这程序好像工作得很好,在一个仅仅使
用很小文件的测试阶段。
</中文>
However, as the program is called on to decompress ever larger files in the field, the problem becomes apparent. A better
designed program would first take into account the amount of memory available and then
determine the appropriate amount of
input data to load.
<中文>
然而，当个程序被应用于解压缩较大文件的领域时,问题就变得明显起来。 一个设计较好的程序首先要考虑可用内存的数量,然后决定适当量的
输入数据进行装载。
</中文>

2. Java objects can be produced dynamically during execution, for example by object = new ClassName ()
<中文>
Java对象在实行期间会动态地产生, 举例来说,object = new ClassName ()
</中文>
These objects are stored on the heap and removed by the garbage collector when no longer needed. In this way, storage
management in Java is handled by the system, with no need for the dreaded malloc and free procedures, or even for explicit
pointers, for that matter.
<中文>
这些对象被存储在堆中,并且在不再需要时被回收。 这样，Java的存储管理经过系统,不用担心分配(malloc)和释放(free)过程,乃至外在的指针。
</中文>

1. Apart from bugs in programs, memory leakage, and fragmentation, it is also possible that conscious design decisions actually cause unnecessary or unexpected footprint problems.
<中文>
1. bug除了出现在程序、内存溢出和碎片之外，它也可能是在设计中有意的加入，以引起不必要的或料想不到的后门问题。

1. Apart from bugs in programs, memory leakage, and fragmentation, it is also possible that conscious design decisions actually cause unnecessary or unexpected footprint problems.
除了程序中的缺陷、内存泄漏和产生碎片以外，引起不必要或者意想不到的内存覆盖问题的有意识设计也是有可能的。

学习

As we have seen before, part of the runtime footprint is used during the execution of the program for storing (intermediate) data.
如同我问以前看到的，运行期的内存覆盖被用在进行程序存储数据（中间值）的过程中。
How the program handles this intermediate data determines its behavior when the data set grows. It is fairly likely that a routine used for transforming a certain set of data will, at some point, cause the original data and the transformed data to be in memory at the same time.
<中文>
当程序中的数据集增长时，程序如何操作中间数据决定了它的特性。一个常规的针对特定数据集的转换，将会出现在某一个点转换中的数据和原始数据同时存在于内存中。
</中文>
An example of this is the aforementioned decompression routine. Designed very badly, this decompression routine might keep all the compressed data in memory while it allocates yet more memory to store all the decompressed data.
<中文>
上面讲述的一个例子就是解压缩的过程，（假定）程序设计得很差，该解压缩进程可能会分配而外(内存)空间用以存储所有的解压过的数据，同时让所有的未解压数据也同时存在。
</中文>
This will not pose a problem for small files;
in fact it is a very fast way of working due to the low level of instruction overhead. Consequently, this routine will seem to work fine during a test phase that used only small files.
<中文>
在小文件的操作中，这不会有什么问题；但实际上，由于低水平的系统开销编码，它是一种快速的方法。因此，在使用小文件的测试阶段，这种程序看起来工作的很好。
</中文>
However, as the program is called on to decompress ever larger files in the field, the problem becomes apparent. A better designed program would first take into account the amount of memory available and then
determine the appropriate amount of input data to load.
<中文>
然而，当该程序进行更大文件的解压调用时，问题就变得明显了。更好的程序设计将会首先计算可用内存的容量然后决定将适当大小的输入数据调入内存。
</中文>

2. Java objects can be produced dynamically during execution, for example by object = new ClassName ()
<中文>
Java对象可以在执行过程中动态产生，例如：object = new ClassName ()
</中文>
These objects are stored on the heap and removed by the garbage collector when no longer needed. In this way, storage management in Java is handled by the system, with no need for the dreaded malloc and free procedures, or even for explicit pointers, for that matter.
这些对象被存储在（内存的）堆中，并由垃圾收集器(Java术语)在当它不不需要时进行移除。通过这种方法，Java中的程序可以被系统控制，并且无需担心过程的分配和释放，甚至是对外部指针的使用。
///////////////////
靠，居然全翻译完了

to wyb_506:你翻译得很好，真不错！要是我有你这种水平就好了．

多谢各位!!!