Java (programming language)
From Wikipedia, the free encyclopedia
Java is a programming language originally developed by James Gosling at Sun Microsystems (which has since merged into Oracle Corporation) and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities. Java applications are typically compiled to bytecode (class file) that can run on any Java Virtual Machine (JVM) regardless of computer architecture. Java is a general-purpose,concurrent, class-based, object-oriented language that is specifically designed to have as few implementation dependencies as possible. It is intended to let application developers "write once, run anywhere," meaning that code that runs on one platform does not need to be edited to run on another. Java is currently one of the most popular programming languages in use, particularly for client-server web applications, with a reported 10 million users.[10][11] The original and reference implementation Java compilers, virtual machines, and class libraries were developed by Sun from 1995. As of May 2007, in compliance with the specifications of the Java Community Process, Sun relicensed most of its Java technologies under the GNU General Public License. Others have also developed alternative implementations of these Sun technologies, such as the GNU Compiler for Java and GNU Classpath.
Contents
1 History
1.1 Principles
1.2 Versions
2 Practices
2.1 Java platform
2.1.1 Implementations
2.1.2 Performance
2.2 Automatic memory management
History
See also: Java (software platform)#History
James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in June 1991.[12] Java was originally designed for interactive television, but it was too advanced for the digital cable television industry at the time.[13] The language was initially called Oak after an oak tree that stood outside Gosling's office; it went by the name Green later, and was later renamed Java, from Java coffee, said to be consumed in large quantities by the language's creators.[14] Gosling aimed to implement a virtual machine and a language that had a familiar C/C++ style of notation.[15]
Sun Microsystems released the first public implementation as Java 1.0 in 1995. It promised "Write Once, Run Anywhere" (WORA), providing no-cost run-times
on popular platforms. Fairly secure and featuring configurable security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run Java applets within web pages, and Java quickly became popular. With the advent of Java 2 (released initially as J2SE 1.2 in December 1998–1999), new versions had multiple configurations built for different types of platforms. For example, J2EE targeted enterprise applications and the greatly stripped-down version J2ME for mobile applications (Mobile Java). J2SE designated the Standard Edition. In 2006, for marketing purposes, Sun renamed new J2 versions as Java EE, Java ME, and Java SE, respectively.
In 1997, Sun Microsystems approached the ISO/IEC JTC1 standards body and later the Ecma International to formalize Java, but it soon withdrew from the process.[16] Java remains a de facto standard, controlled through the Java Community Process.[17] At one time, Sun made most of its Java implementations available without charge, despite their proprietary software status. Sun generated revenue from Java through the selling of licenses for specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit (SDK) and Runtime Environment (JRE) (a subset of the SDK); the primary distinction involves the JRE's lack of the compiler, utility programs, and header files.
On November 13, 2006, Sun released much of Java as free and open source software, (FOSS), under the terms of the GNU General Public License (GPL). On May 8, 2007, Sun finished the process, making all of Java's core code available under free software/open-source distribution terms, aside from a small portion of code to which Sun did not hold the copyright.[18]
Sun's vice-president Rich Green said that Sun's ideal role with regards to Java was as an "evangelist."[19] Following Oracle Corporation's acquisition of Sun Microsystems in 2009–2010, Oracle has described itself as the "steward of Java technology with a relentless commitment to fostering a community of participation and transparency".[20] Java software runs on laptops to data centers, game consoles to scientific supercomputers. There are 930 million Java Runtime Environment downloads each year and 3 billion mobile phones run Java.[21] On April 2, 2010, James Gosling resigned from Oracle.[22] Principles
There were five primary goals in the creation of the Java language:[23]
1. It should be "simple, object-oriented and familiar"
2. It should be "robust and secure"
3. It should be "architecture-neutral and portable"
4. It should execute with "high performance"
5. It should be "interpreted, threaded, and dynamic"
Versions
Main article: Java version history
Major release versions of Java, along with their release dates:
JDK 1.0 (January 23, 1996)
JDK 1.1 (February 19, 1997)
J2SE 1.2 (December 8, 1998)
J2SE 1.3 (May 8, 2000)
J2SE 1.4 (February 6, 2002)
J2EE 5.0 (September 30, 2004)
Java SE 6 (December 11, 2006)
Java SE 7 (July 28, 2011)
Practices
Java platform
Main articles: Java (software platform) and Java Virtual Machine
One characteristic of Java is portability, which means that computer programs written in the Java language must run similarly on any hardware/operating-system platform. This is achieved by compiling the Java language code to an intermediate representation called Java bytecode, instead of directly to platform-specific machine code. Java bytecode instructions are analogous to machine code, but are intended to be interpreted by a virtual machine (VM) written specifically for the host hardware. End-users commonly use a Java Runtime Environment (JRE) installed on their own machine for standalone Java applications, or in a Web browser for Java applets.
Standardized libraries provide a generic way to access host-specific features such as graphics, threading, and networking.
A major benefit of using bytecode is porting. However, the overhead of interpretation means that interpreted programs almost always run more slowly than programscompiled to native executables would. Just-in-Time compilers were introduced from an early stage that compile bytecodes to machine code during runtime.
Implementations
Sun Microsystems officially licensed the Java Standard Edition platform for Linux,[24] Mac OS X,[25] and Solaris. In the past Sun licensed Java to Microsoft but the license expired without renewal.[26] Because Windows does not ship with a Java software platform, a network of third-party vendors and licensees[27] develop them for Windows and other operating system/hardware platforms.
Sun's trademark license for usage of the Java brand insists that all implementations be "compatible". This resulted in a legal dispute with Microsoft after Sun claimed that the Microsoft implementation did not support
RMI or JNI and had added platform-specific features of their own. Sun sued in 1997, and in 2001 won a settlement of US$20 million, as well as a court order enforcing the terms of the license from Sun.[28] As a result, Microsoft no longer ships Java with Windows, and in recent versions of Windows, Internet Explorer cannot support Java applets without a third-party plugin. Sun, and others, have made available free Java run-time systems for those and other versions of Windows.
Platform-independent Java is essential to the Java EE strategy, and an even more rigorous validation is required to certify an implementation. This environment enables portable server-side applications, such as Web services, Java Servlets, and Enterprise JavaBeans, as well as with embedded systems based on OSGi, using Embedded Java environments. Through the GlassFish project, Sun is working to create a fully functional, unified open source implementation of the Java EE technologies.
Sun also distributes a superset of the JRE called the Java Development Kit (commonly known as the JDK), which includes development tools such as the Java compiler, Javadoc, Jar, and debugger.
Performance
Main article: Java performance
Programs written in Java have a reputation for being slower and requiring more memory than those written in C.[29] However, Java programs' execution speed improved significantly with the introduction of Just-in-time compilation in 1997/1998 for Java 1.1,[30] the addition of language features supporting better code analysis (such as inner classes, StringBuffer class, optional assertions, etc.), and optimizations in the Java Virtual Machine itself, such as HotSpot becoming the default for Sun's JVM in 2000. Currently (November 2011), Java 2.0 code has approximately half the performance of C code.[31]
Some platforms offer direct hardware support for Java; there are microcontrollers that can run Java in hardware instead of a software JVM, and ARM based processors can have hardware support for executing Java bytecode through its Jazelle option.
Automatic memory management
Java uses an automatic garbage collector to manage memory in the object lifecycle. The programmer determines when objects are created, and the Java runtime is responsible for recovering the memory once objects are no longer in use. Once no references to an object remain, the unreachable memory becomes eligible to be freed automatically by the garbage collector. Something similar to a memory leak may still occur if a programmer's code holds a reference to an object that is no longer needed, typically when objects that are
no longer needed are stored in containers that are still in use. If methods for a nonexistent object are called, a "null pointer exception" is thrown.[32][33]
One of the ideas behind Java's automatic memory management model is that programmers can be spared the burden of having to perform manual memory management. In some languages, memory for the creation of objects is implicitly allocated on the stack, or explicitly allocated and deallocated from the heap. In the latter case the responsibility of managing memory resides with the programmer. If the program does not deallocate an object, a memory leak occurs. If the program attempts to access or deallocate memory that has already been deallocated, the result is undefined and difficult to predict, and the program is likely to become unstable and/or crash. This can be partially remedied by the use of smart pointers, but these add overhead and complexity. Note that garbage collection does not prevent "logical" memory leaks, i.e. those where the memory is still referenced but never used.
Garbage collection may happen at any time. Ideally, it will occur when a program is idle. It is guaranteed to be triggered if there is insufficient free memory on the heap to allocate a new object; this can cause a program to stall momentarily. Explicit memory management is not possible in Java.
Java does not support C/C++ style pointer arithmetic, where object addresses and unsigned integers (usually long integers) can be used interchangeably. This allows the garbage collector to relocate referenced objects and ensures type safety and security.
As in C++ and some other object-oriented languages, variables of Java's primitive data types are not objects. Values of primitive types are either stored directly in fields (for objects) or on the stack (for methods) rather than on the heap, as commonly true for objects (but see Escape analysis). This was a conscious decision by Java's designers for performance reasons. Because of this, Java was not considered to be a pure object-oriented programming language. However, as of Java 5.0, autoboxing enables programmers to proceed as if primitive types were instances of their wrapper class.
Java contains multiple types of garbage collectors. By default, HotSpot uses the Concurrent Mark Sweep collector, also known as the CMS Garbage Collector. However, there are also several other garbage collectors that can be used to manage the Heap. For 90% of applications in Java, the CMS Garbage Collector is good enough.
Java (程序设计语言)
文章来自维基（免费的百科全书）
Java最初是由James Gosling在Sun Microsystems公司（已经合并到
Oracle公司）开发的程序设计语言，而且是在1995年以Sun Microsystems 的Java运行平台的核心元件发布。其很多语法规则源于C语言和C++，但是对象模型更加简单，还减少了低级功能。Java的应用是典型地用字节码（类文件）编辑，可以无视计算机体系结构在任何Java虚拟机上运行。Java是为了尽可能少执行附属而特别设计的一个通用的、可同时的、以等级为基础的、目标导向的语言。它特意让程序开发人员能“即写即用”，就是说在一个平台上运行的代码不需要再编辑后去另一个平台上运行。Java目前在使用的语言中是最流行的编程语言之一，尤其是在基于WEB的客户端-服务器运用上，据报道有一千万的使用者。经Sun公司在1995年开始由原始和参考实现Java编译器、虚拟机和类库开发。在2007年5月的时候，在遵循Java社区进程的细则下，Sun公司的大部分Java技术得到了GNU通用公共许可条款的认可。其他非官方的人也开发Sun公司的技术的运用，比如 GNU Compiler for Java 和 GNU Classpath。
内容
1.历史
1.1原则
1.2版本
2.惯例
2.1Java平台
2.1.1执行
2.1.2成果
2.2自动内存管理
历史
也可参考：Java（软件平台）历史
James Gosling, Mike Sheridan, 和 Patrick Naughton在1991年7月开始着手Java语言项目。Java语言最初是为交互式电视设计的，不过也因为有缆数字电视产业而进化。因为Gosling的办公室外长着一棵橡树(Oak)，这语言最初被称作Oak后来命名为Green，之后又被重命名为Java，据说那是一个有大量语言创作人去过的咖啡店的名字。Gosling致力于实现一种虚拟计算机和一种类似C/C++表示法的语言。
Sun Microsystems公司在1995年发布了名为Java1.0 的第一个公共工具。它兑现了“即写即用”的承诺，能够在主流的平台上流畅使用，还以结构的安全为特点相当的可靠。它可以进行网络和文件存放管理。主要的网页浏览器马上在网页上加入了能运行Java小程序的功能，于是Java很快变得流行。随着Java 2的到来（最初在1998–1999的十二月以J2SE 1.2名字发布），为各种类型的平
台打造的全新的形式和多种多样的结构。比如，J2EE是针对企业的应用，大大简化版的J2ME针对移动电话的应用。J2SE则是设计为标准版本。在2006年，为了市场目的，Sun公司分别重命名了新的J2版本Java EE, Java ME, 和 Java SE。
在1997年，Sun Microsystems公司接近了 ISO/IEC JTC1 标准体系而且后来的 Ecma International要让Java规范化，但是马上又在中途撤销了。Java 保持事实上的标准，控制整个Java社区过程，同时Sun公司不论软件所有权的状况让其大部分的Java应用免费。Sun公司通过出售像Java Enterprise System 这样特别的产品许可证来获取收益。Sun公司区分了Software Development Kit (SDK) 和 Runtime Environment (JRE) ，这基本的区分使JRE陷入缺少编译器、实用程序和页眉文件。
在2006年11月13日，Sun公司在GNU通用公共许可条款的许可下发布了大量的免费的开源Java软件。在2007年5月8日，除了一小部分非Sun公司版权的代码，Sun公司完成了让所有Java核心代码在软件免费和开源的情况下使用。
Sun公司副总裁声称对Java关注的Sun公司的理想角色就像传播福音的人。2009到2010之间，在Oracle公司收购了Sun Microsystems后，Oracle将自己描述为“为了完善一个有参与且透明的社区而坚持奉献的Java科技的乘务员”。Java 程序无处不在，从手提设备到数据中心，从游戏机到超级科学计算机。每年有9.3亿的Java运行环境下载，30亿的手机使用Java 。2010年的4月2日，James Gosling 从Oracle公司退休。
原则
在Java 语言中实现五个主要原则：
1.它应该是“面向对象的，简单的和熟悉的”
2.它应该是“稳定的和安全的”
3.它应该是“平台无关性和可移植的”
4.它应该是“高性能的”
5.它应该是“及时执行，多线程和动态性”
版本
主要文章：历史版本
根据发行日期Java的主要版本有：
JDK1.0（1996年1月23日）
JDK1.1（1997年2月19日）
J2SE1.2（1998年12月8日）
J2SE1.3（2000年5月8日）
J2SE1.4（2002年2月6日）
J2EE5.0（2004年9月30日）
Java SE 6（2006年12月11日）
Java SE 7（2011年7月28日）
惯例
Java平台
主要内容：Java（软件平台）和Java虚拟机
Java的特征之一是可移植性,这意味着用Java语言编写的电脑程序必须可以在任何硬件/操作系统平台上一样地运行。这是通过把Java语言代码编辑为字节码这一中间代码——而不是直接的具体平台的机械语言——来实现的。Java 字节码指令类似机械代码，但是需要由主机硬件所特别编写的虚拟机翻译。最终用户通常为独立的Java应用程序要在他们自己的机器上安装一个运行环境，或者在浏览器上安装Java小程序。
标准库提供了一个来访问主机具体特点（如图形，线程，网络）的通用方式。
使用字节码的一个主要好处是可移植。然而，额外的翻译意味着翻译的程序运行总会比本地的可执行程序慢。即时编译器被从初期阶段引入，可在运行的时候把字节码翻译成机械码。
执行
Sun Microsystems公司正式地给Lunix、Mac OS X、和 Solaris授权Java 标准版平台，过去Sun公司曾给Microsoft授权Java，但许可证过期了没有更新。因为Windows系统没有一个第三方供应商为Windows（及其其它操作系统/硬件平台）许可和发展的Java软件平台。Sun公司的Java品牌的商标使用许可坚持所有的执行“兼容”。在Sun公司宣布Microsoft的执行不支持RMI和JNI 而且他们添加了其特殊平台，这导致了和Microsoft的法律纠纷。Sun公司在1997年起诉，并在2001获得两千万美元的赔偿，以及法院命令强制Sun公司的许可权。因此，Microsoft再也不在Windows上支持Java，并且，新版本的Windows 在没有第三方插件下也不支持Java。Sun以及其它公司开发了可以给各系列Windows使用的免费的Java运行系统。
独立平台的Java对Java EE的战略至关重要，需要一个甚至更加严格的批准来保证执行。这种环境能够使便携服务设备（比如Web services, Java Servlets, 和 Enterprise JavaBeans，还有基于嵌入式系统的OSGI）使用嵌入式Java环境。在整个GlassFish项目中，Sun公司致力开发出一个全功能的，统一的，开源的Java EE技术的implementation（不知道怎么翻译）。
Sun公司也发布了一个名叫Java Development Kit （俗称JDK）JRE的一个超
集，它包括了比如Java compiler, Javadoc, Jar, 和 debugger的开发工具。
成果
主要内容: Java 的成果
用Java编写的程序有运行速度较慢的名声而且比C语言需要更多的内存。然而，随着1997/1998Java1.1即时编译的引进，Java程序的执行速度得到显著改善。另外的语言功能更好地支持代码分析（比如内部类，StringBuffer 类，可选择声明等等）和优化虚拟机本身，比如HotSpot在2000年变成Sun公司默认的虚拟机。目前（2011年11月），Java2.0码有大约C语言码一半的成果。
一些平台为Java提供直接的硬件支持。有微控制器，它能够取代软件虚拟机运行Java，还有基于ARM的信息处理器，可以通过其Jazelle选项由硬件支持执行Java 字节码。
自动内存管理
Java在对象生命周期使用自动垃圾收集来管理内存。程序员决定对象的创立，一旦对象不再被使用，Java就负责回收内存。若任然没有引用一个对象，不可使用的内存就成为垃圾收集器自动释放。类似于内存泄露可能还会发生，如果一个程序员的代码有一个不再需要引用的对象，通常当对象不被需要时，会被保存在正在使用的储存器中，如果方法需要不存在的对象，会回应“空指针异常”。 Java自动内存管理模型背后理念之一是程序员可以免于进行人工记忆经营管理的负担。在某些语言里，创建对象的内存被后台分配到栈，或者显示分配和释放到堆。在其后的情况下内存管理的权由程序员负责。如果程序没有归还对象，就会发生内存泄露。如果程序试图归还已经被归还的内存，结果是未定义的并且难以预料，并且程序很有可能变得不稳定或导致死机。
这可以通过智能指针的使用来局部地弥补，但这样增加了架空和复杂性。请注意，垃圾收集并不能防止逻辑内存的泄露。即那些那些内存仍被引用但不被使用。
垃圾收集可随时发生。理想情况下，它会在一个程序空闲的时候触发。它可以保证在堆上的空余内存不够分配给新对象时触发。这回导致程序瞬间减速。Java不能显示内存管理。
在对象地址和正整数（通常是长整数）可以互换使用场合，Java不能支持C/C++类型的指针运算。这使垃圾收集器能调用引用个对象并确保类型安全。
在C++和其它面向对象的语言中，Java的原始数据类型的变量不是能作为对象。原始类型变量要么直接储存在（对象的）域，要么储存在（方法的）栈上，而不是在堆上，就像通常的对象真值（见逃逸分析）。这是Java设计师为了运行原因二有意识决定的。因此，Java不会被认为一个纯粹面向对象的编程语言。然而，Java5.0 autoboxing使程序员能够进行，好像原始类的是包装函式类别的实
例。
Java包含了多种类型的垃圾收集器。默认情况下，HotSpot 使用Concurrent Mark Sweep Collector（也作CMS Garbage Collector）。然而，也有其它几种可以使用堆的垃圾收集器。对90%的Java应用来说，CMS Garbage Collector 已经足够了。
外文出处： 《Exploiting Software How to Break Code》By Greg Hoglund, Gary McGraw Publisher : Addison Wesley Pub Date : February 17, 2004 ISBN : 0-201-78695-8 译文标题： JDBC接口技术 译文： JDBC是一种可用于执行SQL语句的JavaAPI（ApplicationProgrammingInterface应用程序设计接口）。它由一些Java语言编写的类和界面组成。JDBC为数据库应用开发人员、数据库前台工具开发人员提供了一种标准的应用程序设计接口，使开发人员可以用纯Java语言编写完整的数据库应用程序。 一、ODBC到JDBC的发展历程 说到JDBC，很容易让人联想到另一个十分熟悉的字眼“ODBC”。它们之间有没有联系呢？如果有，那么它们之间又是怎样的关系呢？ ODBC是OpenDatabaseConnectivity的英文简写。它是一种用来在相关或不相关的数据库管理系统（DBMS）中存取数据的，用C语言实现的，标准应用程序数据接口。通过ODBCAPI，应用程序可以存取保存在多种不同数据库管理系统（DBMS）中的数据，而不论每个DBMS使用了何种数据存储格式和编程接口。 1．ODBC的结构模型 ODBC的结构包括四个主要部分：应用程序接口、驱动器管理器、数据库驱动器和数据源。应用程序接口：屏蔽不同的ODBC数据库驱动器之间函数调用的差别，为用户提供统一的SQL编程接口。 驱动器管理器：为应用程序装载数据库驱动器。 数据库驱动器：实现ODBC的函数调用，提供对特定数据源的SQL请求。如果需要，数据库驱动器将修改应用程序的请求，使得请求符合相关的DBMS所支持的文法。 数据源：由用户想要存取的数据以及与它相关的操作系统、DBMS和用于访问DBMS的网络平台组成。 虽然ODBC驱动器管理器的主要目的是加载数据库驱动器，以便ODBC函数调用，但是数据库驱动器本身也执行ODBC函数调用，并与数据库相互配合。因此当应用系统发出调用与数据源进行连接时，数据库驱动器能管理通信协议。当建立起与数据源的连接时，数据库驱动器便能处理应用系统向DBMS发出的请求，对分析或发自数据源的设计进行必要的翻译，并将结果返回给应用系统。 2．JDBC的诞生 自从Java语言于1995年5月正式公布以来，Java风靡全球。出现大量的用java语言编写的程序，其中也包括数据库应用程序。由于没有一个Java语言的API，编程人员不得不在Java程序中加入C语言的ODBC函数调用。这就使很多Java的优秀特性无法充分发挥，比如平台无关性、面向对象特性等。随着越来越多的编程人员对Java语言的日益喜爱，越来越多的公司在Java程序开发上投入的精力日益增加，对java语言接口的访问数据库的API 的要求越来越强烈。也由于ODBC的有其不足之处，比如它并不容易使用，没有面向对象的特性等等，SUN公司决定开发一Java语言为接口的数据库应用程序开发接口。在JDK1．x 版本中，JDBC只是一个可选部件，到了JDK1．1公布时，SQL类包（也就是JDBCAPI）
外文资料译文及原文 Java Java I/O 系统 对编程语言的设计者来说，创建一套好的输入输出(I/O)系统，是一项难度极高的任务。 这一点可以从解决方案的数量之多上看出端倪。这个问题难就难在它要面对的可能性太多了。不仅是因为有那么多I/O的源和目地(文件，控制台，网络连接等等)，而且还有很多方法(顺序的『sequential』，随机的『random-access』，缓存的『buffered』，二进制的『binary』，字符方式的『character』，行的『by lines』，字的『by words』，等等)。 Java类库的设计者们用"创建很多类"的办法来解决这个问题。坦率地说Java I/O系统的类实在是太多了，以至于初看起来会把人吓着（但是，具有讽刺意味的是，这种设计实际上是限制了类的爆炸性增长）。此外，Java在1.0版之后又对其I/O类库作了重大的修改，原先是面向byte的，现在又补充了面向Unicode字符的类库。为了提高性能，完善功能，JDK 1.4又加了一个nio(意思是"new I/O"。这个名字会用上很多年)。这么以来，如果你想对Java的I/O 类库有个全面了解，并且做到运用自如，你就得先学习大量的类。此外，了解 I/O类库的演化的历史也是相当重要的。可能你的第一反应是"别拿什么历史来烦我了，告诉我怎么用就可以了！"但问题是，如果你对这段历史一无所知，很快就会被一些有用或是没用的类给搞糊涂了。
本章会介绍Java标准类库中的各种I/O类，及其使用方法。 File 类 在介绍直接从流里读写数据的类之前，我们先介绍一下处理文件和目录的类。 File类有一个极具欺骗性的名字；或许你会认为这是一个关于文件的类，但它不是。你可以用它来表示某个文件的名字，也可以用它来表示目录里一组文件的名字。如果它表示的是一组文件，那么你还可以用list( )方法来进行查询，让它会返回String数组。由于元素数量是固定的，因此数组会比容器更好一些。如果你想要获取另一个目录的清单，再建一个File对象就是了。实际上，叫它"FilePath"可能会更好一些。下面我们举例说明怎样使用这个类及其相关的FilenameFilter接口。 目录列表器 假设你想看看这个目录。有两个办法。一是不带参数调用list( )。它返回的是File对象所含内容的完整清单。但是，如果你要的是一个"限制性列表(restricted list)"的话——比方说，你想看看所有扩展名为.java的文件——那么你就得使用"目录过滤器"了。这是一个专门负责挑选显示File对象的内容的类。 下面就是源代码。看看，用了java.utils.Arrays.sort( )和11章的AlphabeticComparator之后，我们没费吹灰之力就对结果作了排序(按字母顺序)： //: c12:DirList.java // Displays directory listing using regular expressions. // {Args: "D.*\.java"} import java.io.*; import java.util.*; import java.util.regex.*; import com.bruceeckel.util.*; public class DirList { public static void main(String[] args) { File path = new File("."); String[] list; if(args.length == 0) list = path.list(); else list = path.list(new DirFilter(args[0])); Arrays.sort(list, new AlphabeticComparator());
毕业设计（论文）外文文献翻译 文献、资料中文题目：软件开发概念和设计方法文献、资料英文题目： 文献、资料来源： 文献、资料发表（出版）日期： 院（部）： 专业： 班级： 姓名： 学号： 指导教师： 翻译日期： 2017.02.14
外文资料原文 Software Development Concepts and Design Methodologies During the 1960s, ma inframes and higher level programming languages were applied to man y problems including human resource s yste ms,reservation s yste ms, and manufacturing s yste ms. Computers and software were seen as the cure all for man y bu siness issues were some times applied blindly. S yste ms sometimes failed to solve the problem for which the y were designed for man y reasons including: ?Inability to sufficiently understand complex problems ?Not sufficiently taking into account end-u ser needs, the organizational environ ment, and performance tradeoffs ?Inability to accurately estimate development time and operational costs ?Lack of framework for consistent and regular customer communications At this time, the concept of structured programming, top-down design, stepwise refinement，and modularity e merged. Structured programming is still the most dominant approach to software engineering and is still evo lving. These failures led to the concept of "software engineering" based upon the idea that an engineering-like discipl ine could be applied to software design and develop ment. Software design is a process where the software designer applies techniques and principles to produce a conceptual model that de scribes and defines a solution to a problem. In the beginning, this des ign process has not been well structured and the model does not alwa ys accurately represent the problem of software development. However,design methodologies have been evolving to accommo date changes in technolog y coupled with our increased understanding of development processes. Whereas early desig n methods addressed specific aspects of the
Java and the Internet If 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 traditional programming perspective. Although Java is very useful for solving traditional stand-alone programming problems, it is also important because it will solve programming problems on the World Wide Web. 1.Client-side programming The Web’s in itial server-browser design provided for interactive content, but the interactivity was completely provided by the server. The server produced static pages for the client browser, which would simply interpret and display them. Basic HTML contains simple mechanisms for data gathering: text-entry boxes, check boxes, radio boxes, lists and drop-down lists, as well as a button that can only be programmed to reset the data on the form or “submit” the data on the form back to the server. This submission passes through the Common Gateway Interface (CGI) provided on all Web servers. The text within the submission tells CGI what to do with it. The most common action is to run a program located on the server in a directory that’s typically called “cgi-bin.” (If you watch the address window at the top of your browser when you push a button on a Web page, you can sometimes see “cgi-bin” within all the gobbledygook there.) These programs can be written in most languages. Perl is a common choice because it is designed for text manipulation and is interpreted, so it can be installed on any server regardless of processor or operating system. Many powerful Web sites today are built strictly on CGI, and you can in fact do nearly anything with it. However, Web sites built on CGI programs can rapidly become overly complicated to maintain, and there is also the problem of response time. The response of a CGI program depends on how much data must
I / 11 本科毕业设计外文翻译 <2018届） 论文题目基于WEB 的J2EE 的信息系统的方法研究 作者姓名[单击此处输入姓名] 指导教师[单击此处输入姓名] 学科(专业 > 所在学院计算机科学与技术学院 提交日期[时间 ]
基于WEB的J2EE的信息系统的方法研究 摘要：本文介绍基于工程的Java开发框架背后的概念，并介绍它如何用于IT 工程开发。因为有许多相同设计和开发工作在不同的方式下重复，而且并不总是符合最佳实践，所以许多开发框架建立了。我们已经定义了共同关注的问题和应用模式，代表有效解决办法的工具。开发框架提供：<1）从用户界面到数据集成的应用程序开发堆栈；<2）一个架构，基本环境及他们的相关技术，这些技术用来使用其他一些框架。架构定义了一个开发方法，其目的是协助客户开发工程。 关键词：J2EE 框架WEB开发 一、引言 软件工具包用来进行复杂的空间动态系统的非线性分析越来越多地使用基于Web的网络平台，以实现他们的用户界面，科学分析，分布仿真结果和科学家之间的信息交流。对于许多应用系统基于Web访问的非线性分析模拟软件成为一个重要组成部分。网络硬件和软件方面的密集技术变革[1]提供了比过去更多的自由选择机会[2]。因此，WEB平台的合理选择和发展对整个地区的非线性分析及其众多的应用程序具有越来越重要的意义。现阶段的WEB发展的特点是出现了大量的开源框架。框架将Web开发提到一个更高的水平，使基本功能的重复使用成为可能和从而提高了开发的生产力。 在某些情况下，开源框架没有提供常见问题的一个解决方案。出于这个原因，开发在开源框架的基础上建立自己的工程发展框架。本文旨在描述是一个基于Java的框架，该框架利用了开源框架并有助于开发基于Web的应用。通过分析现有的开源框架，本文提出了新的架构，基本环境及他们用来提高和利用其他一些框架的相关技术。架构定义了自己开发方法，其目的是协助客户开发和事例工程。 应用程序设计应该关注在工程中的重复利用。即使有独特的功能要求，也
中文翻译 基于Java技术的Web应用设计模型的比较研究 来源：School of Computer Science and Engineering University of New South Wales Sydney, NSW 2052, Australia 作者：Budi Kurniawan and Jingling Xue 摘要 Servlet技术是在建立可扩展性Web应用中被应用最广泛的技术。在运用JAVA技术开发Web应用中有四种模型,分别是:Model 1、Model 2、Struts和JavaServer Faces JSF。Model 1使用一连串的JSP页面，Model 2采用了模型，视图，控制器MVC模式。Struts是一个采用了Model 2设计模型的框架，JSF是一种支持ready-to-use组件来进行快速Web应用开发的新技术。Model 1对于中等和大型的应用来说很难维护，所以不推荐使用。本文通过利用Model 2、Struts和JSF这三种模型分别构建三个不同版本的在线商店应用程序来比较和评价这三种模型在应用程序开发和性能上的差异。 1.绪论 当今Web应用是一种展现动态内容的最普遍的方式。构建Web应用有许多种方法，其中最流行的是Servlet技术。这种技术的流行是因为它比CGI、PHP等其他技术更具优越性。然而Servlet对于开发来说还是麻烦的，因为它在传送HTML 标签时需要程序员将他们组合成为一个字符串对象，再将这个对象传给浏览器。同样的，对于输出的一个很小的改动也要求Servlet被重新编译。基于这个原因SUN 公司发明了JavaServer Pages JSP技术。JSP允许HTML标签和Java代码混合在
Section 3 Design philosophy, design method and earth pressures 3.1 Design philosophy 3.1.1 General The design of earth retaining structures requires consideration of the interaction between the ground and the structure. It requires the performance of two sets of calculations: 1）a set of equilibrium calculations to determine the overall proportions and the geometry of the structure necessary to achieve equilibrium under the relevant earth pressures and forces; 2）structural design calculations to determine the size and properties of thestructural sections necessary to resist the bending moments and shear forces determined from the equilibrium calculations. Both sets of calculations are carried out for specific design situations (see 3.2.2) in accordance with the principles of limit state design. The selected design situations should be sufficiently Severe and varied so as to encompass all reasonable conditions which can be foreseen during the period of construction and the life of the retaining wall. 3.1.2 Limit state design This code of practice adopts the philosophy of limit state design. This philosophy does not impose upon the designer any special requirements as to the manner in which the safety and stability of the retaining wall may be achieved, whether by overall factors of safety, or partial factors of safety, or by other measures. Limit states (see 1.3.13) are classified into: a) ultimate limit states (see 3.1.3); b) serviceability limit states (see 3.1.4). Typical ultimate limit states are depicted in figure 3. Rupture states which are reached before collapse occurs are, for simplicity, also classified and
文献来源：Bruce Eckel.Thinking in Java [J]. Pearson Higher Isia Education,2006-2-20. Java编程思想 (Java和因特网) 既然Java不过另一种类型的程序设计语言，大家可能会奇怪它为什么值得如此重视，为什么还有这么多的人认为它是计算机程序设计的一个里程碑呢？如果您来自一个传统的程序设计背景，那么答案在刚开始的时候并不是很明显。Java除了可解决传统的程序设计问题以外，还能解决World Wide Web(万维网) 上的编程问题。 1、客户端编程 Web最初采用的“服务器－浏览器”方案可提供交互式内容，但这种交互能力完全由服务器提供，为服务器和因特网带来了不小的负担。服务器一般为客户浏览器产生静态网页，由后者简单地解释并显示出来。基本HTML语言提供了简单的数据收集机制：文字输入框、复选框、单选钮、列表以及下拉列表等，另外还有一个按钮，只能由程序规定重新设置表单中的数据，以便回传给服务器。用户提交的信息通过所有Web服务器均能支持的“通用网关接口”（CGI）回传到服务器。包含在提交数据中的文字指示CGI该如何操作。最常见的行动是运行位于服务器的一个程序。那个程序一般保存在一个名为“cgi-bin”的目录中（按下Web页内的一个按钮时，请注意一下浏览器顶部的地址窗，经常都能发现“cgi-bin”的字样）。大多数语言都可用来编制这些程序，但其中最常见的是Perl。这是由于Perl是专为文字的处理及解释而设计的，所以能在任何服务器上安装和使用，无论采用的处理器或操作系统是什么。 2、脚本编制语言 插件造成了脚本编制语言的爆炸性增长。通过这种脚本语言，可将用于自己客户端程序的源码直接插入HTML页，而对那种语言进行解释的插件会在HTML 页显示的时候自动激活。脚本语言一般都倾向于尽量简化，易于理解。而且由于它们是从属于HTML页的一些简单正文，所以只需向服务器发出对那个页的一
毕业设计(论文)外文资料翻译 系：计算机系 专业：计算机科学与技术 姓名： 学号： 外文出处：Ghosh,D..Java Object-oriented (用外文写) programming[J]. IEEE Transactions on Software Engineering,2009, 13(3):42-45. 附件： 1.外文资料翻译译文；2.外文原文。
注：请将该封面与附件装订成册。
附件1：外文资料翻译译文 Java的面向对象编程 ——面向对象编程和它的关键技术—继承和多态性 软件的重用可以节省程序开发时间。它鼓励重复使用已经调试好的高质量的软件，从而减少系统运行后可能出现的问题。这些都是令人振奋的可能性。多态性允许我们用统一的风格编写程序，来处理多种已存在的类和特定的相关类。利用多态性我们可以方便地向系统中添加新的功能。继承和多态对于解决软件的复杂性是一种有效可行的技术。当创建一个新的类时，而不用完整的写出新的实例变量和实例方法，程序员会指定新的类继承已定义的超类的实例变量和实例方法。这个新的类被称为一个子类。每个子类本身将来亦可有新的子类，而其本身将成为父类。一个类的直接父类就是该类所直接继承的类（通过关键字extends继承）。一个间接超类是通过从两级或更多级以上的类继承而来的。例如，从类JApplet（包javax.swing 中）扩展来的类Applet（包java.applet）。一个类单一的从一个父类继承而来。 Java 不支持多重继承（而C++可以），但它支持接口的概念。接口可以使Java实现许多通过多重继承才能实现的优点而没有关联的问题。我们将在本章讨论的接口的详细内容。我们会给出创建和使用接口的一般规律和具体实例。一个子类通常添加自己的实例变量和自己的实例方法，因此子类通常比父类大。一个子类比它的父类更具体并且代表一组更小、更专业的对象。通过单一继承，子类在开始时拥有父类的所有特性。继承性真正的力量在于它可以在定义子类时增加或取代从超类中继承来的特征。每个子类对象也是该类的父类的对象。例如，每一个我们所定义的小程序被认为是类JApplet 的对象。此外，因为Japplet继承了Applet，每一个我们所定义的小程序同时也被认为是一个Applet 的对象。当开发applets时，这些信息是至关重要的，因为一个小程序容器只有当它是一个Applet才可以执行一个程序。虽然子类对象始终可以作为它的父类的一种来看待，父类对象却不被认为是其子类类型的对象。我们将利用这种“子类对象是父类对象”的关系来执行一些强大的操作。例如，绘图程序可以显示一系列图形，如果所有的图形类型都直接或间接地继
编号：桂林电子科技大学信息科技学院 毕业设计(论文)外文翻译 （译文） 系（部）：机电工程系 专业：机械设计制造及自动化 学生姓名：李汉显 学号：1153100506 指导教师单位：桂林航天工业学院 姓名：陈志 职称：讲师 2015年5 月28日
无损检测技术在检测石油管道时的可靠性 卡瓦略·库切答（a）；雷贝洛（b）；米纳拉辛苏扎·苏哲（b）； 湖奈保尔·苏格瑞勒（c）；萨拉?迪基·苏亚雷斯（d） a、华盛顿苏亚雷斯马路大学科学技术中心，1321；巴西福塔雷萨行政长官,埃德森奎罗兹临时选举委员会:60,811 - 905 b、巴西里约热内卢联邦大学临时选举委员会:21941 - 972 c、巴西里约热内卢联邦大学土木工程系 d、巴西里约热内卢大学城临时选举委员会:21949 - 900 文章内容 文章背景：2006年11月9日收到 2008年5月21日修改后的表格 2008年5月27日认可 关键词：无损检测；可靠性；超声检测；X线摄影 摘要 这项工作的目的是评估无损检测技术（NDT）在检查石油工业中的管道焊缝的可靠性。X射线，手动和全自动的超声波都利用了脉冲回波和光线干涉原理。三个层面的缺陷分析为：缺乏渗透（LP），缺乏融合（LF）和削弱（UC）。这些测试是对含焊缝缺陷已被人为地确定为标本的管道进行测试。结果表明：全自动超声波检测缺陷与手动超声波、X光测试相比更具有优越性。此外，人工神经网络已被用于探测缺陷和缺陷的自动分类。 1简介 在长距离的流体（包括石油和天然气）传输过程中，管道运输时最安全最经济的方法。由于这一点和管道的效率，他们已用了几十年。但是由于种种因素，如腐蚀，疲劳，甚至侵蚀所增加泄漏的危险，甚至破裂，这些都是现在应该考虑的关键问题。还应该指出，许多管道铺设在接近道路，铁路，水路甚至在城市或在其下方。因此，必须有方法监测，评价和肯定管道的完整性，减少泄漏的风险，从而避免环境破坏和人群危害。多年来，无损检测在石油管道的状态检测中显示了其高效性。 无损检测技术正被研究的越来越深，同时已经作为评估工程结构、工程系统使用寿命的方法。这项研究特别注意了石油工业可能发生的设备故障导致严重后果，比如环境污染和人员伤亡。然而，一般认为应考虑采取最适当的参数来选择无损技术，剩下的就是它的使用可靠性，其中一个检测与确定缺陷大小的评估检测概率曲线（POD）是最具代表性的。 对于管道检测的两种技术超声波和X线检查比传统方法更具有出色的效率和易于
毕业设计外文资料翻译 （译文） 题目名称：Java and the Internet 学院：计算机科学技术 专业年级：计算机科学与技术（师）08 级 学生姓名：aaa 班级学号：a班a号 指导教师：aaa
二○一一年五月十三日 译文题目：Java和因特网 原文题目：Java and the Internet 原文出处：https://www.doczj.com/doc/7c12102056.html,/view.html
Java and the Internet If 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 traditional programming perspective. Although Java is very useful for solving traditional stand-alone programming problems, it is also important because it will solve programming problems on the World Wide Web. 1.Client-side programming The Web’s initial server-browser design provided for interactive content, but the interactivity was completely provided by the server. The server produced static pages for the client browser, which would simply interpret and display them. Basic HTML contains simple mechanisms for data gathering: text-entry boxes, check boxes, radio boxes, lists and drop-down lists, as well as a button that can only be programmed to reset the data on the form or “submit” the data on the form back to the server. This submission passes through the Common Gateway Interface (CGI) provided on all Web servers. The text within the submission tells CGI what to do with it. The most common action is to run a program located on the server in a directory that’s typically called “cgi-bin.” (If you watch the address window at the top of your browser when you push a button on a Web page, you can so metimes see “cgi-bin” within all the gobbledygook there.) These programs can be written in most languages. Perl is a common choice because it is designed for text manipulation and is interpreted, so it can be installed on any server regardless of processor or operating system. Many powerful Web sites today are built strictly on CGI, and you can in fact do nearly anything with it. However, Web sites built on CGI programs can rapidly become overly complicated to maintain, and there is also the problem of response time. The response of a CGI program depends on how much data must be sent, as well as the load on both the server and the Internet. (On top of this, starting a CGI program tends to be slow.) The initial designers of the Web did not foresee how rapidly this bandwidth would be exhausted for the kinds of applications people developed. For example, any sort of dynamic graphing is nearly impossible to perform with consistency because a GIF file must be created and moved from the server to the client for eac h version of the graph. And you’ve no doubt had direct experience with something as simple as validating the data on an input form. You press the submit button on a page; the data is shipped back to the server; the server starts a CGI program that discovers an error, formats an HTML page informing you of the error, and then sends the page back to you; you must then back up a page and try again. Not only is this slow, it’s inelegant. The solution is client-side programming. Most machines that run Web browsers are powerful engines capable of doing vast work, and with the original static HTML
xxxx大学高新学院毕业设计（论文） 外文翻译 学生姓名： 院（系）： 专业班级： 指导教师： 完成日期：
JSP基础学习资料 一、JSP 技术概述 在Sun 正式发布JSP(JavaServer Pages) 之后，这种新的Web 应用开发技术很快引起了人们的关注。JSP 为创建高度动态的Web 应用提供了一个独特的开发环境。按照Sun 的说法，JSP 能够适应市场上包括Apache WebServer 、IIS4.0 在内的85% 的服务器产品。即使您对ASP “一往情深”，我们认为，关注JSP 的发展仍旧很有必要。 ㈠JSP 与ASP 的简单比较 JSP 与Microsoft 的ASP 技术非常相似。两者都提供在HTML 代码中混合某种程序代码、由语言引擎解释执行程序代码的能力。在ASP 或JSP 环境下，HTML 代码主要负责描述信息的显示样式，而程序代码则用来描述处理逻辑。普通的HTML 页面只依赖于Web 服务器，而ASP 和JSP 页面需要附加的语言引擎分析和执行程序代码。程序代码的执行结果被重新嵌入到HTML 代码中，然后一起发送给浏览器。ASP 和JSP 都是面向Web 服务器的技术，客户端浏览器不需要任何附加的软件支持。 ASP 的编程语言是VBScript 之类的脚本语言，JSP 使用的是Java ，这是两者最明显的区别。此外，ASP 与JSP 还有一个更为本质的区别：两种语言引擎用完全不同的方式处理页面中嵌入的程序代码。在ASP 下，VBScript 代码被ASP 引擎解释执行；在JSP 下，代码被编译成Servlet 并由Java 虚拟机执行，这种编译操作仅在对JSP 页面的第一次请求时发生。 ㈡运行环境 Sun 公司的JSP 主页在https://www.doczj.com/doc/7c12102056.html,/products/jsp/index.html ，从这里还可以下载JSP 规范，这些规范定义了供应商在创建JSP 引擎时所必须遵从的一些规则。 执行JSP 代码需要在服务器上安装JSP 引擎。此处我们使用的是Sun 的JavaServer Web Development Kit （JSWDK ）。为便于学习，这个软件包提供了大量可供修改的示例。安装JSWDK 之后，只需执行startserver 命令即可启动服务器。在默认配置下服务器在端口8080 监听，使用http://localhost:8080 即可打开缺省页面。 在运行JSP 示例页面之前，请注意一下安装JSWDK 的目录，特别是“ work ”子目录下的内容。执行示例页面时，可以在这里看到JSP 页面如何被转换成Java 源文件，然后又被编译成class 文件（即Servlet ）。JSWDK 软件包中的示例页
模型预测油田水中溶解的碳酸钙含量： 压力和温度的影响 XXX 译 摘要：油田中水垢沉积会对储层造成伤害、堵塞地层孔道、表面以及注入设备。碳酸钙是水中最常见的结垢化合物之一，储层产生的盐水会使压力和温度降低，储层压力降低会使CaCO3的溶解度降低，进而提高体系中碳酸钙的饱和速率，而温度下降会产生相反的结果。因此温度和压力一起作用的结果可能增加或减小CaCO3溶解度，用体系温度的变化来指定其压力的变化。因此，在石油生产系统中精确的预测方法的应用备受关注。目前的研究重点是运用基于最小二乘支持向量机(LSSVM)预测模型来估计油田水中溶解碳酸钙浓度的大小。用超优化参数（r和C2）的遗传算法（GA）嵌入到LSSVM模型，这种方法可简单准确的预测油田卤水中溶解碳酸钙浓度的最小量。 1.引言 随着油田卤水压力和温度变化，气体可能会从储层到地表的运动，导致某些固体沉淀。为了保持注水井压力平衡并将油运移到生产井，有时需要将卤水注入到储层中，因此，过量的盐垢可以沉积在储层或井眼内。对于大部分油田结垢多会发生在此过程中。 碳酸钙沉积通常是一个自发的过程，沉积形成的主要原因是二氧化碳从水相逸出，导致油气层的压力下降，该过程会除去了水中的碳酸，直到方解石溶解完全。在恒定二氧化碳分压下，方解石的溶解性随温度的降低而降低[1-4]。根据公式（1），碳酸钙沉积垢来自碳酸钙沉淀： Ca2+ + CO32-→ CaCO3↓ 下面的公式为碳酸的电离式[5–7]： CO2 + H2O → H2CO3 H2CO3→ H+ + HCO3- HCO3-→ H+ + CO32- 若要形成碳酸氢根离子和氢离子，碳酸要电离，因为碳酸的第一电离常数远大于它的第二电离常数，从碳酸第一电离离子化的氢离子与水中自由的碳酸根离子结合。此外，碳酸钙沉淀的方程式可以说明[8–10]：