计算机毕业论文文献翻译
毕业论文的参考文献的中文格式与翻译
毕业论文的参考文献的中文格式与翻译参考文献是毕业论文中非常重要的部分，它汇集了作者在撰写论文过程中所参考的资料和引用的文献来源。
为了使参考文献的格式和翻译准确无误，以下是毕业论文参考文献的中文格式与翻译的详细介绍。
一、参考文献的中文格式在毕业论文中，参考文献的中文格式通常按照GB/T 7714-2015《文后参考文献著录规则》的要求进行编写。
下面是中文参考文献的格式示例：[1] 作者. 文献题目[J]. 期刊名, 年份, 卷号(期号): 起始页码-结束页码.[2] 作者. 文献题目[M]. 出版地: 出版社, 出版年份.[3] 作者. 文献题目[D]. 保存地: 保存单位, 年份.[4] 作者. 文献题目[EB/OL]. (更新或出版日期) [引用日期]. 可获取网址.上述格式中，方括号内的数字代表参考文献的顺序编号，作者表示文献的作者姓名，文献题目是对文献内容的简要概述，期刊名指的是该文献发表的期刊名称，年份代表文献发表的年份，卷号(期号)指的是该文献发表的期刊卷号和期刊期号，起始页码和结束页码表示文献在期刊中所占的页码范围，出版地指的是文献出版的地点，出版社表示文献的出版社，出版年份指的是文献的出版年份，保存地表示文献现在保存的地方，保存单位指的是文献的保管单位，更新或出版日期指的是网上资源的更新或出版日期，引用日期是获取网上资源时的日期，网址指的是网上资源的网址。
二、参考文献的翻译当我们在毕业论文中引用外文文献时，需要对文献题目进行翻译以便读者能够理解。
下面是一些常见的翻译方法和示例：1. 直译法：将外文文献的标题逐字逐句地直接翻译成中文。
示例：[1] Smith J. How to Write a Research Paper[J]. Journal of Academic Writing, 2018, 5(2): 123-135.翻译为：[1] 史密斯 J. 如何写一篇研究论文[J]. 学术写作杂志, 2018,5(2): 123-135.2. 意译法：根据文献的内容和语境将外文文献的标题进行意义上的翻译。
软件工程毕业论文文献翻译中英文对照
软件工程毕业论文文献翻译中英文对照学生毕业设计(论文)外文译文学生姓名: 学号专业名称:软件工程译文标题(中英文):Qt Creator白皮书(Qt Creator Whitepaper)译文出处:Qt network 指导教师审阅签名: 外文译文正文:Qt Creator白皮书Qt Creator是一个完整的集成开发环境(IDE)，用于创建Qt应用程序框架的应用。
Qt是专为应用程序和用户界面，一次开发和部署跨多个桌面和移动操作系统。
本文提供了一个推出的Qt Creator和提供Qt开发人员在应用开发生命周期的特点。
Qt Creator的简介Qt Creator的主要优点之一是它允许一个开发团队共享一个项目不同的开发平台(微软Windows?的Mac OS X?和Linux?)共同为开发和调试工具。
Qt Creator的主要目标是满足Qt开发人员正在寻找简单，易用性，生产力，可扩展性和开放的发展需要，而旨在降低进入新来乍到Qt的屏障。
Qt Creator 的主要功能，让开发商完成以下任务: , 快速，轻松地开始使用Qt应用开发项目向导，快速访问最近的项目和会议。
, 设计Qt物件为基础的应用与集成的编辑器的用户界面，Qt Designer中。
, 开发与应用的先进的C + +代码编辑器，提供新的强大的功能完成的代码片段，重构代码，查看文件的轮廓(即，象征着一个文件层次)。
, 建立，运行和部署Qt项目，目标多个桌面和移动平台，如微软Windows，Mac OS X中，Linux的，诺基亚的MeeGo，和Maemo。
, GNU和CDB使用Qt类结构的认识，增加了图形用户界面的调试器的调试。
, 使用代码分析工具，以检查你的应用程序中的内存管理问题。
, 应用程序部署到移动设备的MeeGo，为Symbian和Maemo设备创建应用程序安装包，可以在Ovi商店和其他渠道发布的。
, 轻松地访问信息集成的上下文敏感的Qt帮助系统。
毕业论文的参考文献的英文翻译与整理
毕业论文的参考文献的英文翻译与整理Reference Translation and Organization of Graduation ThesisAbstract:In academic writing, it is essential to include appropriate and accurate references to support the arguments and ideas presented in a research paper. This article focuses on the translation and organization of references in a graduation thesis. The importance of referencing, common challenges in translation, and effective strategies for organizing references will be discussed.1. Introduction1.1 Background1.2 Purpose of the Study2. Importance of Referencing2.1 Credibility and Scholarly Integrity2.2 Acknowledging Intellectual Contributions2.3 Avoiding Plagiarism3. Common Challenges in Translation3.1 Terminology and Technical Vocabulary3.2 Cultural and Contextual Nuances3.3 Translating Non-English References4. Strategies for Translating References4.1 Literal Translation4.2 Paraphrasing4.3 Maintaining Consistency5. Organization of References5.1 Citation Styles5.2 Creating a Reference List5.3 Formatting Guidelines6. Tools and Resources for Reference Translation6.1 Online Translation Tools6.2 Electronic Databases and Libraries6.3 Style Guides and Manuals7. ConclusionReferences (References should be listed in alphabetical order according to the citation style used in the graduation thesis)Please note that the above format is a general example. Depending on the specific requirements of your graduation thesis, you may need to modify the structure and add additional sections.In conclusion, the translation and organization of references in a graduation thesis play a crucial role in maintaining the credibility andintegrity of the research. By accurately translating and properly organizing references, researchers can provide readers with easily accessible information and demonstrate their acknowledgment of the intellectual contributions of others. It is important to be meticulous and consistent in following the chosen citation style to ensure the professional presentation of the references.。
java英文参考文献(20210507015628)
java 英文参考文献篇一：外文参考文献译文及原文本科毕业设计（论文）外文参考文献译文及原文学院_________ 计算机学院专业___计算机科学与技术_年级班别___ 2009级（1）班学号学生姓名______ ________指导教师_____ ________2013年5月目录译文： (1)第一章微软.NET 平台的介绍 (3)1.1 简介.................................................................................................................1.1.1 .NET 平台简介 (3)1.1.2 微软的.NET 和WINDOWS 的基3因 (4)1.1.3 微软.NET 体系结构 (4)1.1.4 .NET 平台的特点 (4)J \\\ ................................................................................................................................................................................................................................................................................................................................ ■1.1.5 多国语言的发展 (5)1.1.6 平台和处理器独立性 (6)1.1.7 自动内存管理 (7)1.1.8 支持的版本 (7)1.1.9 支持的开放标准 (8)1.1.10 配置简单 (8)1.1.11 分布式体系结构 (9)1.1.12 与非托管代码的互用 (9)原文：Foreword ..................................................................................................... .............................. 11 Chapter1 Introduction of the Microsoft .NET Platform 131.1 Introduction ................................................................................................. .. (13)1.1.1 Introduction of the .NET Platform (13)1.1.2 Microsoft .NET and WindowsDNA (15)1.1.3 Microsoft .NET Architecture Hierarchy ....................................151.1.4 Features of the .NET Platform (16)1.1.5 Multilanguage Development (17)1.1.6 Platform and Processor Independence (18)1.1.7 Automatic Memory Management (19)1.1.8 Versioning Support (20)1.1.9 Support for OpenStandards (21)1.1.10 Easy Deployment (22)1.1.11 Distributed Architecture (23)1.1.12 Interoperability with Unmanaged Code (23)译文：、尸■、亠前言在电脑软件的历史上，很少有一种技术能够得到开发者和业界如此强烈的正面响应。
计算机毕业论文文献翻译
计算机毕业论文文献翻译计算机毕业论文文献翻译的重要性在计算机科学与技术领域，毕业论文是评估学生对所学知识的理解和应用能力的重要标准。
而其中一个重要的环节就是对相关文献的翻译和理解。
毕业论文文献翻译不仅仅是简单的将英文文献转换为中文，更是对研究领域的深入探索和理解的过程。
首先，毕业论文文献翻译对于学生来说是一种学习和提升的机会。
通过翻译文献，学生可以学习到国外领先的研究成果和技术进展。
这些文献往往包含了最新的研究成果、方法和技术，对于学生的学术研究和创新能力的提升有着重要的作用。
通过翻译文献，学生可以了解到国外学者的研究思路和方法，从而拓宽自己的研究思路和方法论。
其次，毕业论文文献翻译对于学术交流和合作具有重要意义。
计算机科学与技术是一个国际化的学科领域，学术交流和合作是不可或缺的。
通过翻译文献，学生可以了解到国外学者的研究成果和进展，从而与他们进行学术交流和合作。
这种交流和合作不仅可以促进学术研究的进展，还可以为学生提供更多的学术机会和资源。
此外，毕业论文文献翻译对于学生的综合素质和语言能力的提升也具有重要作用。
计算机科学与技术是一门综合性的学科，它涉及到多个学科领域的知识和技术。
通过翻译文献，学生可以学习到更多的学科知识和技术，从而提升自己的综合素质。
同时，毕业论文文献翻译也是对学生语言能力的一种考验。
翻译文献不仅要求学生具备良好的英语基础，还要求学生具备较高的语言表达和表达能力。
最后，毕业论文文献翻译对于学生的职业发展也具有重要意义。
计算机科学与技术是一个快速发展的学科领域，不断涌现出新的技术和应用。
通过翻译文献，学生可以了解到国外领先的技术和应用，从而为自己的职业发展提供更多的机会和选择。
同时，毕业论文文献翻译也是提升学生职业竞争力的一种方式。
在求职过程中，能够熟练运用英语进行文献翻译和理解的学生往往更受欢迎。
总之，计算机毕业论文文献翻译不仅仅是学生完成毕业论文的一项任务，更是学习、交流、合作和发展的重要机会。
毕业论文的文献翻译是什么
毕业论文的文献翻译是什么毕业论文的文献翻译是什么在撰写毕业论文的过程中，文献翻译是一个不可忽视的环节。
文献翻译是指将外文文献转化为母语的过程，旨在使读者能够准确理解并运用这些文献中的信息。
在这个过程中，翻译者需要具备一定的翻译技巧和专业知识，以确保翻译结果的准确性和流畅性。
首先，文献翻译需要翻译者具备良好的语言能力。
翻译者需要熟练掌握目标语言和源语言，准确理解文献中的内容，并将其转化为母语。
在翻译过程中，翻译者需要注意语法、词汇和句法等方面的准确性，以确保翻译结果的质量。
其次，文献翻译需要翻译者具备专业知识。
毕业论文通常涉及特定的学科领域，因此翻译者需要对该领域的专业术语和概念有一定的了解。
只有在掌握了相关的专业知识后，翻译者才能准确理解文献中的内容，并将其转化为母语，使读者能够理解和运用这些信息。
此外，文献翻译还需要翻译者具备一定的翻译技巧。
翻译技巧是指在翻译过程中运用的一些方法和策略，以提高翻译的准确性和流畅性。
例如，翻译者可以采用对等翻译、意译或加注说明等方式来处理一些难以准确翻译的内容。
同时，翻译者还需要注意上下文的连贯性和一致性，以确保翻译结果的整体性和可读性。
此外，文献翻译还需要翻译者具备一定的研究能力。
在翻译过程中，翻译者需要对文献中的内容进行深入的研究和理解，以确保翻译结果的准确性和可靠性。
翻译者需要查阅相关的参考资料和文献，了解文献中的背景和相关的研究成果，以便更好地理解和翻译文献中的内容。
最后，文献翻译还需要翻译者具备一定的时间管理能力。
毕业论文的撰写通常有严格的时间要求，因此翻译者需要合理安排时间，确保在规定的时间内完成文献翻译的任务。
同时，翻译者还需要预留一定的时间进行校对和修改，以确保翻译结果的质量。
综上所述，毕业论文的文献翻译是一个需要翻译者具备一定的语言能力、专业知识、翻译技巧、研究能力和时间管理能力的过程。
只有在具备这些能力的基础上，翻译者才能准确理解和翻译文献中的内容，并将其转化为母语，使读者能够准确理解并运用这些信息。
毕业设计论文 外文文献翻译
毕业设计（论文）外文参考文献翻译计算机科学与信息工程系系（院）2008 届题目企业即时通Instant Messaging for Enterprises课题类型技术开发课题来源自选学生姓名许帅专业班级 04计算机科学与技术指导老师王占中职称工程师完成日期：2008年4 月 6 日目录I NSTANT M ESSAGING FOR E NTERPRISE (1)1. Tips (1)2. Introduction (1)3. First things first (2)4.The While-Accept loop (4)5. Per-Thread class (6)6. The Client class (7)企业即时通 (9)1.提示 (9)2.简介 (9)3.首先第一件事 (10)4.监听循环 (11)5.单线程类 (13)6.用户端类 (14)Instant Messaging for Enterprise1. TipsIf Java is, in fact, yet another computer programming language, you may question why it is so important and why it is being promoted as a revolutionary step in computer programming. The answer isn’t immediately obvious if you’re coming from a tr aditional programming perspective. Although Java is very useful for solving traditional standalone programming problems, it is also important because it will solve programming problems on the World Wide Web. What is the Web?The Web can seem a bit of a mys tery at first, with all this talk of “surfing,”“presence,” and “home pages.” It’s helpful to step back and see what it really is, but to do this you must understand client/server systems, another aspect of computing that is full of confusing issues. The primary idea of a client/server system is that you have a central repository of information，some kind of data, often in a database。
计算机专业毕业设计论文外文文献中英文翻译——java对象
1 . Introduction To Objects1.1The progress of abstractionAll programming languages provide abstractions. It can be argued that the complexity of the problems you’re able to solve is directly related to the kind and quality of abstraction。
By “kind” I mean，“What is it that you are abstracting?” Assembly language is a small abstraction of the underlying machine. Many so—called “imperative” languages that followed （such as FORTRAN，BASIC, and C) were abstractions of assembly language。
These languages are big improvements over assembly language，but their primary abstraction still requires you to think in terms of the structure of the computer rather than the structure of the problem you are trying to solve。
The programmer must establish the association between the machine model (in the “solution space，” which is the place where you’re modeling that problem, such as a computer) and the model of the problem that is actually being solved (in the “problem space,” which is the place where the problem exists). The effort required to perform this mapping, and the fact that it is extrinsic to the programming language，produces programs that are difficult to write and expensive to maintain，and as a side effect created the entire “programming methods” industry.The alter native to modeling the machine is to model the problem you’re trying to solve。
计算机中英论文
Understanding Web Addresses You can think of the World Wide Web as a network of electronic files stored on computers all around the world. Hypertext links these
news - a newsgroup
Ø telnet - a computer system that you can log into over the Internet Ø WAIS - a database or document in a Wide Area Information Search database Ø file - a file located on a local drive (your hard drive)
1
resources together. Uniform Resource Locators or URLs are the addresses used to locate these files. The information contained in a URL gives you the ability to jump from one web page to another with just a click of your mouse. When you type a URL into your browser or click on a hypertext link, your browser is sending a request to a remote computer to download a file. What does a typical URL look like? Here are some examples: / The home page for study English. ftp:///pub/ A directory of files at MIT available for downloading. news:rec.gardens.roses A newsgroup on rose gardening. The first part of a URL (before the two slashes* tells you the type of resource or method of access at that address. For example: Ø Ø Ø files Ø http - a hypertext document or directory gopher - a gopher document or menu ftp - a file available for downloading or a directory of such
【计算机专业文献翻译】信息系统的管理
传播媒体必须经过仔细选择，平衡每个媒体的优点和缺点，这个选择决定网络的速度。改变一个已经安装好的网络媒体通常非常昂贵。最实用的传播媒体是电缆，光纤，广播，光，红外线。
本科生毕业设计（论文）外文资料译文
（2009届）
论文题目
基于Javamail的邮件收发系统
学生姓名
学号
专业
计算机科学与技术
班级
指导教师
职称
讲师、副教授
填表日期
2008年 12月 10 日
信息科学与工程学院教务科制
外文资料翻译（译文不少于2000汉字）
1．所译外文资料：信息系统的管理Managing Information Systems
数据共享是网络的重要应用之一。网络可以共享交易数据，搜索和查询数据，信息，公告板，日历，团队和个人信息数据，备份等。在交易的时候，连接一个公司的电脑的中央数据库包括现有库存信息和出售的数据信息。如果数据被储存在一个中央数据库中，搜查结果便可从中获取。电子邮件的发送已经成为同事之间最常用的信息共享的方式之一。
自从信号在空中传输后，广播，光以及红外线作为传播媒体已经不需要电缆。
传输能力，即一个传播媒体一次性传输的数据量，在不同的媒体中，材料不同，安装时付出的劳动不同，传输的能力有很大的区别。传播媒体有时候被合并，代替远地域之间的高速传播媒体，速度虽慢，但是成本低，在一幢大楼中进行信息传播。
连接设备包括网络连接卡NICS，或者在计算机和网络间进行传输和信号传递的局域网LAN卡。其他常用的设备连接不同的网络，特别是当一个网络使用不用的传输媒体的时候。使用一个对很多用户都开放的系统很重要，比如windows/NT,Office2000，Novell，UNIX.
如何进行毕业论文的文献翻译与引用
如何进行毕业论文的文献翻译与引用毕业论文的文献翻译与引用是在写作过程中必不可少的一环。
良好的文献翻译与引用能够提升论文的质量与价值，增强论文的可信度和学术性。
然而，很多同学在文献翻译与引用方面存在一定困惑。
本文将介绍如何进行毕业论文的文献翻译与引用，以期帮助大家在论文写作中更加准确地翻译和引用文献。
一、文献翻译文献翻译是指将外文文献翻译成目标语言，以便读者理解和使用。
在进行文献翻译时，我们需要注意以下几点：1. 选择合适的文献在选择翻译文献时，应根据自己的研究方向和论文题目，选择与之相关的文献进行翻译。
同时要注意选择权威、可靠的文献来源，以确保翻译结果的准确性和可信度。
2. 注重语言表达和用词准确在进行翻译时，要注重语言表达和用词准确。
句子结构要清晰，语意要准确传达。
避免直译和误译，要根据上下文和语境进行恰当的翻译。
3. 保持文献原义在翻译过程中，应努力保持文献的原意。
不要对原文进行任意删减、增加或歪曲，要完整地表达原文中的内容和观点。
二、文献引用文献引用是指在论文中援引他人已发表的相关文献，以支撑自己的观点和主张。
正确的文献引用是保证论文学术性的基础。
以下是对文献引用的一些建议：1. 选择合适的引用方式在选择引用方式时，可以根据引用的内容和篇幅来决定是否直接引用、间接引用还是引述。
直接引用是将他人的观点原封不动地引用过来，要使用引号并标注出处。
间接引用是在自己的观点中引用他人观点的大意，无需使用引号但必须标注出处。
引述是将他人的观点用自己的语言重新表达，并标注出处。
2. 准确标注引用来源在引用文献时，要准确标注引用来源的作者、标题、出版日期、页码等信息，并按照规范的引用格式进行排版。
常用的引用格式有APA、MLA、Chicago等，可以根据自己的学院或研究领域要求选择合适的引用格式。
3. 避免滥用他人观点在引用他人观点时要避免滥用，应确保引用的内容与自己的论点紧密相关，并正确解读和分析引用内容，避免引用内容脱离实际情况或被扭曲。
毕业设计论文外文文献翻译计算机科学与技术微软VisualStudio中英文对照
外文文献翻译（2012届）学生姓名学号********专业班级计算机科学与技术08-5班指导教师微软Visual Studio1微软Visual StudioVisual Studio 是微软公司推出的开发环境，Visual Studio可以用来创建Windows平台下的Windows应用程序和网络应用程序，也可以用来创建网络服务、智能设备应用程序和Office 插件。
Visual Studio是一个来自微软的集成开发环境IDE（inteqrated development environment），它可以用来开发由微软视窗，视窗手机，Windows CE、.NET框架、.NET精简框架和微软的Silverlight支持的控制台和图形用户界面的应用程序以及Windows窗体应用程序，网站，Web应用程序和网络服务中的本地代码连同托管代码。
Visual Studio包含一个由智能感知和代码重构支持的代码编辑器。
集成的调试工作既作为一个源代码级调试器又可以作为一台机器级调试器。
其他内置工具包括一个窗体设计的GUI应用程序，网页设计师，类设计师，数据库架构设计师。
它有几乎各个层面的插件增强功能，包括增加对支持源代码控制系统（如Subversion和Visual SourceSafe）并添加新的工具集设计和可视化编辑器，如特定于域的语言或用于其他方面的软件开发生命周期的工具（例如Team Foundation Server的客户端：团队资源管理器）。
Visual Studio支持不同的编程语言的服务方式的语言，它允许代码编辑器和调试器（在不同程度上）支持几乎所有的编程语言，提供了一个语言特定服务的存在。
内置的语言中包括C/C + +中（通过Visual C++）,（通过Visual ），C＃中（通过Visual C＃）和F＃（作为Visual Studio 2010），为支持其他语言，如M,Python,和Ruby等，可通过安装单独的语言服务。
毕业论文英文文献及翻译
英文原文 and the .NET Framework is part of Microsoft's overall .NET framework, which contains a vast set of programming classes designed to satisfy any conceivable programming need. In the following two sections, you learn how fits within the .NET framework, and you learn about the languages you can use in your pages.The .NET Framework Class LibraryImagine that you are Microsoft. Imagine that you have to support multiple programming languages—such as Visual Basic, JScript, and C++.A great deal of the functionality of these programming languages overlaps. For example, for each language, you would have to include methods for accessing the file system, working with databases, and manipulating strings.Furthermore, these languages contain similar programming constructs. Every language, for example, can represent loops and conditionals. Even though the syntax of a conditional written in Visual Basic differs from the syntax of a conditional written in C++, the programming function is the same.Finally, most programming languages have similar variable data types. In most languages, you have some means of representing strings and integers, for example. The maximum and minimum size of an integer might depend on the language, but the basic data type is the same.Maintaining all this functionality for multiple languages requires a lot of work. Why keep reinventing the wheel? Wouldn't it be easier to create all this functionality once and use it for every language?The .NET Framework Class Library does exactly that. It consists of a vast set of classes designed to satisfy any conceivable programming need. For example, the .NET framework contains classes for handling database access, working with the file system, manipulating text, and generating graphics. In addition, it contains more specialized classes for performing tasks such as working with regular expressions and handling network protocols.The .NET framework, furthermore, contains classes that represent all the basic variable data types such as strings, integers, bytes, characters, and arrays.Most importantly, for purposes of this book, the .NET Framework Class Library contains classes for building pages. You need to understand, however, that you can access any of the .NET framework classes when you are building your pages.Understanding NamespacesAs you might guess, the .NET framework is huge. It contains thousands of classes (over 3,400). Fortunately, the classes are not simply jumbled together. The classes of the .NET framework are organized into a hierarchy of namespaces.ASP Classic NoteIn previous versions of Active Server Pages, you had access to only five standard classes (the Response, Request, Session, Application, and Server objects). , in contrast, provides you with access to over 3,400 classes!A namespace is a logical grouping of classes. For example, all the classes that relate to working with the file system are gathered together into the System.IO namespace.The namespaces are organized into a hierarchy (a logical tree). At the root of the tree is the System namespace. This namespace contains all the classes for the base data types, such as strings and arrays. It also contains classes for working with random numbers and dates and times.You can uniquely identify any class in the .NET framework by using the full namespace of the class. For example, to uniquely refer to the class that represents a file system file (the File class), you would use the following:System.IO.FileSystem.IO refers to the namespace, and File refers to the particular class.NOTEYou can view all the namespaces of the standard classes in the .NET Framework Class Library by viewing the Reference Documentation for the .NET Framework.Standard NamespacesThe classes contained in a select number of namespaces are available in your pages by default. (You must explicitly import other namespaces.) These default namespaces contain classes that you use most often in your applications:System— Contains all the base data types and other useful classes such as those related to generating random numbers and working with dates and times.System.Collections— Contains classes for working with standard collection types such as hash tables, and array lists.System.Collections.Specialized— Contains classes that represent specialized collections such as linked lists and string collections.System.Configuration— Contains classes for working with configuration files (Web.config files).System.Text— Contains classes for encoding, decoding, and manipulating the contents of strings.System.Text.RegularExpressions— Contains classes for performing regular expression match and replace operations.System.Web— Contains the basic classes for working with the World Wide Web, including classes for representing browser requests and server responses.System.Web.Caching— Contains classes used for caching the content of pages and classes for performing custom caching operations.System.Web.Security— Contains classes for implementing authentication and authorization such as Forms and Passport authentication.System.Web.SessionState—Contains classes for implementing session state.System.Web.UI—Contains the basic classes used in building the user interface of pages.System.Web.UI.HTMLControls— Contains the classes for the HTML controls.System.Web.UI.WebControls— Contains the classes for the Web controls..NET Framework-Compatible LanguagesFor purposes of this book, you will write the application logic for your pages using Visual Basic as your programming language. It is the default language for pages (and the most popular programming language in the world). Although you stick to Visual Basic in this book, you also need to understand that you can create pages by using any language that supports the .NET Common Language Runtime. Out of the box, this includes C# (pronounced See Sharp), (the .NET version of JavaScript), and the Managed Extensions to C++.NOTEThe CD included with this book contains C# versions of all the code samples.Dozens of other languages created by companies other than Microsoft have been developed to work with the .NET framework. Some examples of these other languages include Python, SmallTalk, Eiffel, and COBOL. This means that you could, if you really wanted to, write pages using COBOL.Regardless of the language that you use to develop your pages, you need to understand that pages are compiled before they are executed. This means that pages can execute very quickly.The first time you request an page, the page is compiled into a .NET class, and the resulting class file is saved beneath a special directory on your server named Temporary Files. For each and every page, a corresponding class file appears in the Temporary Files directory. Whenever you request the same page in the future, the corresponding class file is executed.When an page is compiled, it is not compiled directly into machine code. Instead, it is compiled into an intermediate-level language called Microsoft Intermediate Language (MSIL). All .NET-compatible languages are compiled into this intermediate language.An page isn't compiled into native machine code until it is actually requested by a browser. At that point, the class file contained in the Temporary Files directory is compiled with the .NET framework Just in Time (JIT) compiler and executed.The magical aspect of this whole process is that it happens automatically in the background. All you have to do is create a text file with the source code for your page, and the .NET framework handles all the hard work of converting it into compiled code for you.ASP CLASSIC NOTEWhat about VBScript? Before , VBScript was the most popular language for developing Active Server Pages. does not support VBScript, and this is good news. Visual Basic is a superset of VBScript, which means that Visual Basic has all the functionality of VBScript and more. So, you have a richer set of functions and statements with Visual Basic.Furthermore, unlike VBScript, Visual Basic is a compiled language. This means that if you use Visual Basic to rewrite the same code that you wrote with VBScript, you can get better performance.If you have worked only with VBScript and not Visual Basic in the past, don't worry. Since VBScript is so closely related to Visual Basic, you'll find it easy to make the transition between the two languages.NOTE Microsoft includes an interesting tool named the IL Disassembler (ILDASM) with the .NET framework. You can use this tool to view the disassembled code for any of the classes in the Temporary Files directory. It lists all the methods and properties of the class and enables you to view the intermediate-level code.This tool also works with all the controls discussed in this chapter. For example, you can use the IL Disassembler to view the intermediate-level code for the TextBox control (located in a file named System.Web.dll).中文翻译 和 .NET Framework是微软.NET框架总体战略的一部分。
如何进行毕业论文的文献翻译工作
如何进行毕业论文的文献翻译工作毕业论文是完成学业的重要一步，而其中的文献翻译工作更是不可或缺的环节。
本文将为您介绍如何进行毕业论文的文献翻译工作。
一、准备工作在进行文献翻译之前，有几项准备工作是必要的。
首先，要对研究课题进行深入了解，明确自己要翻译的文献的背景和内容。
其次，要熟悉研究领域的专业术语和常用翻译技巧。
最后，准备好翻译所需的工具，如专业词典和翻译软件。
二、文献选择与筛选在进行文献翻译之前，需要对已有的文献进行选择与筛选。
首先，选择与自己研究课题相关的文献。
其次，对文献进行筛选，选择质量较高、内容较全面的文献进行翻译。
可以参考专业数据库、学术期刊和图书馆的资源。
三、翻译方法在进行文献翻译时，需要选择适当的翻译方法。
根据具体情况，可以采用直译、意译或译注等方法。
在保持原文意思的基础上，要注意修辞和语法的调整，使译文更符合目标语言的表达习惯。
同时，要注重翻译的准确性和一致性，避免出现歧义或理解偏差。
四、校对与修改在完成翻译后，务必进行校对与修改。
首先，对译文进行语法、拼写和标点等方面的检查，避免出现错误。
其次，对译文进行逐句对照原文的校对，确保译文与原文意思一致。
最后，对译文的流畅性和可读性进行考量，进行适当的修改和润色。
五、引用与署名在进行文献翻译时，必须严格遵守学术规范和版权法律。
如果引用了他人的翻译成果，要进行准确的引用和署名。
同时，要注意避免直接复制原文，确保译文的独立性和原创性。
六、文献翻译的注意事项在进行文献翻译时，还有一些注意事项需要牢记。
首先，要保持耐心和细致，避免翻译过程中的粗心和马虎。
其次，要善于利用各种翻译资源和工具，提高翻译效率和质量。
最后，要注重个人语言表达能力的培养，提升翻译水平和专业素养。
总结起来，进行毕业论文的文献翻译工作需要进行充分的准备，并选择适当的翻译方法。
在翻译过程中要注重准确性和一致性，并进行校对与修改。
同时，要遵守学术规范和版权法律，注意引用和署名。
毕业论文外文文献及翻译
毕业论文外文文献及翻译毕业论文外文文献及翻译在撰写毕业论文的过程中，外文文献的引用和翻译是不可或缺的一部分。
外文文献的引用可以增加论文的可信度和学术性，而翻译则是将外文文献的内容转化为母语读者所能理解的形式。
本文将探讨毕业论文中外文文献的引用和翻译的重要性，并提供一些建议和技巧。
首先，外文文献的引用对于毕业论文的写作至关重要。
引用外文文献可以为论文提供更多的证据和支持，增强论文的可信度。
在引用外文文献时，需要确保文献的来源可靠，作者权威，内容与论文主题相关。
此外，引用外文文献还可以展示作者对国际学术研究的关注和理解，提升论文的学术性。
然而，引用外文文献并不意味着直接复制粘贴原文内容。
在论文中，外文文献的内容需要进行翻译，以确保读者能够理解和接受。
翻译外文文献需要一定的技巧和方法。
首先，翻译者需要确保准确理解原文的意思。
对于一些专业术语和学术用语，可以通过查阅专业词典或咨询专业人士来获得准确的翻译。
其次，翻译时需要注意语言的准确性和流畅性。
翻译应该符合母语读者的语言习惯和表达方式，使得读者能够顺畅地理解文献内容。
最后，翻译后的文献内容应该与论文的整体风格和语言风格保持一致，避免出现突兀的翻译。
在引用外文文献和翻译时，研究者还应该注意一些细节。
首先，引用外文文献时需要标注出处和页码，以便读者查阅原文。
其次，在引用外文文献时可以使用引文的方式，即将原文内容放在引号中，并注明作者和出处。
这样可以明确区分原文和翻译内容，避免产生版权纠纷。
另外，翻译后的文献内容应该与论文的整体结构和逻辑相符，不应该脱离论文的主题和论证。
在进行外文文献的引用和翻译时，还可以借助一些工具和资源。
首先，可以使用文献管理软件来管理和引用外文文献。
这些软件可以帮助研究者整理和管理大量的文献资料，并自动生成引用格式。
其次，可以使用在线翻译工具来辅助翻译。
然而，需要注意的是，机器翻译并不完美，可能存在一些语义和语法错误。
因此，研究者在使用机器翻译时需要仔细校对和修正翻译结果。
毕业设计论文外文文献翻译
xxxx大学xxx学院毕业设计（论文）外文文献翻译系部xxxx专业xxxx学生姓名xxxx 学号xxxx指导教师xxxx 职称xxxx2013年3 月Introducing the Spring FrameworkThe Spring Framework: a popular open source application framework that addresses many of the issues outlined in this book. This chapter will introduce the basic ideas of Spring and dis-cuss the central “bean factory” lightweight Inversion-of-Control (IoC) container in detail.Spring makes it particularly easy to implement lightweight, yet extensible, J2EE archi-tectures. It provides an out-of-the-box implementation of the fundamental architectural building blocks we recommend. Spring provides a consistent way of structuring your applications, and provides numerous middle tier features that can make J2EE development significantly easier and more flexible than in traditional approaches.The basic motivations for Spring are:To address areas not well served by other frameworks. There are numerous good solutions to specific areas of J2EE infrastructure: web frameworks, persistence solutions, remoting tools, and so on. However, integrating these tools into a comprehensive architecture can involve significant effort, and can become a burden. Spring aims to provide an end-to-end solution, integrating spe-cialized frameworks into a coherent overall infrastructure. Spring also addresses some areas that other frameworks don’t. For example, few frameworks address generic transaction management, data access object implementation, and gluing all those things together into an application, while still allowing for best-of-breed choice in each area. Hence we term Spring an application framework, rather than a web framework, IoC or AOP framework, or even middle tier framework.To allow for easy adoption. A framework should be cleanly layered, allowing the use of indi-vidual features without imposing a whole worldview on the application. Many Spring features, such as the JDBC abstraction layer or Hibernate integration, can be used in a library style or as part of the Spring end-to-end solution.To deliver ease of use. As we’ve noted, J2EE out of the box is relatively hard to use to solve many common problems. A good infrastructure framework should make simple tasks simple to achieve, without forcing tradeoffs for future complex requirements (like distributed transactions) on the application developer. It should allow developers to leverage J2EE services such as JTA where appropriate, but to avoid dependence on them in cases when they are unnecessarily complex.To make it easier to apply best practices. Spring aims to reduce the cost of adhering to best practices such as programming to interfaces, rather than classes, almost to zero. However, it leaves the choice of architectural style to the developer.Non-invasiveness. Application objects should have minimal dependence on the framework. If leveraging a specific Spring feature, an object should depend only on that particular feature, whether by implementing a callback interface or using the framework as a class library. IoC and AOP are the key enabling technologies for avoiding framework dependence.Consistent configuration. A good infrastructure framework should keep application configuration flexible and consistent, avoiding the need for custom singletons and factories. A single style should be applicable to all configuration needs, from the middle tier to web controllers.Ease of testing. Testing either whole applications or individual application classes in unit tests should be as easy as possible. Replacing resources or application objects with mock objects should be straightforward.To allow for extensibility. Because Spring is itself based on interfaces, rather than classes, it is easy to extend or customize it. Many Spring components use strategy interfaces, allowing easy customization.A Layered Application FrameworkChapter 6 introduced the Spring Framework as a lightweight container, competing with IoC containers such as PicoContainer. While the Spring lightweight container for JavaBeans is a core concept, this is just the foundation for a solution for all middleware layers.Basic Building Blockspring is a full-featured application framework that can be leveraged at many levels. It consists of multi-ple sub-frameworks that are fairly independent but still integrate closely into a one-stop shop, if desired. The key areas are:Bean factory. The Spring lightweight IoC container, capable of configuring and wiring up Java-Beans and most plain Java objects, removing the need for custom singletons and ad hoc configura-tion. Various out-of-the-box implementations include an XML-based bean factory. The lightweight IoC container and its Dependency Injection capabilities will be the main focus of this chapter.Application context. A Spring application context extends the bean factory concept by adding support for message sources and resource loading, and providing hooks into existing environ-ments. Various out-of-the-box implementations include standalone application contexts and an XML-based web application context.AOP framework. The Spring AOP framework provides AOP support for method interception on any class managed by a Spring lightweight container.It supports easy proxying of beans in a bean factory, seamlessly weaving in interceptors and other advice at runtime. Chapter 8 dis-cusses the Spring AOP framework in detail. The main use of the Spring AOP framework is to provide declarative enterprise services for POJOs.Auto-proxying. Spring provides a higher level of abstraction over the AOP framework and low-level services, which offers similar ease-of-use to .NET within a J2EE context. In particular, the provision of declarative enterprise services can be driven by source-level metadata.Transaction management. Spring provides a generic transaction management infrastructure, with pluggable transaction strategies (such as JTA and JDBC) and various means for demarcat-ing transactions in applications. Chapter 9 discusses its rationale and the power and flexibility that it offers.DAO abstraction. Spring defines a set of generic data access exceptions that can be used for cre-ating generic DAO interfaces that throw meaningful exceptions independent of the underlying persistence mechanism. Chapter 10 illustrates the Spring support for DAOs in more detail, examining JDBC, JDO, and Hibernate as implementation strategies.JDBC support. Spring offers two levels of JDBC abstraction that significantly ease the effort of writing JDBC-based DAOs: the org.springframework.jdbc.core package (a template/callback approach) and the org.springframework.jdbc.object package (modeling RDBMS operations as reusable objects). Using the Spring JDBC packages can deliver much greater pro-ductivity and eliminate the potential for common errors such as leaked connections, compared with direct use of JDBC. The Spring JDBC abstraction integrates with the transaction and DAO abstractions.Integration with O/R mapping tools. Spring provides support classesfor O/R Mapping tools like Hibernate, JDO, and iBATIS Database Layer to simplify resource setup, acquisition, and release, and to integrate with the overall transaction and DAO abstractions. These integration packages allow applications to dispense with custom ThreadLocal sessions and native transac-tion handling, regardless of the underlying O/R mapping approach they work with.Web MVC framework. Spring provides a clean implementation of web MVC, consistent with the JavaBean configuration approach. The Spring web framework enables web controllers to be configured within an IoC container, eliminating the need to write any custom code to access business layer services. It provides a generic DispatcherServlet and out-of-the-box controller classes for command and form handling. Request-to-controller mapping, view resolution, locale resolution and other important services are all pluggable, making the framework highly extensi-ble. The web framework is designed to work not only with JSP, but with any view technology, such as Velocity—without the need for additional bridges. Chapter 13 discusses web tier design and the Spring web MVC framework in detail.Remoting support. Spring provides a thin abstraction layer for accessing remote services without hard-coded lookups, and for exposing Spring-managed application beans as remote services. Out-of-the-box support is inc luded for RMI, Caucho’s Hessian and Burlap web service protocols, and WSDL Web Services via JAX-RPC. Chapter 11 discusses lightweight remoting.While Spring addresses areas as diverse as transaction management and web MVC, it uses a consistent approach everywhere. Once you have learned the basic configuration style, you will be able to apply it in many areas. Resources, middle tier objects, and web components are all set up using the same bean configuration mechanism. You can combine your entireconfiguration in one single bean definition file or split it by application modules or layers; the choice is up to you as the application developer. There is no need for diverse configuration files in a variety of formats, spread out across the application.Spring on J2EEAlthough many parts of Spring can be used in any kind of Java environment, it is primarily a J2EE application framework. For example, there are convenience classes for linking JNDI resources into a bean factory, such as JDBC DataSources and EJBs, and integration with JTA for distributed transaction management. In most cases, application objects do not need to work with J2EE APIs directly, improving reusability and meaning that there is no need to write verbose, hard-to-test, JNDI lookups.Thus Spring allows application code to seamlessly integrate into a J2EE environment without being unnecessarily tied to it. You can build upon J2EE services where it makes sense for your application, and choose lighter-weight solutions if there are no complex requirements. For example, you need to use JTA as transaction strategy only if you face distributed transaction requirements. For a single database, there are alternative strategies that do not depend on a J2EE container. Switching between those transac-tion strategies is merely a matter of configuration; Spring’s consistent abstraction avoids any need to change application code.Spring offers support for accessing EJBs. This is an important feature (and relevant even in a book on “J2EE without EJB”) because the u se of dynamic proxies as codeless client-side business delegates means that Spring can make using a local stateless session EJB an implementation-level, rather than a fundamen-tal architectural, choice.Thus if you want to use EJB, you can within a consistent architecture; however, you do not need to make EJB the cornerstone of your architecture. This Spring feature can make devel-oping EJB applications significantly faster, because there is no need to write custom code in service loca-tors or business delegates. Testing EJB client code is also much easier, because it only depends on the EJB’s Business Methods interface (which is not EJB-specific), not on JNDI or the EJB API.Spring also provides support for implementing EJBs, in the form of convenience superclasses for EJB implementation classes, which load a Spring lightweight container based on an environment variable specified in the ejb-jar.xml deployment descriptor. This is a powerful and convenient way of imple-menting SLSBs or MDBs that are facades for fine-grained POJOs: a best practice if you do choose to implement an EJB application. Using this Spring feature does not conflict with EJB in any way—it merely simplifies following good practice.Introducing the Spring FrameworkThe main aim of Spring is to make J2EE easier to use and promote good programming practice. It does not reinvent the wheel; thus you’ll find no logging packages in Spring, no connection pools, no distributed transaction coordinator. All these features are provided by other open source projects—such as Jakarta Commons Logging (which Spring uses for all its log output), Jakarta Commons DBCP (which can be used as local DataSource), and ObjectWeb JOTM (which can be used as transaction manager)—or by your J2EE application server. For the same reason, Spring doesn’t provide an O/R mapping layer: There are good solutions for this problem area, such as Hibernate and JDO.Spring does aim to make existing technologies easier to use. For example, although Spring is not in the business of low-level transactioncoordination, it does provide an abstraction layer over JTA or any other transaction strategy. Spring is also popular as middle tier infrastructure for Hibernate, because it provides solutions to many common issues like SessionFactory setup, ThreadLocal sessions, and exception handling. With the Spring HibernateTemplate class, implementation methods of Hibernate DAOs can be reduced to one-liners while properly participating in transactions.The Spring Framework does not aim to replace J2EE middle tier services as a whole. It is an application framework that makes accessing low-level J2EE container ser-vices easier. Furthermore, it offers lightweight alternatives for certain J2EE services in some scenarios, such as a JDBC-based transaction strategy instead of JTA when just working with a single database. Essentially, Spring enables you to write appli-cations that scale down as well as up.Spring for Web ApplicationsA typical usage of Spring in a J2EE environment is to serve as backbone for the logical middle tier of a J2EE web application. Spring provides a web application context concept, a powerful lightweight IoC container that seamlessly adapts to a web environment: It can be accessed from any kind of web tier, whether Struts, WebWork, Tapestry, JSF, Spring web MVC, or a custom solution.The following code shows a typical example of such a web application context. In a typical Spring web app, an applicationContext.xml file will reside in the WEB-INF directory, containing bean defini-tions according to the “spring-beans” DTD. In such a bean definition XML file, business objects and resources are defined, for example, a “myDataSource” bean, a “myInventoryManager” bean, and a “myProductManager” bean. Spring takes care of their configuration, their wiring up, and their lifecycle.<beans><bean id=”myDataSource” class=”org.springframework.jdbc. datasource.DriverManagerDataSource”><property name=”driverClassName”> <value>com.mysql.jdbc.Driver</value></property> <property name=”url”><value>jdbc:mysql:myds</value></property></bean><bean id=”myInventoryManager” class=”ebusiness.DefaultInventoryManager”> <property name=”dataSource”><ref bean=”myDataSource”/> </property></bean><bean id=”myProductManager” class=”ebusiness.DefaultProductManage r”><property name=”inventoryManager”><ref bean=”myInventoryManager”/> </property><property name=”retrieveCurrentStock”> <value>true</value></property></bean></beans>By default, all such beans have “singleton” scope: one instance per context. The “myInventoryManager” bean will automatically be wired up with the defined DataSource, while “myProductManager” will in turn receive a reference to the “myInventoryManager” bean. Those objects (traditionally called “beans” in Spring terminology) need to expos e only the corresponding bean properties or constructor arguments (as you’ll see later in this chapter); they do not have to perform any custom lookups.A root web application context will be loaded by a ContextLoaderListener that is defined in web.xml as follows:<web-app><listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>...</web-app>After initialization of the web app, the root web application context will be available as a ServletContext attribute to the whole web application, in the usual manner. It can be retrieved from there easily via fetching the corresponding attribute, or via a convenience method in org.springframework.web. context.support.WebApplicationContextUtils. This means that the application context will be available in any web resource with access to the ServletContext, like a Servlet, Filter, JSP, or Struts Action, as follows:WebApplicationContext wac = WebApplicationContextUtils.getWebApplicationContext(servletContext);The Spring web MVC framework allows web controllers to be defined as JavaBeans in child application contexts, one per dispatcher servlet. Such controllers can express dependencies on beans in the root application context via simple bean references. Therefore, typical Spring web MVC applications never need to perform a manual lookup of an application context or bean factory, or do any other form of lookup.Neither do other client objects that are managed by an application context themselves: They can receive collaborating objects as bean references.The Core Bean FactoryIn the previous section, we have seen a typical usage of the Spring IoC container in a web environment: The provided convenience classes allow for seamless integration without having to worry about low-level container details. Nevertheless, it does help to look at the inner workings to understand how Spring manages the container. Therefore, we will now look at the Spring bean container in more detail, starting at the lowest building block: the bean factory. Later, we’ll continue with resource setup and details on the application context concept.One of the main incentives for a lightweight container is to dispense with the multitude of custom facto-ries and singletons often found in J2EE applications. The Spring bean factory provides one consistent way to set up any number of application objects, whether coarse-grained components or fine-grained busi-ness objects. Applying reflection and Dependency Injection, the bean factory can host components that do not need to be aware of Spring at all. Hence we call Spring a non-invasive application framework.Fundamental InterfacesThe fundamental lightweight container interface is org.springframework.beans.factory.Bean Factory. This is a simple interface, which is easy to implement directly in the unlikely case that none of the implementations provided with Spring suffices. The BeanFactory interface offers two getBean() methods for looking up bean instances by String name, with the option to check for a required type (and throw an exception if there is a type mismatch).public interface BeanFactory {Object getBean(String name) throws BeansException;Object getBean(String name, Class requiredType) throws BeansException;boolean containsBean(String name);boolean isSingleton(String name) throws NoSuchBeanDefinitionException;String[] getAliases(String name) throws NoSuchBeanDefinitionException;}The isSingleton() method allows calling code to check whether the specified name represents a sin-gleton or prototype bean definition. In the case of a singleton bean, all calls to the getBean() method will return the same object instance. In the case of a prototype bean, each call to getBean() returns an inde-pendent object instance, configured identically.The getAliases() method will return alias names defined for the given bean name, if any. This mecha-nism is used to provide more descriptive alternative names for beans than are permitted in certain bean factory storage representations, such as XML id attributes.The methods in most BeanFactory implementations are aware of a hierarchy that the implementation may be part of. If a bean is not foundin the current factory, the parent factory will be asked, up until the root factory. From the point of view of a caller, all factories in such a hierarchy will appear to be merged into one. Bean definitions in ancestor contexts are visible to descendant contexts, but not the reverse.All exceptions thrown by the BeanFactory interface and sub-interfaces extend org.springframework. beans.BeansException, and are unchecked. This reflects the fact that low-level configuration prob-lems are not usually recoverable: Hence, application developers can choose to write code to recover from such failures if they wish to, but should not be forced to write code in the majority of cases where config-uration failure is fatal.Most implementations of the BeanFactory interface do not merely provide a registry of objects by name; they provide rich support for configuring those objects using IoC. For example, they manage dependen-cies between managed objects, as well as simple properties. In the next section, we’ll look at how such configuration can be expressed in a simple and intuitive XML structure.The sub-interface org.springframework.beans.factory.ListableBeanFactory supports listing beans in a factory. It provides methods to retrieve the number of beans defined, the names of all beans, and the names of beans that are instances of a given type:public interface ListableBeanFactory extends BeanFactory {int getBeanDefinitionCount();String[] getBeanDefinitionNames();String[] getBeanDefinitionNames(Class type);boolean containsBeanDefinition(String name);Map getBeansOfType(Class type, boolean includePrototypes,boolean includeFactoryBeans) throws BeansException}The ability to obtain such information about the objects managed by a ListableBeanFactory can be used to implement objects that work with a set of other objects known only at runtime.In contrast to the BeanFactory interface, the methods in ListableBeanFactory apply to the current factory instance and do not take account of a hierarchy that the factory may be part of. The org.spring framework.beans.factory.BeanFactoryUtils class provides analogous methods that traverse an entire factory hierarchy.There are various ways to leverage a Spring bean factory, ranging from simple bean configuration to J2EE resource integration and AOP proxy generation. The bean factory is the central, consistent way of setting up any kind of application objects in Spring, whether DAOs, business objects, or web controllers. Note that application objects seldom need to work with the BeanFactory interface directly, but are usu-ally configured and wired by a factory without the need for any Spring-specific code.For standalone usage, the Spring distribution provides a tiny spring-core.jar file that can be embed-ded in any kind of application. Its only third-party dependency beyond J2SE 1.3 (plus JAXP for XML parsing) is the Jakarta Commons Logging API.The bean factory is the core of Spring and the foundation for many other services that the framework offers. Nevertheless, the bean factory can easily be used stan-dalone if no other Spring services are required.Derivative：networkSpring 框架简介Spring框架：这是一个流行的开源应用框架，它可以解决很多问题。
计算机科学与技术Java垃圾收集器中英文对照外文翻译文献
中英文资料中英文资料外文翻译文献原文：How a garbage collector works of Java LanguageIf you come from a programming language where allocating objects on the heap is expensive, you may naturally assume that Java’s scheme of allocating everything (except primitives) on the heap is also expensive. However, it turns out that the garbage collector can have a significant impact on increasing the speed of object creation. This might sound a bit odd at first—that storage release affects storage allocation—but it’s the way some JVMs work, and it means that allocating storage for heap objects in Java can be nearly as fast as creating storage on the stack in other languages.For example, you can think of the C++ heap as a yard where each stakes out its own piece of turf object. This real estate can become abandoned sometime later and must be reused. In some JVMs, the Java heap is quite different; it’s more like a conveyor belt that moves forwardevery time you allocate a new object. This means that object storage allocation is remarkab ly rapid. The “heap pointer” is simply moved forward into virgin territory, so it’s effectively the same as C++’s stack allocation. (Of course, there’s a little extra overhead for bookkeeping, but it’s nothing like searching for storage.)You might observ e that the heap isn’t in fact a conveyor belt, and if you treat it that way, you’ll start paging memory—moving it on and off disk, so that you can appear to have more memory than you actually do. Paging significantly impacts performance. Eventually, after you create enough objects, you’ll run out of memory. The trick is that the garbage collector steps in, and while it collects the garbage it compacts all the objects in the heap so that you’ve effectively moved the “heap pointer” closer to the beginning of the conveyor belt and farther away from a page fault. The garbage collector rearranges things and makes it possible for the high-speed, infinite-free-heap model to be used while allocating storage.To understand garbage collection in Java, it’s helpful le arn how garbage-collection schemes work in other systems. A simple but slow garbage-collection technique is called reference counting. This means that each object contains a reference counter, and every time a reference is attached to that object, the reference count is increased. Every time a reference goes out of scope or is set to null, the reference count isdecreased. Thus, managing reference counts is a small but constant overhead that happens throughout the lifetime of your program. The garbage collector moves through the entire list of objects, and when it finds one with a reference count of zero it releases that storage (however, reference counting schemes often release an object as soon as the count goes to zero). The one drawback is that if objects circularly refer to each other they can have nonzero reference counts while still being garbage. Locating such self-referential groups requires significant extra work for the garbage collector. Reference counting is commonly used to explain one kind of g arbage collection, but it doesn’t seem to be used in any JVM implementations.In faster schemes, garbage collection is not based on reference counting. Instead, it is based on the idea that any non-dead object must ultimately be traceable back to a reference that lives either on the stack or in static storage. The chain might go through several layers of objects. Thus, if you start in the stack and in the static storage area and walk through all the references, you’ll find all the live objects. For each reference that you find, you must trace into the object that it points to and then follow all the references in that object, tracing into the objects they point to, etc., until you’ve moved through the entire Web that originated with the reference on the stack or in static storage. Each object that you move through must still be alive. Note that there is no problem withdetached self-referential groups—these are simply not found, and are therefore automatically garbage.In the approach described here, the JVM uses an adaptive garbage-collection scheme, and what it does with the live objects that it locates depends on the variant currently being used. One of these variants is stop-and-copy. This means that—for reasons that will become apparent—the program is first stopped (this is not a background collection scheme). Then, each live object is copied from one heap to another, leaving behind all the garbage. In addition, as the objects are copied into the new heap, they are packed end-to-end, thus compacting the new heap (and allowing new storage to simply be reeled off the end as previously described).Of course, when an object is moved from one place to another, all references that point at the object must be changed. The reference that goes from the heap or the static storage area to the object can be changed right away, but there can be other references pointing to this object Initialization & Cleanup that will be encountered later during the “walk.” These are fixed up as they are found (you could imagine a table that maps old addresses to new ones).There are two issues that make these so-called “copy collectors” inefficient. The first is the idea that you have two heaps and you slosh all the memory back and forth between these two separate heaps,maintaining twice as much memory as you actually need. Some JVMs deal with this by allocating the heap in chunks as needed and simply copying from one chunk to another.The second issue is the copying process itself. Once your program becomes stable, it might be generating little or no garbage. Despite that, a copy collector will still copy all the memory from one place to another, which is wasteful. To prevent this, some JVMs detect that no new garbage is being generated and switch to a different scheme (this is the “adaptive” part). This other scheme is called mark-and-sweep, and it’s what earlier versions of Sun’s JVM used all the time. For general use, mark-and-sweep is fairly slow, but when you know you’re generating little or no garbage, it’s fast. Mark-and-sweep follows the same logic of starting from the stack and static storage, and tracing through all the references to find live objects.However, each time it finds a live object, that object is marked by setting a flag in it, but the object isn’t collected yet.Only when the marking process is finished does the sweep occur. During the sweep, the dead objects are released. However, no copying happens, so if the collector chooses to compact a fragmented heap, it does so by shuffling objects around. “Stop-and-copy”refers to the idea that this type of garbage collection is not done in the background; Instead, the program is stopped while the garbage collection occurs. In the Sun literature you’llfind many references to garbage collection as a low-priority background process, but it turns out that the garbage collection was not implemented that way in earlier versions of the Sun JVM. Instead, the Sun garbage collector stopped the program when memory got low. Mark-and-sweep also requires that the program be stopped.As previously mentioned, in the JVM described here memory is allocated in big blocks. If you allocate a large object, it gets its own block. Strict stop-and-copy requires copying every live object from the source heap to a new heap before you can free the old one, which translates to lots of memory. With blocks, the garbage collection can typically copy objects to dead blocks as it collects. Each block has a generation count to keep track of whether it’s alive. In the normal case, only the blocks created since the last garbage collection are compacted; all other blocks get their generation count bumped if they have been referenced from somewhere. This handles the normal case of lots of short-lived temporary objects. Periodically, a full sweep is made—large objects are still not copied (they just get their generation count bumped), and blocks containing small objects are copied and compacted.The JVM monitors the efficiency of garbage collection and if it becomes a waste of time because all objects are long-lived, then it switches to mark-and sweep. Similarly, the JVM keeps track of how successful mark-and-sweep is, and if the heap starts to becomefragmented, it switches back to stop-and-copy. This is where the “adaptive” part comes in, so you end up with a mouthful: “Adaptive generational stop-and-copy mark-and sweep.”There are a number of additional speedups possible in a JVM. An especially important one involves the operation of the loader and what is called a just-in-time (JIT) compiler. A JIT compiler partially or fully converts a program into native machine code so that it doesn’t need to be interpreted by the JVM and thus runs much faster. When a class must be loaded (typically, the first time you want to create an object of that class), the .class file is located, and the byte codes for that class are brought into memory. At this point, one approach is to simply JIT compile all the code, but this has two drawbacks: It takes a little more time, which, compounded throughout the life of the program, can add up; and it increases the size of the executable (byte codes are significantly more compact than expanded JIT code), and this might cause paging, which definitely slows down a program. An alternative approach is lazy evaluation, which means that the code is not JIT compiled until necessary. Thus, code that never gets executed might never be JIT compiled. The Java Hotspot technologies in recent JDKs take a similar approach by increasingly optimizing a piece of code each time it is executed, so the more the code is executed, the faster it gets.译文：Java垃圾收集器的工作方式如果你学下过一种因为在堆里分配对象所以开销过大的编程语言，很自然你可能会假定Java 在堆里为每一样东西（除了primitives）分配内存资源的机制开销也会很大。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录1 外文文献译文1 ...................................................................... 错误！未定义书签。
2 外文文献原文1 (5)3 外文文献译文2 (9)4 外文文献原文2 (12)1 外文文献译文1Access2000关系型数据库在Office的家族成员当中，人们最初对于Access2000的了解，往往只是局限在它的操作界面中，对于数据库的管理功能仍然只是停留在建立数据表、数据的输入、使用窗体向导、使用报表向导、数据访问的向导等一些相对比较简单的应用上面。
其实Access2000的功能非常强大，而且超乎你的想象。
它是微软自发布Access以来功能最全面、与Windows和Internet结合最密切的数据库软件，是一个功能非常强大，且简单易用的数据库管理系统（DBMS），就是对数据库进行存储、管理和处理的系统。
Access2000数据库管理系统是Microsoft公司的Office办公自动化软件的一个组成部分。
它可以有效地组织、管理和共享数据库的信息，并且将数据库的信息与Web结合在一起，并通过Internet共享数据信息提供了基础的平台。
伴随着信息技术的发展，信息技术平台的选择往往是建立或者是重新建立应用系统的重要问题，而数据库正是它们要做出选择的关键平台。
Access2000是一种关系型数据库管理系统，是中小型企业管理系统的最理想的开发环境，在当前的数据库领域，已经有越来越多的人在使用。
它是一个功能非常强大的数据库管理系统的MIS系统开发工具。
数据库是存储在一起的相关数据的集合，这些数据是结构化的，数据库是一种用来存储数据并且对数据进行管理的工具。
数据库的作用就在于组织和表达信息，简单来说，数据库就是不同信息的集合。
计算机的数据库可以分为两大类：非关系型的数据库（flat-file）和关系型的数据库（relational）。
关系型的数据库中包含了多个数据表的信息，数据库含有各个不同部分的术语，像记录等。
关系型的数据库管理系统曾经处于技术主流而且独领风骚，但是这种传统的数据库管理系统因为采用了两维的数据模型，而且存在着本身固有的约束和限制。
难以适应现在迅速变化的业务需求，以及新技术的发展。
信息技术的飞速发展，数据处理不仅在数量上需要越来越大，而且在质量上也要求越来越高，数据库所管理的数据已经发生了根本上的变化。
这样一个变化给数据库技术带来了巨大的挑战，数据库管理的对象已经不再局限于文本数据等一些简单的数据类型，而是需要描述和保存大量多媒体非结构化的复杂数据，以及数据之间的关系。
另外，随着热门网站访问数量的逐渐增加，对数据库本身的存储机制、大量并发用户的使用需求、存储空间的使用效率、以及数据的完整性和安全性等方面都提出了更高的要求。
而这些都不是传统关系数据库中，用二维表简单结构就可以满足需要的。
Access2000 就是关系型的数据库开发工具，数据库能够汇集各种信息以供查询、存储和检索。
Access2000 的优点在于它能使用数据表示图或自定义窗体来收集信息。
数据表示图提供了一种类似于Excel 的电子表格，可以使数据一目了然。
而且，Access2000允许创建自定义的报表用于打印或者是输出数据库中的信息。
Access2000也提供了数据储存库，可以使用桌面数据库文件把数据库文件置于网络文件服务器中，与其他网络用户共享数据库。
Access2000 是一种关系型的数据库工具，关系数据库是已经开发的最常用的数据库之一。
综上所述，Access2000作为关系型的数据库开发具备了很多优点，可以在一个数据包中同时拥有桌面数据库的便利和关系型的数据库的强大功能。
在Access2000中，用户具有的数据库访问权限有两种类型：显式权限和隐式权限。
显式权限是指直接赋予某一用户账号的权限，这是该用户账号专用的，与其他用户无关。
隐式权限是指授予组账号的权限，即用户加入到该组中的同时被赋予的组的权限。
假如一个用户同时具有上面两种权限，当该用户对设置了安全性的数据库进行访问时，那么，他所具有的权限就是两种权限的交集。
在Access数据库中，对组和用户访问数据库权限的设置工作，只能通过管理员来完成。
设置的权限包括：“打开/运行”，读取设计、修改设计、管理、读取数据，更新数据、插入数据和删除数据。
关系型数据库管理系统本身固有的局限性，表现在以下三个方面：关系数据库所采用的两维表数据模型，不能有效地处理在大多数事务处理应用中，典型存在的多维数据。
其不可避免的结果是，在复杂方式下，相互作用表的数量激增，而且还不能很好地提供模拟现实数据关系的模型。
关系型的数据库由于它所用数据模型比较多，还可能会造成存储空间的海量增加和大量的浪费，并且还会导致系统的响应性能不断的下降。
并且，在现实数据中，有许多类型是关系型的数据库不能较好地处理的。
伪静态的应用例如报表的生成，而设计的关系型数据库管理系统，并没有经过针对高效事务处理而进行的优化过程。
其结果通常是某些关系型数据库产品，在对GUI和Web的事务处理过程中，没有达到预期的效果。
除非增加更多的硬件投资，但这不能从根本上解决问题。
用关系型的数据库的两维表数据模型，可以处理在大多数事务处理应用中的典型多维数据，但它的结果通常是建立和使用大量的数据表格，仍然很难建立起能够模拟现实世界的数据模型。
并且在数据需要作报表输出的时候，又要反过来将已经分散设置的大量的两维数据表，再利用索引的技术进行表的连接后，才能找到我们所需要的数据，而这又将会影响到应用系统的响应速度。
关系型的数据库在目前是各类数据库中最重要、最流行的数据库。
关系型的数据库系统支持关系模型的数据库系统，关系模型由关系数据结构、关系操作集合和完整性约束三部分组成。
Access2000是Office2000中文版的组件之一。
与以前的Access版本相比，Access2000不仅界面更加友好，而且功能也有了加强，尤其是网络功能有明显的提高，使Access2000与互联网的结合更加密切。
Access2000是一个中、小型数据库管理系统，使用非常方便、功能非常强大，与其它的数据库有良好的接口。
通过Access2000功能强大的工具，用户可以方便的使用和管理数据库，如创建和编辑数据表、设计和使用各种查询工具进行查询操作、设计和使用窗体、制作和打印报表、设计和使用宏设计和使用Web页等。
还可使用Visual Basic6.0A（Visual Basic6.0 for Application）开发高级应用程序。
Access2000具有完整的数据库应用开发工具，用户可以方便的设计、修改、浏览一条记录数据的基本表；可以在表数据中进行各种筛选和查询操作；可以设计和使用各种窗体以实现数据显示和操作；可以根据表数据设计打印各种报表；可以设计和使用宏，对表进行一系列特定的操作。
Access2000内有强大的操作向导，为用户提供了丰富的数据库基本表模板。
用户只需要简单的操作就可建立数据库中所使用的各种基本表、窗体和报表。
在Access2000中，可以设定、修改基本表之间的关联，从而实现在多个相关表之间的关系查询。
Access2000中的宏可以实现操作的自动化，使操作更加简单、快捷。
Access2000增强了网络功能，用户可以轻松自如地完成网页发布等。
Access2000不仅可以处理自身的数据库文件，还可以处理其它一些数据库系统管理软件所建立的数据库文件，能识别Base、FoxBASE、FoxPro、Paradox等数据库格式文件，并且支持开放式数据库互连性标准（ODBC）的SQL。
Access2000能与工作站、数据库服务器或主机上的各种数据库互相连接，并可用于建立客户/服务器应用程序中的工作站部分。
与其它的关系型数据库管理系统相比，Access2000具有以下优点：存储文件单一。
Access2000的一个数据库文件中包含了该数据库中的全部数据表、查询、窗体、报表等所有数据，易于管理。
支持长文件名，并且可以在文件名里面加空格，使文件便于理解、查找。
具有强大的网络功能，可以通过网络来传送数据。
使用简单，用户无需要了解编程语言，就可以轻松地设计和开发数据库应用程序。
还可以处理多种数据信息，比如文本文件和其它数据库文件。
2 外文文献原文1Access2000 Relational DatabaseMembers of the Office family, the people of Access2000 understanding, often limited in its interface, for the database management function is still at the establishment table, data entry, Use Form guide Reporting Wizard, Data Access2000Page Wizard and other simple applications. In fact, the functions of the Access2000 is a powerful and beyond your imagination. It is released from Microsoft Access2000functions since most comprehensive, Windows and the Internet more closely with the database software, is a very powerful, and simple, easy-to-use database management system (DBMS) that the database storage, processing and management system. Access2000 relational database management system is Microsoft Office Public automation software as an integral part. It can effectively organize, manage and share the information in the database, and database information with the Web together. Through the Internet to share database information with the basic platform. With the development of information technology. Information technology platform is often the choice of establishing or re-establishing applications of the key issues, the database is part of the need to make a choice as a key platform.Access2000 as a relational database management system small and medium- sized information management system ideal development environment, the current database in the field, there are more and more people use. It is a powerful database management system MIS development tools.The database is stored together a collection of relevant data, the data is structured. The database is a data storage and data operation of the tool. The role of the database is to organize and present information, in short, the database is a collection of information. Computer database can be divided into two categories: non-relational database (flat-) and relational database (relational).Relational database contains a number of data tables, databases containing various parts of the terminology, like records. Relational database management system has the technological dominance of the mainstream, but this traditional database management systems by using two-dimensional data model, and there are inherent limitations and restrictions. It difficult to adapt to today's rapidly changing business needs, and the development of new technologies.With the rapid IT development, data processing, not only in quantity increasingly demanding, but also the quality of increasingly high demand, database management data has been a fundamental change. This change to the database technology has brought tremendous challenges, Object database management is no longer limited to text data and other simple data types. And the description and the need to preserve a lot of complex unstructured multimedia data, and the relationship between the data. Furthermore, in the wake of popular websites surge in the number of visits to its own database storage mechanism, a large number of concurrent users to the demand, storage efficiency in the use of space, and data integrity and security, and other aspects of higher demand. These are not traditional relational database, the use of a simple two-dimensional table structure of the meet.Access2000 is the relational database development tools, database pooling information for the inquiry, Storage and retrieval. Access2000 the advantage lies in its ability to use data map or custom windows to collect information. Data provides a map similar to the Excel spreadsheet, database transparent. In addition, the Access2000 allows creation of custom statements to print or export the information in the database.Access2000 also provides a data repository. Can use desktop database file to extend the database file at the network file server and other network users to share databases? Access2000 is a relational database tools, database development, is the most common databases. As noted above, as an Access2000 database development possesses many advantages, in a data packet available at the same time facilitate the desktop database and a powerful relational database functions.In Access2000, with the user database access permissions are two types: Explicit and implicit powers authority. Explicit authority is granted a direct user account competence, which is the exclusive use of user accounts, has nothing to do with other users. Implicit authority is delegated the authority group account, the user added to the group was given by the group's mandate. If a user with the same time these two powers, the right set of user security database for a visit, then He had such authority is the intersection of the two powers. The Access20002000database, the group of users’access to the database and the authority set up work, completed only through the administrator. Set up the authority include: "Open/Run", read design, design modifications, management, read data, update data insertion and deletion of data.Relational database management system inherent limitations in the following three aspects:Relational database used in the two-dimensional table data model, can not effectively handle the majority of business applications, Typical of multidimensional data. Its inevitable result is that in complex ways, the interaction of the dramatic increase in the number of tables, not very good but also to provide realistic simulation of the data model.Relational database as they use more data model, which might lead to a massive storage space and wasting a lot of increase, and cause the system to respond to the declining performance. Furthermore, the data in reality, there are many types of relational database is not well addressed.Static applications such as report generation, and the design of the relational database management system after no response and efficient business processing for the optimization process. The result is often some relational database products, in the GUI and Web Services processing, not achieved the desired results. Unless additional hardware investment, but it does not resolve the fundamental problem.Relations with the two-dimensional database table data model can deal with the majority of business application of a typical multi- dimensional data, but the results are often the establishment and use of a large amount of data forms, it is difficult to establish a simulation of real-world data model. And the need for data output statements when they, in turn, would have dispersed the large number of two-dimensional data tables. Reuse indexing technology linking the table in order to find all the necessary data, this, in turn, is bound to affect the use of the response speed. Database various databases is currently the most important and the most popular database.Relational database system to support the relational model of database systems, relationships between data model structure, relations operation and integrity constraint set is composed of three parts.Office Access2000 is the Chinese version of one of the components. Access2000 to the previous version, the Access2000 is not only a more friendly interface, but their functions have also been strengthened, especially network function was improved, Internet Access2000 so that it more closely connected.Access2000 is a small and medium-sized database management system, easy to use, powerful, and other databases have a good interface.Access2000 through powerful tool, users can facilitate the use and management of databases, such as the creation and editing of data tables, design and the use of various tools inquiries queryoperation, design and the use of windows, production and printing statements, the design and use of Acer, the design and use of such Web pages. May also be used in Visual Basic6.0A(Visual Basic6.0 for Application)Advanced Application Development procedures.Access2000 is a complete database application development tool, the user can design, modify, View a record of the basic data table; in the table data for various screen and query operation; design and use of Window to achieve data and operations; Data tables can design various print statements; design and use of Acer, a series of tables for specific operations.Access2000 with a strong operational guide, and to provide users with a rich database table basic template. Users only need a simple database operations can be established by using the basic form, Form and statements.In Access2000, can be set, to alter the basic correlation between the tables, thus achieving a number of related tables in the relationship between the inquiries. Access2000-The operation can achieve automation, the operator is more simple and efficient. Access2000 to enhance the network function, users can complete the ease of web publication.Access2000 can not only deal with their own database files. Could also address some other database management software system established by the database files, the ability to distinguish Base. FoxBASE, FoxPro, Paradox, database formats, such as documents, and support the open database connectivity standard (ODBC) SQL. Access2000 with workstations, servers or databases on the mainframe database interconnected and can be used for building client/server applications of the workstation. And other relational database management systems, Access2000 have the following advantages: Storage single document.Access2000 of a database file contains the database of all data tables, query, windows, all statements, and other data manageable.Support for long file names and file name can be added to the blank, documents easily comprehensible search.Powerful network function can be transmitted through the network data.Easy to use, you do not need to understand the programming language can easily design and development of database applications.Can handle a variety of data and information, such as text files and other databases of documents.3 外文文献译文21.ASP的起源对于ASP模式和ASP企业起源的研究，我们可以从两个方面入手，第一个是从技术和业务的角度分析，主要是从ASP业务构成的发展历史来进行研究；另一个是从ASP企业起源的组织机构发展的角度分析，从而来研究目前ASP企业的由来、发展和演化的一个过程。