网络即时通信系统的设计 外文文献翻译.doc

1、学校代码： XXX学 号：XXX 本科毕业设计外文文献翻译（学生姓名：XXX学 院：信息工程学院系 别：计算机系专 业：软件工程班 级：软件06指导教师：XXX 讲师二一年六月本文源码索取，请联系qq：XXX工业大学本科毕业设计外文文献翻译Object landscapes and lifetimesTechnically, OOP is just about abstract data typing, inheritance, and polymorphism, but other issues can be at least as important. The remainder of t

2、his 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 th

3、e most important issue, so it gives the programmer a choice. For maximum run-time speed, the storage and lifetime can be determined while the program is being written, by placing the objects on the stack (these are sometimes called automatic or scoped variables) or in the static storage area. This p

4、laces 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 youre writing the program. If you are trying to solve a more

5、 general problem such as 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 dont know until run-time how many objects you need, what their lifeti

6、me is, or what their exact type is. 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 to allocate st

7、orage on the heap is significantly longer than the time to create storage on the stack. (Creating storage on the stack 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

8、 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. Every time y

9、ou want to create an object, you use the new keyword to build a dynamic instance of that object. Theres another issue, however, and thats the lifetime of an object. With languages that allow objects to be created on the stack, the compiler determines how long the object lasts and can automatically d

10、estroy 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 can lead to memory leaks if you dont do it correctly (and this is a common problem in C+ programs). Java provid

11、es a feature called a garbage collector that automatically discovers when an object is no longer in use and destroys it. A garbage collector is much more convenient because it reduces the number of issues that you must track and the code you must write. More important, the garbage collector provides

12、 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 iteratorsIf you dont know how many objects youre goin

13、g to need to solve a particular problem, or how long they will last, you also dont know how to store those objects. How can you know how much space to create for those objects? You cant, since that information isnt known until run-time. The solution to most problems in object-oriented design seems f

14、lippant: 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 theres more. This new object, generally called a container (also cal

15、led 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 dont need to know how manyobjects youre going to hold in a container. Just create a container obj

16、ect 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+, its 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 con