软件专业毕业论文外文文献中英文翻译
Object landscapes and lifetimes
Tech nically, OOP is just about abstract data typing, in herita nee, and polymorphism, but other issues can be at least as importa nt. The rema in der of this sect ion will cover these issues.
One of the most importa nt factors is the way objects are created and destroyed. Where is the data for an object and how is the lifetime of the object con trolled? There are differe nt philosophies at work here. C++ takes the approach that con trol of efficie ncy is the most importa nt 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 places a priority on the speed of storage allocatio n and release, and con trol of these can be very valuable in some situati ons. However, you sacrifice flexibility because you must know the exact qua ntity, lifetime, and type of objects while you're writing the program. If you are trying to solve a more general problem such as computer-aided desig n, warehouse man ageme nt, or air-traffic con trol, this is too restrictive.
The sec ond approach is to create objects dyn amically in a pool of memory called the heap. In this approach, you don't know un til run-time how many objects you n eed, what their lifetime is, or what their exact type is. Those are determined at the spur of the moment while the program is runnin g. If you n eed a new object, you simply make it on the heap at the point that you n eed it. Because the storage is man aged dyn amically, at run-time, the amount of time required to allocate storage on the heap is sig ni fica ntly Ion ger tha n the time to create storage on the stack. (Creat ing storage on the stack is ofte n a si ngle assembly in structio n to move the stack poin ter dow n, and ano ther to move it back up.) The dyn amic approach makes the gen erally logical assumpti on that objects tend to be complicated, so the extra overhead of finding storage and releas ing that storage will not have an importa nt impact on the creati on of an object .In additi on, the greater flexibility is esse ntial to solve the gen eral program ming problem.
Java uses the sec ond approach, exclusive". Every time you want to create an object, you use the new keyword to build a dyn amic in sta nee of that object.
There's ano ther issue, however, and that's the lifetime of an object. With Ian guages 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 kno wledge of its lifetime. In a Ianguage like C++, you must determine programmatically when to destroy the
object, which can lead to memory leaks if you don ' t do it correctly (and this is a com mon problem
in C++ programs). Java provides a feature called a garbage collector that automatically discovers whe n an object is no Ion ger in use and destroys it. A garbage collector is much more convenient because it reduces the nu mber of issues that you must track and the code you must write. More importa nt, the garbage collector provides a much higher level of in sura nee aga inst the in sidious problem of memory leaks (which has brought many a C++ project to its kn ees).
The rest of this secti on looks at additi onal factors concerning object lifetimes and Ian dscapes.
1. The si ngly rooted hierarchy
One of the issues in OOP that has become especially prominent since the in troduct ion of C++ is whether all classes should ultimately be inherited from a single base class. In Java (as with virtually all other OOP Ianguages) th e answer is “ yes ” and the name of this ultimate base class is simply Object. It turns out that the ben efits of the sin gly rooted hierarchy are many.
All objects in a sin gly rooted hierarchy have an in terface in com mon, so they are all ultimately the same type. The alter native (provided by C++) is that you don' know that everyth ing is the same fun dame ntal type. From a backward-compatibility sta ndpo int 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 Ianguages. And in any new ctasBy you acquire, some other in compatible in terface will be used. It requires effort (and possibly multiple in herita nee) to work the new in terface into your desig n. Is the extra “ flexibility ” of C++ worth it? If you n eec
it—if you have a large investment in C —it ' s quite valuable. If you ' re starting from scratch, other
alter natives such as Java can ofte n be more productive.
All objects in a sin gly rooted hierarchy (such as Java provides) can be guara nteed to have certa in function ality. You know you can perform certa in basic operati ons on every object in your system. A sin gly rooted hierarchy, along with creat ing all objects on the heap, greatly simplifies
argume nt pass ing (one of the more complex topics in C++).
A sin gly rooted hierarchy makes it much easier to impleme nt a garbage collector (which is convenien tly built into Java). The n ecessary support can be in stalled in the base class, and the garbage collector can thus send the appropriate messages to every object in the system. Without a singly rooted hierarchy and a system to manipulate an object via a reference, it is difficult to impleme nt a garbage collector.
Since run-time type information is guaranteed to be in all objects, you ' ll never end up with
object whose type you cannot determ ine. This is especially importa nt with system level operati ons, such as exceptio n han dli ng, and to allow greater flexibility in program ming.
2 .Collectio n libraries and support for easy collecti on use
Because a container is a tool that you ' ll use frequently, it makes sense to have a library of containers that are built in a reusable fashion, so you can take one off the shelf Because a container is a tool that you ' ll use frequently, it makes sense to have a library of containers that are
built in a reusable fashi on, so you can take one off the shelf and plug it i nto your program. Java provides such a library, which should satisfy most n eeds.
Down cast ing vs. templates/ge nerics
To make these containers reusable, they hold the one universal type in Java that was previously men ti on ed: Object. The si ngly rooted hierarchy means that everyth ing is an Object, so a container that holds Objects can hold anything. This makes containers easy to reuse.
To use such a container, you simply add object references to it, and later ask for them back.
But, since the container holds only Objects, whe n you add your object reference into the container
it is upcast to Object, thus los ing its ide ntity. When you fetch it back, you get an Object referen ce, and not a reference to the type that you put in. So how do you turn it back into someth ing that has the useful in terface of the object that you put into the container?
Here, the cast is used again, but this time you ' re not casting up the inheritanee hierarchy to a more gen eral type, you cast dow n the hierarchy to a more specific type. This manner of cast ing is called downcasting. With upcasting, you know, for example, that a Circle is a type of Shape so it ' s safe to upcast, but you don ' t knoObjeat annecessarily a Circle or a Shape so it ' s hardly
safe to dow ncast uni ess you know that s what you ' re dealing with.
It ' s not completely dangerous, however, because if you downcast to the wrong thing you get a run-time error called an excepti on, which will be described shortly. When you fetch object references from a container, though, you must have some way to remember exactly what they are so you can perform a proper dow ncast.
Down cast ing and the run-time checks require extra time for the running program, and extra
effort from the programmer. Would n make sense to somehow create the container so that it
knows the types that it holds, elim in at ing the n eed for the dow ncast and a possible mistake? The soluti on is parameterized types, which are classes that the compiler can automatically customize to work with particular types. For example, with a parameterized container, the compiler could customize that container so that it would accept only Shapes and fetch only Shapes.
Parameterized types are an importa nt part of C++, partly because C++ has no sin gly rooted hierarchy .In C++, the
Java cu keyword that impleme nts parameterized types is “ template.
has no parameterized types since it is possible for it to get by —however awkwardly —using the sin gly rooted hierarchy. However, a curre nt proposal for parameterized types uses a syn tax that is strik in gly similar to C++ templates.
对象的创建和存在时间
从技术角度说，00P（面向对象程序设计）只是涉及抽象的数据类型、继承以及多形性，但另一些问题也可能显得非常重要。本节将就这些问题进行探讨。
最重要的问题之一是对象的创建及破坏方式。对象需要的数据位于哪儿，如何控制对象
的“存在时间”呢？针对这个问题，解决的方案是各异其趣的。C++认为程序的执行效率是
最重要的一个问题，所以它允许程序员作出选择。为获得最快的运行速度，存储以及存在时
间可在编写程序时决定，只需将对象放置在堆栈（有时也叫作自动或定域变量）或者静态存
储区域即可。这样便为存储空间的分配和释放提供了一个优先级。某些情况下，这种优先级
的控制是非常有价值的。然而，我们同时也牺牲了灵活性，因为在编写程序时，必须知道对象的准确的数量、存在时间、以及类型。如果要解决的是一个较常规的问题，如计算机辅助
设计、仓储管理或者空中交通控制，这一方法就显得太局限了。
第二个方法是在一个内存池中动态创建对象，该内存池亦叫“堆”或者“内存堆”。若
采用这种方式，除非进入运行期，否则根本不知道到底需要多少个对象，也不知道它们的存
在时间有多长，以及准确的类型是什么。这些参数都在程序正式运行时才决定的。若需一个
新对象，只需在需要它的时候在内存堆里简单地创建它即可。由于存储空间的管理是运行期
间动态进行的，所以在内存堆里分配存储空间的时间比在堆栈里创建的时间长得多（在堆栈
里创建存储空间一般只需要一个简单的指令，将堆栈指针向下或向下移动即可）。由于动态
创建方法使对象本来就倾向于复杂，所以查找存储空间以及释放它所需的额外开销不会为对象的创建造成明显的影响。除此以外，更大的灵活性对于常规编程问题的解决是至关重要的。
C++允许我们决定是在写程序时创建对象，还是在运行期间创建，这种控制方法更加灵
活。大家或许认为既然它如此灵活，那么无论如何都应在内存堆里创建对象，而不是在堆栈
中创建。
但还要考虑另外一个问题，亦即对象的“存在时间”或者“生存时间” （Lifetime ）。
若在堆栈或者静态存储空间里创建一个对象，编译器会判断对象的持续时间有多长，到时会
自动“破坏”或者“清除”它。程序员可用两种方法来破坏一个对象：用程序化的方式决定
何时破坏对象，或者利用由运行环境提供的一种“垃圾收集器”特性，自动寻找那些不再使
用的对象，并将其清除。当然，垃圾收集器显得方便得多，但要求所有应用程序都必须容忍
垃圾收集器的存在，并能默许随垃圾收集带来的额外开销。但这并不符合C++语言的设计宗旨，所以未能包括到C++里。但Java确实提供了一个垃圾收集器（Smalltalk 也有这样的设计；尽管Delphi默认为没有垃圾收集器，但可选择安装；而C++亦可使用一些由其他公司
开发的垃圾收集产品）。
本节剩下的部分将讨论操纵对象时要考虑的另一些因素。
1单根结构
在面向对象的程序设计中，由于C+啲引入而显得尤为突出的一个问题是：所有类最终
是否都应从单独一个基础类继承。在Java中（与其他几乎所有OOP语言一样），对这个问
题的答案都是肯定的，而且这个终级基础类的名字很简单，就是一个“Object ”。这种“单
根结构”具有许多方面的优点。
单根结构中的所有对象都有一个通用接口，所以它们最终都属于相同的类型。另一种方
案（就象C++那样）是我们不能保证所有东西都属于相同的基本类型。从向后兼容的角度看，
这一方案可与C模型更好地配合，而且可以认为它的限制更少一些。但假期我们想进行纯粹
的面向对象编程，那么必须构建自己的结构，以期获得与内建到其他OOP语言里的同样的便
利。需添加我们要用到的各种新类库，还要使用另一些不兼容的接口。理所当然地，这也需
要付出额外的精力使新接口与自己的设计方案配合（可能还需要多重继承）。为得到C++额外的“灵活性”，付出这样的代价值得吗？当然，如果真的需要一一如果早已是C专家，如
果对C有难舍的情结一一那么就真的很值得。但假如你是一名新手，首次接触这类设计，象
Java那样的替换方案也许会更省事一些。
单根结构中的所有对象（比如所有Java对象）都可以保证拥有一些特定的功能。在自
己的系统中，我们知道对每个对象都能进行一些基本操作。一个单根结构，加上所有对象都
在内存堆中创建，可以极大简化参数的传递（这在C++里是一个复杂的概念）。
利用单根结构，我们可以更方便地实现一个垃圾收集器。与此有关的必要支持可安装于
基础类中，而垃圾收集器可将适当的消息发给系统内的任何对象。如果没有这种单根结构，
而且系统通过一个句柄来操纵对象，那么实现垃圾收集器的途径会有很大的不同，而且会面临许多障碍。
由于运行期的类型信息肯定存在于所有对象中，所以永远不会遇到判断不出一个对象的
类型的情况。这对系统级的操作来说显得特别重要，比如违例控制；而且也能在程序设计时
获得更大的灵活性。
2集合库与方便使用集合
由于集合是我们经常都要用到的一种工具，所以一个集合库是十分必要的，它应该可以
方便地重复使用。这样一来，我们就可以方便地取用各种集合，将其插入自己的程序。Java
提供了这样的一个库，尽管它在Java 1.0和1.1中都显得非常有限（Java 1.2的集合库则无疑是一个杰作）。
下溯造型与模板/通用性
为了使这些集合能够重复使用，或者“再生”，Java提供了一种通用类型，以前曾把它叫作"Object ”。单根结构意味着、所有东西归根结底都是一个对象”！所以容纳了Object 的一个集合实际可以容纳任何东西。这使我们对它的重复使用变得非常简便。
为使用这样的一个集合，只需添加指向它的对象句柄即可，以后可以通过句柄重新使用
对象。但由于集合只能容纳Object，所以在我们向集合里添加对象句柄时，它会上溯造型
成Object，这样便丢失了它的身份或者标识信息。再次使用它的时候，会得到一个Object
句柄，而非指向我们早先置入的那个类型的句柄。所以怎样才能归还它的本来面貌，调用早
先置入集合的那个对象的有用接口呢？
在这里，我们再次用到了造型（Cast）。但这一次不是在分级结构中上溯造型成一种更
“通用”的类型。而是下溯造型成一种更“特殊”的类型。这种造型方法叫作“下溯造型”
（Downcasting ）。举个例子来说，我们知道在上溯造型的时候，Circle （圆）属于Shape
（几何形状）的一种类型，所以上溯造型是安全的。但我们不知道一个Object至U底是Circle
还是Shape,所以很难保证下溯造型的安全进行，除非确切地知道自己要操作的是什么。
但这也不是绝对危险的，因为假如下溯造型成错误的东西，会得到我们称为“违例”
（Exception ）的一种运行期错误。我们稍后即会对此进行解释。但在从一个集合提取对象句柄时，必须用某种方式准确地记住它们是什么，以保证下溯造型的正确进行。
下溯造型和运行期检查都要求花额外的时间来运行程序，而且程序员必须付出额外的精
力。既然如此，我们能不能创建一个“智能”集合，令其知道自己容纳的类型呢？这样做可
消除下溯造型的必要以及潜在的错误。答案是肯定的，我们可以采用“参数化类型”，它们
是编译器能自动定制的类，可与特定的类型配合。例如，通过使用一个参数化集合，编译器
参数化类型是C++一个重要的组成部分，这部分是C++没有单根结构的缘故。在C++中,
可对那个集合进行定制，使其只接受Shape,而且只提取Shape。
毕业设计（论文）外文参考文献及译文 英文题目Component-based Safety Computer of Railway Signal Interlocking System 中文题目模块化安全铁路信号计算机联锁系统 学院自动化与电气工程学院 专业自动控制 姓名葛彦宁 学号 200808746 指导教师贺清 2012年5月30日
Component-based Safety Computer of Railway Signal Interlocking System 1 Introduction Signal Interlocking System is the critical equipment which can guarantee traffic safety and enhance operational efficiency in railway transportation. For a long time, the core control computer adopts in interlocking system is the special customized high-grade safety computer, for example, the SIMIS of Siemens, the EI32 of Nippon Signal, and so on. Along with the rapid development of electronic technology, the customized safety computer is facing severe challenges, for instance, the high development costs, poor usability, weak expansibility and slow technology update. To overcome the flaws of the high-grade special customized computer, the U.S. Department of Defense has put forward the concept：we should adopt commercial standards to replace military norms and standards for meeting consumers’demand [1]. In the meantime, there are several explorations and practices about adopting open system architecture in avionics. The United Stated and Europe have do much research about utilizing cost-effective fault-tolerant computer to replace the dedicated computer in aerospace and other safety-critical fields. In recent years, it is gradually becoming a new trend that the utilization of standardized components in aerospace, industry, transportation and other safety-critical fields. 2 Railways signal interlocking system 2.1 Functions of signal interlocking system The basic function of signal interlocking system is to protect train safety by controlling signal equipments, such as switch points, signals and track units in a station, and it handles routes via a certain interlocking regulation. Since the birth of the railway transportation, signal interlocking system has gone through manual signal, mechanical signal, relay-based interlocking, and the modern computer-based Interlocking System. 2.2 Architecture of signal interlocking system Generally, the Interlocking System has a hierarchical structure. According to the function of equipments, the system can be divided to the function of equipments; the system
https://www.doczj.com/doc/4010000.html,/finance/company/consumer.html Consumer finance company The consumer finance division of the SG group of France has become highly active within India. They plan to offer finance for vehicles and two-wheelers to consumers, aiming to provide close to Rs. 400 billion in India in the next few years of its operations. The SG group is also dealing in stock broking, asset management, investment banking, private banking, information technology and business processing. SG group has ventured into the rapidly growing consumer credit market in India, and have plans to construct a headquarters at Kolkata. The AIG Group has been approved by the RBI to set up a non-banking finance company (NBFC). AIG seeks to introduce its consumer finance and asset management businesses in India. AIG Capital India plans to emphasize credit cards, mortgage financing, consumer durable financing and personal loans. Leading Indian and international concerns like the HSBC, Deutsche Bank, Goldman Sachs, Barclays and HDFC Bank are also waiting to be approved by the Reserve Bank of India to initiate similar operations. AIG is presently involved in insurance and financial services in more than one hundred countries. The affiliates of the AIG Group also provide retirement and asset management services all over the world. Many international companies have been looking at NBFC business because of the growing consumer finance market. Unlike foreign banks, there are no strictures on branch openings for the NBFCs. GE Consumer Finance is a section of General Electric. It is responsible for looking after the retail finance operations. GE Consumer Finance also governs the GE Capital Asia. Outside the United States, GE Consumer Finance performs its operations under the GE Money brand. GE Consumer Finance currently offers financial services in more than fifty countries. The company deals in credit cards, personal finance, mortgages and automobile solutions. It has a client base of more than 118 million customers throughout the world
Inventory management Inventory Control On the so-called "inventory control", many people will interpret it as a "storage management", which is actually a big distortion. The traditional narrow view, mainly for warehouse inventory control of materials for inventory, data processing, storage, distribution, etc., through the implementation of anti-corrosion, temperature and humidity control means, to make the custody of the physical inventory to maintain optimum purposes. This is just a form of inventory control, or can be defined as the physical inventory control. How, then, from a broad perspective to understand inventory control? Inventory control should be related to the company's financial and operational objectives, in particular operating cash flow by optimizing the entire demand and supply chain management processes (DSCM), a reasonable set of ERP control strategy, and supported by appropriate information processing tools, tools to achieved in ensuring the timely delivery of the premise, as far as possible to reduce inventory levels, reducing inventory and obsolescence, the risk of devaluation. In this sense, the physical inventory control to achieve financial goals is just a means to control the entire inventory or just a necessary part; from the perspective of organizational functions, physical inventory control, warehouse management is mainly the responsibility of The broad inventory control is the demand and supply chain management, and the whole company's responsibility. Why until now many people's understanding of inventory control, limited physical inventory control? The following two reasons can not be ignored: First, our enterprises do not attach importance to inventory control. Especially those who benefit relatively good business, as long as there is money on the few people to consider the problem of inventory turnover. Inventory control is simply interpreted as warehouse management, unless the time to spend money, it may have been to see the inventory problem, and see the results are often very simple procurement to buy more, or did not do warehouse departments . Second, ERP misleading. Invoicing software is simple audacity to call it ERP, companies on their so-called ERP can reduce the number of inventory, inventory control, seems to rely on their small software can get. Even as SAP, BAAN ERP world, the field of
吉林化工学院理学院 毕业论文外文翻译English Title（Times New Roman ，三号） 学生学号：08810219 学生姓名：袁庚文 专业班级：信息与计算科学0802 指导教师：赵瑛 职称副教授 起止日期：2012.2.27～2012.3.14 吉林化工学院 Jilin Institute of Chemical Technology
1 外文翻译的基本内容 应选择与本课题密切相关的外文文献（学术期刊网上的），译成中文，与原文装订在一起并独立成册。在毕业答辩前，同论文一起上交。译文字数不应少于3000个汉字。 2 书写规范 2.1 外文翻译的正文格式 正文版心设置为：上边距：3.5厘米，下边距：2.5厘米，左边距：3.5厘米，右边距：2厘米，页眉：2.5厘米，页脚：2厘米。 中文部分正文选用模板中的样式所定义的“正文”，每段落首行缩进2字；或者手动设置成每段落首行缩进2字，字体：宋体，字号：小四，行距：多倍行距1.3，间距：前段、后段均为0行。 这部分工作模板中已经自动设置为缺省值。 2.2标题格式 特别注意：各级标题的具体形式可参照外文原文确定。 1．第一级标题（如：第1章绪论）选用模板中的样式所定义的“标题1”，居左；或者手动设置成字体：黑体，居左，字号：三号，1.5倍行距，段后11磅，段前为11磅。 2．第二级标题（如：1.2 摘要与关键词）选用模板中的样式所定义的“标题2”，居左；或者手动设置成字体：黑体，居左，字号：四号，1.5倍行距，段后为0，段前0.5行。 3．第三级标题（如：1.2.1 摘要）选用模板中的样式所定义的“标题3”，居左；或者手动设置成字体：黑体，居左，字号：小四，1.5倍行距，段后为0，段前0.5行。 标题和后面文字之间空一格（半角）。 3 图表及公式等的格式说明 图表、公式、参考文献等的格式详见《吉林化工学院本科学生毕业设计说明书（论文）撰写规范及标准模版》中相关的说明。
中英文资料外文翻译文献 J2EE开发框架 Java2企业版为中间件领域思想的统一上发挥了很大的作用。比如，J2EE为分布式事务管理、目录服务和消息服务提供了一套标准的编程接口。J2EE的基础——Java2标准版(J2SE) ，成功地为Java提供了一套访问关系数据库的标准。 但是，就像本文中“J2EE缺乏对编程的支持”提到的一样，J2EE这个平台没有能够提供一个令人满意的应用程序编程模型。Sun公司和一些大的应用服务器供应商都想用开发工具来降低J2EE开发的复杂性，但是这些工具没有其他的JA V A 开发工具优秀，后者有先进的重构工具，和.NET平台相比，J2EE的工具支持显得很逊色。 很多J2EE开发工具自动产生的代码像这些工具本身同样复杂。在开源社区很多小型J2EE开发者选择了另外一种开发方式——一些可以降低J2EE开发难度的开发框架,较为流行的比如：Struts, Hibernate, 和Spring Framework，他们当今很多J2EE项目种扮演着重要角色。 为什么要采用框架？ 框架是一由一些类组成，正式这些类为应用程序提供了一个可重用的设计――或者我们经常提到的——应用程序种的一层。应用程序代码访问类库从而执行任务，而框架是调用应用程序代码，从而管理程序的流程。这就是经常说道的好莱坞原则：“不要试图联系我们，我们到时候自会通知你。”开发者写的程序在运行时由框架调用。 设计一个在各种未知背景下都可以使用的框架是很有挑战性的。框架很适合在复杂的J2EE开发中使用，它可以为开发者提供一个简单易用的模型。采用一个经过良好设计的开源框架有很多好处：
1、在好的框架下，开发者只需要写一些必须的代码；他们不需要直接接触底层的API。这一点很重要。 2、经过良好设计的框架可以为程序提供清晰的结构并且提高程序的内聚性。好清晰的结构使得其他人可以更容易加入项目。 3、一个容易使用的框架可以通过一些例子和文档为用户提供最佳实践。 4、采用成功的框架的代码比自己的代码容易测试 5、框架只有提供了一些值得使用的功能才会变得流行。J2EE工程只有真正需要框架的时候才会用它，而自己的框架并不是这样，后者是处于统治地位的。 J2EE本身也提供了一些框架。比如，Enterprise Java-Beans (EJB) container 或者Servlet engine，二者都运用了“ 采用了好莱坞原则”这个思想，并采用运行时调用来管理对象。像Struts这些开源web应用框架正式建立在这两个框架的基础上的，本文讨论的重点也是像Struts这样建立在J2EE上的框架，他们为开发者提供了更为简单的模型，和其他的一些好处。 开源框架的出现 很多大型的J2EE项目都用自己的内部框架来隐藏平台的复杂性，直到最近人们才逐渐发现一些在很多项目中都存在的共有的难题，这些难题都可以由一个较为统一的解决方案来解决。而有的框架正好可以充当这些问题的解决方案。现在有种很明显的趋势：与从前的内部框架相比，这些框架将成为这些难题的更加“标准化”的解决方案。 J2EE平台的日益成熟是这些框架流行的一个原因。开发者知道有些地方是J2EE的标准API无能为力的，倚他们的经验来看，要弥补这个缺陷是很困难的。于此同时，一些优秀的开源框架可供使用，它们提供了极为丰富的技术文档，在它们背后还有一个专业的团队做支持，并且一切都是免费的。 Struts 在web应用程序产生的那时就有了开源框架。在1999－2000年，开发者们意识到JSP“Model1”的缺陷，JSP中充斥着请求处理代码和静态数据模板，这意味着你不得不把业务逻辑和复杂的HTML以及其他的标签混到一起。那个时候
中等分辨率制备分离的 快速色谱技术 W. Clark Still,* Michael K a h n , and Abhijit Mitra Departm(7nt o/ Chemistry, Columbia Uniuersity,1Veu York, Neu; York 10027 ReceiLied January 26, 1978 我们希望找到一种简单的吸附色谱技术用于有机化合物的常规净化。这种技术是适于传统的有机物大规模制备分离，该技术需使用长柱色谱法。尽管这种技术得到的效果非常好，但是其需要消耗大量的时间，并且由于频带拖尾经常出现低复原率。当分离的样本剂量大于1或者2g时，这些问题显得更加突出。近年来，几种制备系统已经进行了改进，能将分离时间减少到1-3h，并允许各成分的分辨率ΔR f≥（使用薄层色谱分析进行分析）。在这些方法中，在我们的实验室中，媒介压力色谱法1和短柱色谱法2是最成功的。最近，我们发现一种可以将分离速度大幅度提升的技术，可用于反应产物的常规提纯，我们将这种技术称为急骤色谱法。虽然这种技术的分辨率只是中等（ΔR f≥），而且构建这个系统花费非常低，并且能在10-15min内分离重量在的样本。4 急骤色谱法是以空气压力驱动的混合介质压力以及短柱色谱法为基础，专门针对快速分离，介质压力以及短柱色谱已经进行了优化。优化实验是在一组标准条件5下进行的，优化实验使用苯甲醇作为样本，放在一个20mm*5in.的硅胶柱60内，使用Tracor 970紫外检测器监测圆柱的输出。分辨率通过持续时间（r）和峰宽（w,w/2）的比率进行测定的（Figure 1），结果如图2-4所示，图2-4分别放映分辨率随着硅胶颗粒大小、洗脱液流速和样本大小的变化。
软件专业毕业论文外文文献中英文翻译 Object landscapes and lifetimes Tech nically, OOP is just about abstract data typing, in herita nee, and polymorphism, but other issues can be at least as importa nt. The rema in der of this sect ion will cover these issues. One of the most importa nt factors is the way objects are created and destroyed. Where is the data for an object and how is the lifetime of the object con trolled? There are differe nt philosophies at work here. C++ takes the approach that con trol of efficie ncy is the most importa nt 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 places a priority on the speed of storage allocatio n and release, and con trol of these can be very valuable in some situati ons. However, you sacrifice flexibility because you must know the exact qua ntity, lifetime, and type of objects while you're writing the program. If you are trying to solve a more general problem such as computer-aided desig n, warehouse man ageme nt, or air-traffic con trol, this is too restrictive. The sec ond approach is to create objects dyn amically in a pool of memory called the heap. In this approach, you don't know un til run-time how many objects you n eed, what their lifetime is, or what their exact type is. Those are determined at the spur of the moment while the program is runnin g. If you n eed a new object, you simply make it on the heap at the point that you n eed it. Because the storage is man aged dyn amically, at run-time, the amount of time required to allocate storage on the heap is sig ni fica ntly Ion ger tha n the time to create storage on the stack. (Creat ing storage on the stack is ofte n a si ngle assembly in structio n to move the stack poin ter dow n, and ano ther to move it back up.) The dyn amic approach makes the gen erally logical assumpti on that objects tend to be complicated, so the extra overhead of finding storage and releas ing that storage will not have an importa nt impact on the creati on of an object .In additi on, the greater flexibility is esse ntial to solve the gen eral program ming problem. Java uses the sec ond approach, exclusive". Every time you want to create an object, you use the new keyword to build a dyn amic in sta nee of that object. There's ano ther issue, however, and that's the lifetime of an object. With Ian guages 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 kno wledge of its lifetime. In a Ianguage like C++, you must determine programmatically when to destroy the
文献翻译 原文 Combining JSP and Servlets The technology of JSP and Servlet is the most important technology which use Java technology to exploit request of server, and it is also the standard which exploit business application .Java developers prefer to use it for a variety of reasons, one of which is already familiar with the Java language for the development of this technology are easy to learn Java to the other is "a preparation, run everywhere" to bring the concept of Web applications, To achieve a "one-prepared everywhere realized." And more importantly, if followed some of the principles of good design, it can be said of separating and content to create high-quality, reusable, easy to maintain and modify the application. For example, if the document in HTML embedded Java code too much (script), will lead the developed application is extremely complex, difficult to read, it is not easy reuse, but also for future maintenance and modification will also cause difficulties. In fact, CSDN the JSP / Servlet forum, can often see some questions, the code is very long, can logic is not very clear, a large number of HTML and Java code mixed together. This is the random development of the defects. Early dynamic pages mainly CGI (Common Gateway Interface, public Gateway Interface) technology, you can use different languages of the CGI programs, such as VB, C / C + + or Delphi, and so on. Though the technology of CGI is developed and powerful, because of difficulties in programming, and low efficiency, modify complex shortcomings, it is gradually being replaced by the trend. Of all the new technology, JSP / Servlet with more efficient and easy to program, more powerful, more secure and has a good portability, they have been many people believe that the future is the most dynamic site of the future development of technology. Similar to CGI, Servlet support request / response model. When a customer submit a request to the server, the server presented the request Servlet, Servlet responsible for handling requests and generate a response, and then gave the server, and then from the server sent to
数据库外文参考文献及翻译 数据库外文参考文献及翻译数据库管理系统——实施数据完整性一个数据库，只有用户对它特别有信心的时候。这就是为什么服务器必须实施数据完整性规则和商业政策的原因。执行SQL Server的数据完整性的数据库本身，保证了复杂的业务政策得以遵循，以及强制性数据元素之间的关系得到遵守。因为SQL Server的客户机/服务器体系结构允许你使用各种不同的前端应用程序去操纵和从服务器上呈现同样的数据，这把一切必要的完整性约束，安全权限，业务规则编码成每个应用，是非常繁琐的。如果企业的所有政策都在前端应用程序中被编码，那么各种应用程序都将随着每一次业务的政策的改变而改变。即使您试图把业务规则编码为每个客户端应用程序，其应用程序失常的危险性也将依然存在。大多数应用程序都是不能完全信任的，只有当服务器可以作为最后仲裁者，并且服务器不能为一个很差的书面或恶意程序去破坏其完整性而提供一个后门。SQL Server使用了先进的数据完整性功能，如存储过程，声明引用完整性（DRI），数据类型，限制，规则，默认和触发器来执行数据的完整性。所有这些功能在数据库里都有各自的用途;通过这些完整性功能的结合，可以实现您的数据库的灵活性和易于管理，而且还安全。声明数据完整性声明数据完整原文请找腾讯3249114六,维-论'文.网 https://www.doczj.com/doc/4010000.html, 定义一个表时指定构成的主键的列。这就是所谓的主键约束。SQL Server使用主键约束以保证所有值的唯一性在指定的列从未侵犯。通过确保这个表有一个主键来实现这个表的实体完整性。有时，在一个表中一个以上的列（或列的组合）可以唯一标志一行，例如，雇员表可能有员工编号（ emp_id ）列和社会安全号码（ soc_sec_num ）列，两者的值都被认为是唯一的。这种列经常被称为替代键或候选键。这些项也必须是唯一的。虽然一个表只能有一个主键，但是它可以有多个候选键。 SQL Server的支持多个候选键概念进入唯一性约束。当一列或列的组合被声明是唯一的， SQL Server 会阻止任何行因为违反这个唯一性而进行的添加或更新操作。在没有故指的或者合适的键存在时，指定一个任意的唯一的数字作为主键，往往是最有效的。例如，企业普遍使用的客户号码或账户号码作为唯一识别码或主键。通过允许一个表中的一个列拥有身份属性，SQL Server可以更容易有效地产生唯一数字。您使用的身份属性可以确保每个列中的值是唯一的，并且值将从你指定的起点开始，以你指定的数量进行递增（或递减）。（拥有特定属性的列通常也有一个主键或唯一约束，但这不是必需的。）第二种类型的数据完整性是参照完整性。 SQL Server实现了表和外键约束之间的逻辑关系。外键是一个表中的列或列的组合，连接着另一个表的主键（或着也可能是替代键）。这两个表之间的逻辑关系是关系模型的基础;参照完整性意味着这种关系是从来没有被违反的。例如，一个包括出版商表和标题表的简单的select例子。在标题表中，列title_id （标题编号）是主键。在出版商表，列pub_id （出版者ID ）是主键。 titles表还包括一个pub_id列，这不是主键，因为出版商可以发布多个标题。相反， pub_id是一个外键，它对应着出版商表的主键。如果你在定义表的时候声明了这个关系， SQL Server由双方执行它。首先，它确保标题不能进入titles表，或在titles表中现有的pub_id无法被修改，除非有效的出版商ID作为新pub_id出现在出版商表中。其次，它确保在不考虑titles表中对应值的情况下，出版商表中的pub_id的值不做任何改变。以下两种方法可
毕业设计说明书 英文文献及中文翻译 学院：专 2011年6月 电子与计算机科学技术软件工程
https://www.doczj.com/doc/4010000.html, Overview https://www.doczj.com/doc/4010000.html, is a unified Web development model that includes the services necessary for you to build enterprise-class Web applications with a minimum of https://www.doczj.com/doc/4010000.html, is part of https://www.doczj.com/doc/4010000.html, Framework,and when coding https://www.doczj.com/doc/4010000.html, applications you have access to classes in https://www.doczj.com/doc/4010000.html, Framework.You can code your applications in any language compatible with the common language runtime(CLR), including Microsoft Visual Basic and C#.These languages enable you to develop https://www.doczj.com/doc/4010000.html, applications that benefit from the common language runtime,type safety, inheritance,and so on. If you want to try https://www.doczj.com/doc/4010000.html,,you can install Visual Web Developer Express using the Microsoft Web Platform Installer,which is a free tool that makes it simple to download,install,and service components of the Microsoft Web Platform.These components include Visual Web Developer Express,Internet Information Services (IIS),SQL Server Express,and https://www.doczj.com/doc/4010000.html, Framework.All of these are tools that you use to create https://www.doczj.com/doc/4010000.html, Web applications.You can also use the Microsoft Web Platform Installer to install open-source https://www.doczj.com/doc/4010000.html, and PHP Web applications. Visual Web Developer Visual Web Developer is a full-featured development environment for creating https://www.doczj.com/doc/4010000.html, Web applications.Visual Web Developer provides an ideal environment in which to build Web sites and then publish them to a hosting https://www.doczj.com/doc/4010000.html,ing the development tools in Visual Web Developer,you can develop https://www.doczj.com/doc/4010000.html, Web pages on your own computer.Visual Web Developer includes a local Web server that provides all the features you need to test and debug https://www.doczj.com/doc/4010000.html, Web pages,without requiring Internet Information Services(IIS)to be installed. Visual Web Developer provides an ideal environment in which to build Web sites and then publish them to a hosting https://www.doczj.com/doc/4010000.html,ing the development tools in Visual Web Developer,you can develop https://www.doczj.com/doc/4010000.html, Web pages on your own computer.