关于本课程
本书的主要目标是为你提供有关Java应用和Java applets的面向对象的程序设计所必需的知识和技能；并讲授Java编程语言句法和面向对象的概念，以及Java运行环境的许多特性， 对图形用户界面（GUIs）、多线程和网络的支持等。本课程包括了参加SUN Certified Java Programmer和SUN Certified Java Developer考试所必备的知识。
一、课程概述
| 课程概述 本课程主要包括以下内容： - Java编程语言句法 - 应用于Java编程语言的面向对象的概念 - 图形用户界面（GUI）编程 - 创建Applet - 多线程 - 网络 |
本课程首先讨论了Java运行环境和Java编程语言句法，然后阐述了应用于Java编程语言的面向对象的概念；随着课程的进展还将讨论有关Java平台的更先进的特性。
本课程授课对象应具备运用Java 编程语言或其它语言进行基本语言设计的能力，它是“非程序员Java编程”（“Java Programming for Non—Programmers”，SL-110）课程的延续。
尽管Java编程语言独立于操作系统，但它所产生的图形用户界面（GUI）却可能依赖于执行其代码的操作系统。本课程中的例题所使用的代码运行于Solaris TM操作系统，因而本手册中的图形具备Motif GUI。如果将这些代码运行于Windows 95操作系统，则可产生Microsoft Windows 95 GUI。本课程的内容适用于所有Java操作系统端口。
二、课程图
每一模块的课程都从一张课程图开始，使学员可掌握自己的学习进度。全课程设置流程图如下所示：
三、各模块概述
| 各模块概述 - 模块1──起步 - 模块2──标识符、关键字和类型 - 模块3──表达式和流程控制 - 模块4──数组 - 模块5──对象和类 - 模块6──高级语言特性 - 模块7──异常 - 模块8──建立GUIs - 模块9──AWT事件模型 - 模块10──AWT组件库 - 模块11──Java基础类 - 模块12──Java Applets介绍 - 模块13──线程 - 模块14──流式I/O和文件 - 模块15──网络
|
- 模块1──起步
本模块概述了Java编程语言的主要特性及Java应用程序，阐述了类和包的概念，并介绍了一些常用Java包。
- 模块2──标识符、关键字和类型
Java编程语言与C语言类似，具有许多编程构造。本模块对这些构造作了一般介绍并讲授了每一构造所要求的一般句法。此外，还介绍了采用集合数据类型进行数据关联的面向对象的方法。
- 模块3──表达式和流程控制
本模块介绍了包括运算符和Java程序控制句法在内的表达式。
- 模块4──数组
本模块讲解了如何声明、创建、初始化和拷贝Java数组。
- 模块5──对象和类
本模块是在模块2的基础上，对Java对象的概念作了进一步的阐述，包括重载、覆盖、子类和构造函数。
- 模块6──高级语言特性
本模块是模块5的继续，它进一步讲解了Java面向对象的编程模块，包括一些新的JDK1.1特性──降级和内部类。该模块还介绍了在Java开发包JDKTM 1.2中新增的收集的概念。
- 模块7──异常
本模块为Java程序员提供了一种在运行Java程序时俘获错误的机制，并阐述了预定义异常和用户定义异常。
- 模块8──建立GUIs
在Java编程语言中，所有图形用户界面都是建立在框架和面板的概念之上。本模块介绍了布局管理和容器的概念。
- 模块9──AWT事件模型
Java编程语言1.1版的最重要的变化就是将事件送入和送出Java组件的方法的变化。本模块阐述了JDK1.0和1.1的事件模型的区别，并演示了如何建立小型事件柄（compact event handler）的方法。
- 模块10──AWT组件库
本模块介绍了用于建立Java GUIs的抽象窗口工具包（AWT）组件，并演示了Java AWT组件和1.1事件模型共同工作的方法。
l 模块11──Java基础类介绍
本模块重点介绍了JDK1.2的一个重要特性──Java基础类（JFC），阐述了Swing组件和它们的可插入式外观及感觉的体系结构，并介绍了一例基本的Swing应用及JFC的其它特点，例如在二维图形、存取性及拖放（Drag and drop）等方面的应用。
- 模块12──Java Applets介绍
本模块演示了applet 和应用程序开发之间的区别，并介绍了JDK 1.2的声音增强功能.
- 模块13──线程
线程是一个复杂的论题。本模块阐述了与Java编程语言相关的线程问题，并介绍了一个简单的线程通信和同步传输实例。
- 模块14──流式I/O和文件
本模块阐述了既可读写数据又可读写文本文件的类，并介绍了对象流的概念。
- 模块15──网络
本模块介绍了Java网络编程包并演示了传输控制协议/Internet协议（TCP/IP）客户──服务器模型。
四、课程目标
完成本课程的学习后，你应该能够：
- 描述语言的主要特性
- 编译并运行Java应用程序
- 理解和使用在线超文本Java技术文件
- 描述语言句法元素和构造
- 理解面向对象的例子并使用该语言的面向对象特性
- 理解并使用异常
- 开发图形用户界面
- 描述Java技术平台上的用于建立GUIs的抽象窗口工具包
- 从GUI输入
- 理解事件处理
- 描述Swing的主要特性
- 开发Java applets
- 读写文件和其它数据源
- 在不使用GUI的情况下，对所有数据源执行输入输出
- 理解多线程基础
- 开发多线程Java应用程序和applets
- 使用TCP/IP和用户数据报协议（UDP）开发客户和服务器程序
五、从各模块中所获得的技能
下表的左侧显示有关的Java应用程序编程技能，右侧的黑格表示出讲解其左侧相应技能的有关模块，而灰格则表示简述其左侧相应技能的有关模块。
|
| Module | ||||||||||||||||||||||
| Skills Gained | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | ||||||||
| Describe Key language features |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Compile and run a Java application |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Understand and use the online hypertext Java technology documentation |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Describe language syntactic elements and constructs |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Understand the object-oriented paradigm and use object-oriented features |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Understand and use exceptions |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Develop a GUI |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Describe the Java technology platform’s Abstract Window Toolkit from which GUIs are built |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Take input from a graphical user interface |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Understand event handling |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Describe the main features of Swing |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Develop Java applets |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Understand the basics of multithreading |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |||||||||
| Develop multithreaded Java applications and applets |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |||||||||
| Perform I/O to all sources without the use of a GUI |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Read and write to files and other data sources |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
| Develop Java client and server programs using TCP/IP and UDP |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ||||||||
六、课时安排
下表给出了大致的课程进度
Module Day Day Day Day Day
1 2 3 4 5
About This Course A.M.
Module 1-Getting Started A.M.
Module 2-Identifiers,Keywords,and Types A.M.
Module 3-Expressions and Flow Control P.M.
Module 4-Arrays P.M.
Module 5-Objects and Classes A.M.
Module 6-Advanced Language Features P.M.
Module 7-Exceptions A.M.
Module 8-Building GUIs A.M.
Module 9-The AWT Event Model P.M.
Module 10-The AWT Component Library A.M.
Module 11-Introduction to JFC A.M.
Module 12-Introduction to Applets P.M.
Module 13-Threads A.M.
Module 14-Stream I/O and Files P.M.
Module 15-Networking P.M.
七、未包括的论题
| 未包括的论题 - 一般编程概念。本课程不是为从未参与过编程的人员而设置。 - 一般面向对象概念。
|
本课程未包括的论题见上表，由SUN Educational Services（SES）提供的其它课程包括了上述论题。
- 面向对象的概念──见OO-100：面向对象的技术和概念
- 面向对象的设计和分析──见OO-120面向对象的设计和分析
- 一般编程概念──见SL-110：非程序员Java编程
八、如何做好准备？
| 如何做好准备？ 在学习本课程前，你应该已经完成了下列内容的学习： - SL-110 非程序员Java编程 - 用C或C++创建编译程序 - 用文本编辑器创建并编辑文本文件 - 使用World Wide Web（WWW）浏览器，如Netscape NavigatorTM |
在学习本课程前，你应该已经完成了下列内容的学习：
- SL-110 非程序员Java编程
或能够：
- 用C或C++创建编译程序
- 用文本编辑器创建并编辑文本文件
- 使用World Wide Web（WWW）浏览器，如Netscape NavigatorTM
九、自我介绍：
| 自我介绍 - 姓名 - 公司 - 职务、职责 - 编程经历 - 参与本课程学习的原因 - 对本课程的预期
|
现在你已经进入本课程的学习，请互相介绍并填写上面的表格。
十、如何使用本教材
| 如何使用本教材 - 课程图 - 相关问题 - 页头图 - 教程 - 练习 - 检查你的进度 - 思考题 |
为使你学好本课程，本教材采用了包括下列主要项目的授课模式：
l 课程图──每一模块都从内容概述开始，这样你就可以了解该模块在实现整个课程目标中所起的作用。
l 相关问题──每一模块的相关问题部分提供给你一些有关该模块的问题供学习者之间进行讨论，并鼓励你思考在Java应用程序编程过程中你的兴趣与该模块内容的关系
l 页头图──页头图可帮助你及时而轻松的跟上教师的进度。它并不是在每一页都出现
l 教程──教师将为你提供有关模块的特有信息，这些信息将有助于你掌握做练习所需要的知识和技能
l 练习──练习将为你提供测试你的技能和应用所学概念的机会。本教程中所提供的例题代码亦有助于你完成练习。
l 检查你的进度──在这一部分，模块的目标被重新提及，有时是以问题形式出现。这样，在你进入下一模块之前，就可以检查你是否已完成了目前这一模块所要求达到的目标。
l 思考题──具有挑战性的问题有助于你应用所学模块内容或预测待学模块的内容。
十一、图表和印刷体例说明
下列图表及印刷体例代表着不同的含义：
辅助资源──表示可获取辅助参考资料。
讨论──表示此时建议以小组或班级形式进行讨论。
练习目标──表示练习的目标，这个练习适合于正在讨论的内容。
注意──附加重要信息、强调信息、有趣或特殊信息
警告──对数据或机器的潜在损坏
印刷体例
字体Courier系用来表示命令名称、文件名及目录名，同时也表示计算机屏幕输出。例如：
Use ls –al to all files.
System% You have mail
黑体courier bold系用来表示你打印的字符和数字。
例如：
system% su
Password:
斜体courier italic系用来表示变量和命令行，它可以被实际名称或值所代替。
例如：
To delete a file, type rm filename.
斜体Palatino系用来表示书名、新词或术语或需强调的词。
例如：
Read Chapter 6 in User’s Guide.
These are called class options
You must be root to do this.
第一章 起 步
本模块对Java编程语言做了一般性描述，包括Java虚拟机、垃圾收集和安全性等。
第一节 相关问题
讨论──下列问题与本模块相关
- Java编程语言是一种完整的语言吗？它是不是仅用于编写Web程序 ？
- 你为什么需要另一种编程语言 ？
- Java平台是如何在其它语言平台上提高性能的 ？
第二节 目 标
完成本模块的学习后，你应该能够：
- 描述Java编程语言的主要特性
- 描述Java虚拟机的主要功能
- 描述垃圾收集是如何进行的
- 列举由处理代码安全性的Java平台所执行的三大任务
- 定义Class，Package，Applets和Applications
- 编写、编译并运行简单Java应用程序
- 利用Java技术应用程序编程界面(API)的在线文档来标识Java. lang包的方法。
参考资料
辅助资源──下列参考资料可为本模块所讨论的问题提供更详细的补充
- Lindholm and Yellin. 1997. The Java Virtual Machine Specification. Addison-Wesley.
- Yellin, Frank. Low-Level Security in Java, white paper. [Online]. Available:
http://www.javasoft.com/sfaq/verifier.html.
第三节 什么是Java编程语言 ？
| 什么是Java编程语言 Java是： - 一种编程语言 - 一种开发环境 - 一种应用环境 - 一种部署环境 - 句法与C++相似，语义与Small Talk相似 - 用来开发applets，又用来开发applications |
Java是：
- 一种编程语言
- 一种开发环境
- 一种应用环境
- 一种部署环境
Java编程语言的句法与C++的句法相似，语义则与Small Talk TM的语义相似。Java编程语言可被用来创建任何常规编程语言所能创建的应用程序。
在World Wide Web（WWW）和能够运行称为applets程序的浏览器的有关介绍中，人们经常提及Java编程语言。Applets是一种贮存于WWW服务器的用Java编程语言编写的程序，它通常由浏览器下载到客户系统中，并通过浏览器运行。Applets通常较小，以减少下载时间，它由超文本标识语言（HTML）的Web页来调用。
Java applications是一种独立的程序，它不需要任何Web浏览器来执行。它们是一种典型的通用程序；可运行于任何具备Java运行环境的设备中。
1.3.1 Java编程语言的主要目标
| Java编程语言的主要目标 提供一种解释环境为 - 提高开发速度 - 代码可移植性 - 使用户能运行不止一个活动线程 - 当程序运行时，能动态支持程序改变 提供更好的安全性 |
设计Java编程语言的主要目标是
提供一种易于编程的语言，从而
Ú 消除其它语言在诸如指针运算和存储器管理方面影响健壮性的缺陷。
Ú 利用面向对象的概念使程序真正地成为可视化程序
Ú 为使代码尽可能清晰合理、简明流畅提供了一种方法
| Java编程语言的主要目标 设计Java编程语言的主要目标是 提供一种易于编程的语言 - 消除其它语言在诸如指针运算和存储器管理方面影响健壮性的缺陷。 - 利用面向对象的概念使程序真正地成为可视化程序 - 为使代码尽可能清晰合理、简明流畅提供了一种方法 |
Java编程语言的主要目标（续）
- 为获得如下两点益处提供一种解释环境
Ú 提高开发速度──消除编译─链接—装载—测试周期。
Ú 代码可移植性──使操作系统能为运行环境做系统级调用
- 为运行不止一个活动线程的程序提供了一种方式
- 通过允许下载代码模块，从而当程序运行时也能动态支持程序改变。
- 为那些保证安全性而装载的代码模块提供了一种检查方法。
| Java编程语言的主要目标 下列特性使这些目标付诸实现： - Java虚拟机（JVM） - 垃圾收集 - 代码安全性
|
Java编程语言的主要目标（续）
精心开发的Java技术体系结构为上述目标的实现提供了保证。Java的如下特性使这些目标得以实现
- Java虚拟机
- 垃圾收集
- 代码安全性
1.3.2 Java虚拟机
| Java虚拟机 - 提供硬件平台规范 - 解读独立于平台的已编译的字节码 - 可当作软件或硬件来实现 - 可在Java技术开发工具或Web浏览器上实现 |
Java虚拟机规范为Java虚拟机（JVM）作了如下定义：
在真实机器中用软件模拟实现的一种想象机器。Java虚拟机代码被存储在 .class文件中；每个文件都包含最多一个public类。
Java虚拟机规范为不同的硬件平台提供了一种编译Java技术代码的规范，该规范使Java软件独立于平台，因为编译是针对作为虚拟机的“一般机器”而做，这个“一般机器”可用软件模拟并运行于各种现存的计算机系统，也可用硬件来实现。
| Java虚拟机 JVM为下列各项做出了定义 - 指令集（中央处理器［CPU］ ） - 注册集 - 类文件格式 - 栈 - 垃圾收集堆 - 存储区 |
Java虚拟机（续）
编译器在获取Java 应用程序的源代码后，将其生成字节码，它是为JVM生成的一种机器码指令。每个Java解释器，不管它是Java技术开发工具，还是可运行applets的Web浏览器，都可执行JVM。
JVM为下列各项做出了定义
- 指令集（相当于中央处理器［CPU］ ）
- 注册集
- 类文件格式
- 栈
- 垃圾收集堆
- 存储区
| Java虚拟机 - 由保持适当类型约束的字节码形成代码 - 大部分类型检查在编译代码时完成 - 每个由SUN TM批准的JVM必须能够运行任何从属类文件 |
Java虚拟机（续）
JVM的代码格式由紧缩有效的字节码构成。由JVM字节码编写的程序必须保持适当的类型约束。大部分类型检查是在编译时完成。
任何从属的Java技术解释器必须能够运行任何含有类文件的程序，这些类文件应符合Java虚拟机规范中所指定的类文件格式。
1.3.3 垃圾收集
|
垃圾收集 - 不再需要的分配存储器应取消分配 - 在其它语言中，取消分配是程序员的责任 - Java编程语言提供了一种系统级线程以跟踪存储区分配 - 垃圾收集 - 可检查和释放不再需要的存储器 - 可自动完成上述工作 - 可在JVM实现周期中，产生意想不到的变化 |
许多编程语言都允许在程序运行时动态分配存储器，分配存储器的过程由于语言句法不同而有所变化，但总是要将指针返回到存储区的起始位置
当分配存储器不再需要时（存储器指针已溢出范围），程序或运行环境应取消分配存储器。
在C，C++ 或其它语言中，程序员负责取消分配存储器。有时，这是一件很困难的事情。因为你并不总是事先知道存储器应在何时被释放。当在系统中没有能够被分配的存储器时，可导致程序瘫痪，这种程序被称作具有存储器漏洞。
Java编程语言解除了程序员取消分配存储器的责任，它可提供一种系统级线程以跟踪每一存储器的分配情况。在Java虚拟机的空闲周期，垃圾收集线程检查并释放那些可被释放的存储器。
垃圾收集在Java技术程序的生命周期中自动进行，它解除了取消分配存储器的要求，并避免了存储器漏洞。然而，垃圾收集可在JVM实现的周期中，产生意想不到的变化。
1.3.4 代码的安全性
概述
下图显示了Java技术的运行环境及其加强代码安全性的方法。
Java源程序文件通过“编译”，在你的感觉中，就好象是将它们从程序员编写的文本文件格式转换成了一组字节码。字节码被存储在 .class文件中。
构成Java软件程序的字节码在运行时被加载、校验并在解释器中运行。当运行applets时，字节码可被下载，然后由建于浏览器中的JVM进行解释。解释器具备两种功能，一是执行字节码，二是对底层硬件做适当调用。
在一些使用Java技术的运行环境中，部分校验过的字节码被编译成原始机器码并直接运行于硬件平台。这就使Java软件代码能够以C或C++接近的速度运行，只是在加载时， 因为要编译成原始机器码而略有延迟。
注意－－SUN MicrosystemsTM通过采用新的技术，使Java虚拟机的性能已经有了进一步的提高。这种新型虚拟机被称为HotSpotTM虚拟机，它具备了使Java编程语言能象编译C++一样快速运行的潜力。HotSpot虚拟机对操作系统具有本地多线程支持能力，而不是虚拟多线程。因而，HotSpot虚拟机可保证对一个应用程序来说，并不一定有代码才能使用这一能力。HotSpot技术解决了性能与移植性之间的难题。
|
Java运行环境
执行三大任务 - 加载代码 - 校验代码 - 执行代码
|
代码安全性（续）
Java运行环境
一个Java技术的运行环境可运行为JVM编译的代码并执行如下三大任务：
- 加载代码－由类加载器执行
- 校验代码－由字节码校验器执行
- 执行代码－由运行时的解释器执行
类加载器
类加载器为程序的执行加载所需要的全部类。类加载器将局部文件系统的类名空间与来自网络源的类名空间相分离，以增加安全性。由于局部类总是首先加载，因而可限制任何“特洛依木马”的应用。
当全部类被加载后，可执行文件的存储器格式被确定。这时，特定的存储器地址被分配给符号引用并创建检索表格。由于存储器格式在运行时出现，因而Java技术解释器增加了保护以防止对限制代码区的非法进入。
|
字节码校验 可保证 - 代码符合JVM规范 - 代码不破坏系统完整性 - 代码不会引起操作数栈上溢或下溢 - 所有操作代码的参数类型的准确性 - 无非法数据转换（整数到指针的转换） |
代码安全性（续）
字节码校验器
Java软件代码在实际运行之前要经过几次测试。JVM将代码输入一个字节码校验器以测试代码段格式并进行规则检查－－检查伪造指针、违反对象访问权限或试图改变对象类型的非法代码。
注意----所有源于网络的类文件都要经过字节码校验器
代码安全性（续）
校验过程
字节码校验器对程序代码进行四遍校验，这可以保证代码符合JVM规范并且不破坏系统的完整性。如果校验器在完成四遍校验后未返回出错信息，则下列各点可被保证：
- 类符合JVM规范的类文件格式
- 无访问限制违例
- 代码未引起操作数栈上溢或下溢
- 所有操作代码的参数类型将总是正确的
- 无非法数据转换发生，如将整数转换为对象引用
- 对象域访问是合法的
第四节 一个基本的Java应用程序
象其它编程语言一样，Java编程语言也被用来创建应用程序。一个共同的小应用程序范例是在屏幕上显示字串“Hello World!”。下列代码给出了这个Java应用程序。
1.4.1 HelloWorldApp
1.//
2.// Sample HelloWorld application
3.//
4.public class HelloWorldApp{
5.public static void main (String args[]) {
6.System.out.println ("Hello World!");
7.}
8.}
以上程序行是在你的屏幕上打印“Hello World!”所需的最少组件。
1.4.2 描述HelloWorldApp
第1-3行
程序中的1-3行是注释行
1 //
2 // Sample HelloWorld application
3 //
第4行
第4行声明类名为HelloWorldApp。类名（Classname）是在源文件中指明的，它可在与源代码相同的目录上创建一个classname·class文件。在本例题中，编译器创建了一个称为HelloWorldApp.class的文件, 它包含了公共类HelloWorldApp的编译代码。
4 public class HelloWorldApp｛
第5行
第5行是程序执行的起始点。Java技术解释器必须发现这一严格定义的点，否则将拒绝运行程序。
其它程序语言（特别是C和C++）也采用main ()声明作为程序执行的起始点。此声明的不同部分将在本课程的后几部分介绍。
如果在程序的命令行中给出了任何自变量，它们将被传递给main()方法中被称作args的String数组。在本例题中，未使用自变量。
5 public static void main (String args［］) ｛
- public－方法main()可被任何程序访问，包括Java技术解释器。
- static－ 是一个告知编译器main()是用于类HelloWorldApp中的函数的关键字。为使main()在程序做其它事之前就开始运行，这一关键字是必要的。
- void－ 表明main()不返回任何信息。这一点是重要的，因为Java编程语言要进行谨慎的类型检查，包括检查调用的方法确实返回了这些方法所声明的类型。
- String args [] － 是一个String数组的声明，它将包含位于类名之后的命令行中的自变量。
java HelloWorldApp args［0］args［1］····
第6行
第6行声明如何使用类名、对象名和方法调用。它使用由System类的out成员引用的PrintStreamout对象的println()方法，将字串“Hello World!”打印到标准输出上。
6 System.out.println (“Hello World!”);
在这个例子中，println()方法被输入了一个字串自变量并将其写在了标准输出流上。
第7-8行
本程序的7-8行分别是方法main()和类HelloWorldApp的下括号。
7 ｝
8 ｝
1.4.3 编译并运行HelloWorldApp
| 编译并运行HelloWorldApp - 编译HelloWorldApp.java javac HelloworldApp.java - 运行应用程序 java HelloWorldApp - 判定编译和运行的共同错误 |
编译
当你创建了HelloWorldApp.java源文件后，用下列程序行进行编译：
c:/student/javac HelloWorldApp.java
如果编译器未返回任何提示信息，新文件HelloWorldApp.class则被存储在与源文件相同的目录中，除非另有指定。
如果在编译中遇到问题，请参阅本模块的查错提示信息部分。
运行
为运行你的HelloWorldApp应用程序，需使用Java解释器和位于bin目录下的java:
c:/student/ java HelloWorldApp
Hello World!
注意－必须设置PATH环境变量以发现java和javac，确认它包括c:/jdk1.2/bin
1.4.4 编译查错
编译时的错误
以下是编译时的常见错误
- javac:Command not found
PATH变量未正确设置以包括javac编译器。javac编译器位于JDK目录下的bin目录。
- HelloWorldApp.java:6: Method printl(java.lang.String)
not found in class java.io.PrintStream.System.
out.printl ("Hello World!");
方法名println 出现打印错误。
- In class HelloWorldApp:main must be public or static
该错误的出现是因为词static 或public被放在了包含main方法的行之外。
运行时的错误
- can’t find class HelloWorldApp （这个错误是在打印java HelloWorldApp时产生的）
通常, 它表示在命令行中所指定的类名的拼写与filename.class文件的拼写不同。Java编程语言是一种大小写区别对待的语言。
例如： public class HelloWorldapp {
创建了一个HellloWorldapp.class，它不是编译器所预期的类名(HelloWorldApp.class)。
- 命名
如果·java文件包括一个公共类，那么它必须使用与那个公共类相同的文件名。例如在前例中的类的定义是
public class HelloWorldapp
源文件名则必须是HelloWorldapp.java
- 类计数
在源文件中每次只能定义一个公共类。
源文件布局
| 源文件布局 包含三个“顶级”要素 - 一个可选择的包声明 - 任意数量的输入语句 - 类和界面声明 |
一个Java源文件可包含三个“顶级”要素：
- 一个包声明（可选）
- 任意数量的输入语句
- 类和界面声明
该三要素必须以上述顺序出现。即，任何输入语句出现在所有类定义之前；如果使用包声明，则包声明必须出现在类和输入语句之前。
第五节 类和包介绍
| 类和包介绍 1. 什么是类和包？ 2. Java类库中的几个重要包 java.lang java.awt java.applet java.net java.io java.util |
类是描述提供某种功能的模块的一般术语。Java开发集（JDK）给出了一套标准的类（称作类库），这些类可执行大部分所需的基本行为 不仅为编程任务（例如，类可提供基本的数学函数、数组和字符串），而且为图形和网络。
类库被组织成许多包，每个包都包含几个类。如下所列为一些重要的包：
java.lang包含一些形成语言核心的类，如String、Math、Integer和Thread。
java.awt包含了构成抽象窗口工具包（AWT）的类，这个包被用来构建和管理应用程序的图形用户界面。
java.applet包含了可执行applet特殊行为的类。
java.net包含执行与网络相关的操作的类和处理接口及统一资源定位器(URLs)的类。
java.io包含处理I/O文件的类。
java.util包含为任务设置的实用程序类，如随机数发生、定义系统特性和使用与日期日历相关的函数。
第六节 使用Java API文档
| 使用Java API文档 1. 一组超文本标识语言(HTML)文件提供了有关API的信息 2. 一个包包含了对所有类信息的超链接 3. 一个类文档包括类层次、一个类描述、一组成员变量和构造函数等 |
一组HTML文件以文档的形式提供了有关API的信息，这个文档的布局是等级制的，因而主页列出所有的包为超链接。如果选中了一个特殊包的热链接，作为那个包成员的类将被列出。从一个包页选中一个类的热链接将提交一页有关那个类的信息。
图1-1显示了这样一个类文档
图1-1
一个类文档的主要部分包括:
- 类层次
- 类和类的一般目的描述
- 成员变量列表
- 构造函数列表
- 方法列表
- 变量详细列表及目的和用途的描述
- 构造函数详细列表及描述
- 方法详细列表及描述
练习：基本任务
练习目标－－在本练习里，你将利用Java API文档练习如何识别包、类和方法并练习标准输入输出方法。你还将编写、编译和运行两个简单的使用这些方法的应用程序。
一、准备
理解本模块中提出的概念和术语对理解文件和运用文件信息编写程序至关重要。
二、任务
1级：阅读文件
1.你的老师将指导你如何启动API浏览器并打开Java API在线文档的索引页。
2.找到java.lang包
3.在此包中定义了那些类？在System类中有那些方法？System.out.println方法是在什么包中定义的？什么是标准输入方法调用？
2级：创建一个Java应用程序
1.使用任意文本编辑器，创建一个可打印你选定的字串的与HelloWorldApp类似的应用程序。
2.编译程序并纠正错误。
3.用解释器运行程序。
3级：使用标准输入和标准输出
编写一个称为MyCat的应用程序，它将从stdin中读出一行并将这一行写回到stdout. 无论stdin还是stdout都在java.lang.System类中。
三、检查你的进度
在进入下一模块之前，请确认你已经能够：
- 描述Java编程语言的主要特性
- 描述JVM
- 描述垃圾收集是如何进行的
- 列出由处理代码安全性的Java平台所执行的三个任务
- 定义术语类、包、applets和application
- 编写、编译并运行一个简单的Java应用程序
- 使用Java技术应用程序编程界面(API)的在线文档识别java.lang包中的方法。
四、思考题
使用Java编程语言将为你的工作带来什么益处？
第二章 标识符、关键字和类型
本模块阐述了在Java技术程序中使用的基本元素，包括变量、关键字、原始类型和类类型。
第一节 相关问题
讨论──下列问题与本模块阐述的论题相关。
- 你是如何理解类的？
- 你是如何理解一个对象的？
第二节 目标
完成本模块的学习后，你应该能够：
- 在一个源程序中使用声明
- 区分有效和无效标识符
- 确认Java技术关键字
- 列出八个原始类型
- 为数字类型和文本类型定义文字值
- 定义术语class、object、member variable和reference variable
- 为一个简单的包含原始成员变量的类创建一个类定义
- 声明类类型变量
- 使用new构造一个对象
- 描述缺省初始化
- 使用点符号访问一个对象的成员变量
- 描述一个参考变量的意义
- 规定分配类类型变量的结果
第三节 注 释
| 注释 三种允许的Java技术程序注释风格 //comment on one line /* comment on one or more line */ /** documenting comment */ |
2.3.1 概述
有三种插入注释的允许风格：
//comment on one line
/* comment on one or more line */
/** documenting comment */
紧放在声明(变量、方法或类的声明)之前的文档注释表明, 注释应该被放在自动生成的文档中(由javadoc命令生成的HTML文件)以当作对声明项的描述。
注意------有关这些注释的格式和 javadoc工具的使用，请见JDK1.2 API文件的 docs/tooldocs/win32目录
2.3.2 分号、块和空白
| 分号、块和空白 - 一个语句是一行用分号(；) 终止的代码 totals=a+b+c+d+e+f； - 一个块是以上括号和下括号为边界的语句集合 { x=y+1 y=x+1 } |
在Java编程语言中，语句是一行由分号(;)终止的代码。
例如
totals=a+b+c+d+e+f；
与下式相同
total=a+b+c+
d+e+f；
一个块(block)或一个复合语句是以上括号和下括号（{}）为边界的语句集合；块语句也被用来组合属于某个类的语句。
分号、块和空白（续）
| 分号、块和空白 - 一个块可被用在一个类的定义中 public class Date { int day; int month; int year; } - 块语句可被嵌套 - Java程序中允许任意多的空白 |
语句块可被嵌套。HelloWorldApp类由main方法构成，这个方法就是一个语句块，它是一个独立单元，单元本身可作为在类HelloWorldApp块中的一组事务之一。
其它一些块语句或组的例子如下：
// a block statement
{
x = y + 1;
y = x + 1;
}
Semicolons, Blocks, and Whitespace
// a block used in a class definition
public class MyDate {
int day;
int month;
int year;
}
// an example of a block statement nested within
// another block statement
while ( i < large ) {
a = a + i;
if ( a == max ) {
b = b + a; // nested block is here
a = 0;
}
}
在源代码元素之间允许空白，空白的数量不限。空白(包括空格、tabs和新行)可以改善你的对源代码的视觉感受。
{
int x;
x = 23 * 54;
}
{
int x
x = 23 + 54;
}
第四节 标识符
| 标识符 - 是赋予变量、类和方法的名称 - 可从一个字母、下划线(_)或美元符号($)开始 - 是大小写区别对待的, 且无最大长度 |
在Java编程语言中，标识符是赋予变量、类或方法的名称。标识符可从一个字母、下划线(_)或美元符号($)开始，随后也可跟数字。标识符是大小写区别对待的并且未规定最大长度。
有效标识符如下：
- identifier
- userName
- User_name
- _sys_varl
- $change
Java技术源程序采用有效的16-bit 双字节字符编码标准(Unicode) ，而不是8-bit ASCII文本。因而，一个字母有着更广泛的定义，而不仅仅是a到z和A到Z。
谨慎对待非ASCII字符，因为Unicode可支持看似相同而实际不同 的字符。
标识符不能是关键字，但是它可包含一个关键字作为它的名字的一部分。例如，thisone是一个有效标识符，但this却不是，因为this是一个Java关键字。Java关键字将在后面讨论。
注意──包含美元符号（$）的关键字通常用的较少， 尽管它在BASIC和VAX/VMS系统语言中有着广泛的应用。由于它们不被熟知，因而最好避免在标识符中使用它们， 除非有本地使用上的习惯或其他不得已的原因。
第五节 Java关键字
表2-1列出了使用在Java编程语言中的关键字。
abstract do implements private throw
boolean double import protected throws
break else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized
default if package this
关键字对Java技术编译器有特殊的含义，它们可标识数据类型名或程序构造（construct）名。
以下是有关关键字的重要注意事项：
- true、false和null为小写，而不是象在C++语言中那样为大写。严格地讲，它们不是关键字，而是文字。然而，这种区别是理论上的。
- 无sizeof运算符；所有类型的长度和表示是固定的，不依赖执行。
- goto和const不是Java编程语言中使用的关键字。
第六节 基本Java类型
| Java编程语言定义了八个原始类型 - 逻辑类 boolean - 文本类 char - 整数类 byte, short, int, long - 浮点类 double, float |
2.6.1 原始类型
Java编程语言为八个原始数据类型和一个特殊类型定义了文字值。原始类型可分为四种：
- 逻辑类 boolean
- 文本类 char
- 整数类 byte, short, int, long
- 浮点类 double, float
2.6.2 基本Java类型
1.逻辑类──boolean
|
逻辑类──boolean boolean 数据类型有两种文字值：true和false。 例如：boolean truth = true； 上述语句声明变量truth为boolean 类型，它被赋予的值为true。 |
逻辑值有两种状态，即人们经常使用的“on”和“off” 或“true”和“false”或“yes”和“no”，这样的值是用boolean类型来表示的。boolean有两个文字值，即true和false。以下是一个有关boolean类型变量的声明和初始化：
boolean truth = true; //declares the variable truth
//as boolean type and assigns it
//the value true
注意──在整数类型和boolean类型之间无转换计算。有些语言（特别值得强调的是C和C++）允许将数字值转换成逻辑值，这在Java编程语言中是不允许的；boolean类型只允许使用boolean值。
2.文本类──char和String
| 文本类──char和String char - 代表一个16-bit Unicode字符 - 必须包含用单引号（’’）引用的文字 - 使用下列符号： ‘a’ ‘/t’ 一个制表符 ‘/u????’ 一个特殊的Unicode字符，????应严格使用四个16进制数进行替换 |
使用char类型可表示单个字符。一个char代表一个16-bit无符号的（不分正负的）Unicode字符。一个char文字必须包含在单引号内(‘’)。
‘a’
‘/t’ 一个制表符
‘/u????’ 一个特殊的Unicode字符。????应严格按照四个16进制数字进行替换
String不是原始类型，而是一个类（class），它被用来表示字符序列。字符本身符合Unicode标准，且上述char类型的反斜线符号适用于String。与C和C++不同，String不能用 /0作为结束。
| 文本类──char和String String - 不是一个原始数据类型，它是一个类 - 具有用双引号引用的文字 “The quick brown fox jumped over the lazy dog.” - 可按如下情形使用： String greeting = “Good Morning!! /n”； String err_meg = “ record not found !”;
|
文本类──char和String (续)
String的文字应用双引号封闭，如下所示：
“The quick brown fox jumped over the lazy dog.”
Char和String类型变量的声明和初始化如下所示：
char ch = `A'; // declares and initializes a char variable
char ch1,ch2 ; // declares two char variables
// declare two String variables and initialize them
String greeting = "Good Morning !! /n" ;
String err_msg = "Record Not Found !" ;
String str1,str2 ; // declare two String variables
2.6.3 整数类──byte, short, int, long
|
整数类──byte, short, int, long
l 采用三种进制──十进制、八进制和16进制 2 十进制值是2 077 首位的0表示这是一个八进制的数值 0xBAAC 首位的0x表示这是一个16进制的数值 l 具有缺省int l 用字母“L”和“l”定义long
|
在Java编程语言中有四种整数类型，每种类型可使用关键字byte, short, int和long中的任意一个进行声明。整数类型的文字可使用十进制、八进制和16进制表示，如下所示：
2 十进制值是2
077 首位的0表示这是一个八进制的数值
0xBAAC 首位的0x表示这是一个16进制的数值
注意──所有Java编程语言中的整数类型都是带符号的数字。
整数类──byte, short, int, long（续）
整数类文字属int类型，除非在其后直接跟着一个字母“L”。L表示一个long值。请注意，在Java编程语言中使用大写或小写L同样都是有效的，但由于小写l与数字1容易混淆，因而，使用小写不是一个明智的选择。上述文字的long的形式如下：
2L 十进制值是2，是一个long
077L 首位的0表示这是一个八进制的数值
0xBAACL 前缀0x表示这是一个16进制的数值
| 整数类──byte, short, int, long 每个整数数据类型具有下列范围： Integer Length Name or Type Range 8 bits byte -2 7 ... 2 7 -1 16 bits short -2 15 ... 2 15 -1 32 bit int -2 31 ... 2 31 -1 64 bits long -2 63 ... 2 63 -1 |
整数类──byte, short, int, long（续）
四个整数类型的长度和范围如表2-2所示。范围的表示是按Java编程语言规范定义的且不依赖于平台。
表2-2 整数数据类型—范围
Integer Length Name or Type Range
8 bits byte -2 7 ... 2 7 -1
16 bits short -2 15 ... 2 15 -1
32 bit int -2 31 ... 2 31 -1
64 bits long -2 63 ... 2 63 -1
2.6.4 浮点──float和double
| 浮点──float和double - 缺省为double - 浮点文字包括小数点或下列各项之一 - E或e (增加指数值) - F或f (float) - D或d （double） 3.14 一个简单的浮点值（a double） 4.02E23 一个大浮点值 2.718F 一个简单的float长度值 123.4E+306D 一个大的带冗余D的double值 |
浮点变量可用关键字float或double来声明，下面是浮点数的示例。如果一个数字文字包括小数点或指数部分，或者在数字后带有字母F或f（float）、D或d（double），则该数字文字为浮点。
3.14 一个简单的浮点值（a double）
4.02E23 一个大浮点值
2.718F 一个简单的float长度值
123.4E+306D 一个大的带冗余D的double值
| 浮点──float和 double 浮点数据类型具有下列范围： 浮点长度 名称或类型 32 bits float 64 bits double |
浮点──float和 double（续）
表2—3 浮点数据类型──范围
浮点长度 名称或类型
32 bits float
64 bits double
注意──浮点文字除非明确声明为float，否则为double
第七节 变量、声明和赋值
Java技术规范的浮点数的格式是由电力电子工程师学会（IEEE）754定义的，它使用表2—3的长度，并且是独立于平台的。
下列程序显示了如何为整数、浮点、boolean、字符和string类型变量声明和赋值。
1. public class Assign {
2. public static void main(String args []) {
3. int x, y; // declare int
// variables
4.float z = 3.414f; // declare and assign
// float
5.double w = 3.1415; // declare and assign
// double
6.boolean truth = true; // declare and assign
// boolean
7.char c; // declare character
// variable
8.String str; // declare String
9.String str1 = "bye"; // declare and assign
// String variable
10.c = 'A'; // assign value to char
// variable
11.str = "Hi out there!"; // assign value to
// String variable
12.x = 6;
13.y = 1000; // assign values to int variables
14....
15.}
16.}
非法赋值举例
y = 3.1415926; // 3.1415926 is not an int.
// Requires casting and decimal will
// be truncated.
w = 175,000; // the comma symbol ( , ) cannot appear
truth = 1; // a common mistake made by ex- C / C++
// programmers.
z = 3.14156 ; //can't fit double into a
//Float. Requires casting.
第八节 Java编码约定
|
Java编码约定 l 类： class AccountBook class ComplexVariable l 界面： interface Account l 方法： balanceAccount（） addComplex （） |
Java编程语言的一些编码约定是：
classes──类名应该是名词，大小写可混用，但首字母应大写。例如：
class AccountBook
class ComplexVariable
interface──界面名大小写规则与类名相同。
interface Account
method──方法名应该是动词，大小写可混用，但首字母应小写。在每个方法名内，大写字母将词分隔并限制使用下划线。例如：
balanceAccount（）
addComplex （）
|
Java编码约定 l 变量 currentCustomer l 常量 HEAD-COUNT MAXIMUM-SIZE |
Java编码约定
Variables──所有变量都可大小写混用，但首字符应小写。词由大写字母分隔，限制用下划线，限制使用美元符号（$），因为这个字符对内部类有特殊的含义。
currentCustomer
变量应该代表一定的含义，通过它可传达给读者使用它的意图。尽量避免使用单个字符， 除非是临时“即用即扔”的变量（例如，用i, j, k作为循环控制变量）
constant──原始常量应该全部大写并用下划线将词分隔；对象常量可大小写混用。
HEAD-COUNT
MAXIMUM-SIZE
control structures──当语句是控制结构的一部分时，即使是单个语句也应使用括号（｛｝）将语句封闭。例如：
if (condition) ｛
do something
｝else ｛
do something else
｝
spacing── 每行只写一个语句并使用四个缩进的空格使你的代码更易读。
comments──用注释来说明那些不明显的代码段落；对一般注释使用 // 分隔符， 而大段的代码可使用 /*···*/分隔符。使用 /**···*/将注释形成文档，并输入给javadoc以生成HTML代码文档。
// A comment that takes up only one line.
/* Comments that continue past one line and take up space on multiple lines...*/
/** A comment for documentation purposes.
@see Another class for more information
*/
注意──@see是一个有关类或方法的特殊的javadoc标记符（”see also”）。有关javadoc的详细资料， 请参见“The Design of Distributed Hyperlinked Programming Documentation”(Lisa著)的有关文档系统的完整定义。该资料可从下列地址获得：http://www.javasoft.com/doc/api_documentation.html.
第九节 理解对象
|
理解对象 l 回顾对象的历史 l 创建一个新的类型，如date public class date｛ int day; int month; int year; ｝ l 声明一个变量 Date myBirth, yourBirth l 访问成员 myBirth.day = 26; myBirth.month = 11; yourBirth.year = 1960;
|
2.9.1 回顾对象的历史
早些时候的编程语言和初级程序员将每个变量看作相互无关的实体。例如，如果一个程序需处理某个日期，则要声明三个单独的整数：
int day, month, year;
上述语句作了两件事，一是当程序需要日、月或年的有关信息时，它将操作一个整数； 二是为那些整数分配存储器。
尽管这种作法很容易理解，但它存在两个重大缺陷。首先，如果程序需同时记录几个日期，则需要三个不同的声明。例如，要记录两个生日，你可能使用：
int myBirthDay, myBirthMonth, myBirthYear;
int yourBirthDay, yourBirthMonth, yourBirthYear;
这种方法很快就会引起混乱，因为需要的名称很多。
第二个缺陷是这种方法忽视了日、月和年之间的联系并把每个变量都作为一个独立的值，每个变量都是一个独立单元(在本例中为date)的一部分并被相应地处理。
2.9.2 创建一个新类型
为克服上述两种缺陷，Java编程语言使用类来创建新类型。请看下列原始类型声明：
int day;
Java编程语言被用来分配一定量的存储器并解释该存储器的内容。于是，要定义一个新的类型，你必须指出需要多大存储器和如何解释存储器内容。这不是根据字节数或位的顺序和含义来做，而是根据已经定义的其它类型来做。
例如，要定义一个表示日期的类型，你需要足够的存储器存储三个整数变量；进而，日、月和年的意义即由这些整数变量给出。如下所示：
class MyDate {
int day;
int month;
int year;
}
词class是Java编程语言的一个关键字，必须全部小写。名称MyDate按照大小写的有关约定处理，而不是由语意要求来定。
注意----- class 不仅仅是一个集合数据类型，这个问题以后还将进一步讨论。
一个变量可被声明为归属于类型MyDate，从而日、月和年部分将被隐含声明。例如：
MyDate myBirth, yourBirth;
使用这个声明，Java编程语言允许变量的部分(day, month和year)通过调用成员和使用点(·)运算符而被访问。例如：
myBirth.day = 26;
myBirth.month = 11;
yourBirth.year = 1960;
2.9.3 创建一个对象
|
创建一个对象 - 原始类型的声明可分配存储器空间 - 非原始类型的声明不分配存储器空间 - 声明的变量不是数据本身, 而是数据的引用(或指针) |
当任何原始类型(如boolean, byte, short,char,int,long,float或double类型) 的变量被声明时，作为上述操作的一部分，存储器空间也同时被分配。使用非原始类型(如String或class)的变量的声明不为对象分配存储器空间。
事实上，使用class类型声明的变量不是数据本身，而是数据的引用(reference)。
注意----你也可以认为引用是一个指针(pointer), 这可能会有助于你的理解。实际上, 在大多数实现中, 也确实可以这样认为。值得注意的是, Java编程语言实际上不支持指针数据类型。
在你可以使用变量之前，实际存储器必须被分配。这个工作是通过使用关键字new来实现的。如下所示：
MyDate myBirth;
myBirth = new MyDate ();
第一个语句(声明)仅为引用分配了足够的空间，而第二个语句则通过调用对象为构成MyDate的三个整数分配了空间。对象的赋值使变量myBirth重新正确地引用新的对象。这两个操作被完成后，MyDate对象的内容则可通过myBirth进行访问。
假使定义任意一个class XXXX, 你可以调用new XXXX () 来创建任意多的对象，对象之间是分隔的。一个对象的引用可被存储在一个变量里，因而一个”变量点成员”(如myBirth.day)可用来访问每个对象的单个成员。请注意在没有对象引用的情况下，仍有可能使用对象，这样的对象称作”匿名”对象。
2.9.4 创建一个对象----存储器分配和布局
|
创建一个对象----存储器分配和布局 一个声明仅为一个引用分配存储器 MyDate today today = new MyDate(); today |
|
???? |
在一个方法体中，声明
MyDate today
today = new MyDate();
仅为一个引用分配存储器
|
???? |
关键字new意味着存储器的分配和初始化
MyDate today;
today = new MyDate();
赋值则建立了引用变量，从而它可适当地引用新的创建对象
MyDate today;
today = new MyDate();
使用一个语句同时为引用today和由引用today所指的对象分配空间也是可能的。
MyDate today = new MyDate ();
2.9.5 引用类型的赋值
|
引用变量的赋值 请考虑下列代码片段： int x = 7; int y = x; String s = “Hello”; String t = s; |
在Java编程语言中，用类的一个类型声明的变量被指定为引用类型，这是因为它正在引用一个非原始类型，这对赋值具有重要的意义。请看下列代码片段：
int x = 7;
int y = x;
String s = “Hello”;
String t = s;
四个变量被创建：两个原始类型 int 和两个引用类型String。x的值是7，而这个值被复制到y；x 和 y是两个独立的变量且其中任何一个的进一步的变化都不对另外一个构成影响。
至于变量 s 和 t，只有一个String 对象存在, 它包含了文本”Hello” ，s 和 t均引用这个单一的对象。
将变量t 重新定义，则新的对象World被创建，而 t 引用这个对象。上述过程被描述如下：
2.9.6 术语回顾
|
术语回顾 - Class - Object - Reference type - member
|
本模块中介绍了几个术语，简单回顾如下：
- 类------在Java编程语言中定义新类型的一种途径。类声明可定义新类型并描述这些类型是如何实现的。有许多关于类的其它特性还未讨论。
- 对象------一个类的实例。类可被认为是一个模板------你正在描述一个对象模型。一个对象就是你每次使用new创建一个类的实例的结果。
- 引用类型------一个用户定义类型, 它可引用类、界面和数组。
- 成员------构成一个对象的元素之一。这个词也被用作定义类的元素(elements)。成员变量(member variabl)、实例变量(instance variable)和域(field)也经常被互换使用。
练习：使用对象
练习目标──正确使用Java关键字，编写一个创建类的程序并从类创建一个对象。编译并运行程序，然后校验引用是否被赋值并检查引用是不是按照本模块所描述的那样操作的。
一、准备
为了成功地完成本练习，你必须能够编译并运行Java程序，并且需要熟悉有关类和对象的面向对象的概念和引用的概念。
二、任务
1级：创建一个类和相应的对象
1. 一个点可用x和y坐标描述。定义一个称为MyPoint的类来表达上述想法。你应该称这个文件为什么?
2. 在你的类中编写一个类方法，然后为类型MyPoint声明两个变量，将变量称为start和end；用new MyPoint()创建对象并分别将引用值赋予变量start和end；
3. 将值10赋予对象start的成员x和y；
4. 将值20赋予对象end的x值，将值20赋予对象end的y值。
5. 分别打印MyPoint对象(start和end)的成员值(x和y)。
注意----为完成第5步，你需要更多地了解system类。带自变量String的System.out.println()可输出string并开始新的一行，而System.out.print()不开始新的一行。如果你使用System.out.print()，你应该在这个应用程序结束之前，调用System.out.println()或System.out.flush()，否则你会发现，输出的最后一行未被显示出来。
为显示数字，你可以使用下列形式(稍后将在本课程中讨论)
System.out.println(“Start MyPoint = x：“+start.x + “ y “ + start.y);
注意--如果一个操作数已经是一个String, 则加号(+)将另一个操作数转换成String。
6. 编译并运行程序。
2级：检验引用赋值
使用你在前一个练习中MyPoint类，增加代码到main()方法，以完成下列事项：
1. 为类型MyPoint声明一个新的变量，称之为stray。将现存变量end的引用值赋予stray；
2. 打印end和stray变量的成员x和y的值；
3. 赋予变量stray的成员x和y新的值；
4. 打印end和stray的成员的值；编译并运行MyPoint类。end的值反映了stray内的变化，表明两个变量都引用了同一个MyPoint对象；
5. 将start变量的成员x和y赋予新的值；
6. 打印start和end的成员值; 再次编译并运行MyPoint类，start的值仍然独立于stray和end的值，表明start变量仍然在引用一个MyPoint对象，而这个对象与stray和end引用的对象是不同的。
三、练习小结
讨论──用几分钟的时间讨论一下在以上练习中你所获得的经验、感想和发现。
经验 解释 总结 应用
四、检查你的进度
在进入下一模块之前，请确认你已经能够：
- 在源程序中使用注释
- 区分有效和无效标识符
- 识别Java技术关键字
- 列出八个原始类型
- 为数字和文本类型定义文字值
- 定义术语class, object,member,variable,referrence variable
- 为一个简单的包含原始成员变量的类创建一个类定义
- 声明类类型的变量
- 使用new构造一个对象
- 描述缺省初始化
- 使用点符号访问一个对象的成员变量
- 描述引用变量的意义
- 陈述分配类类型变量的结果
五、思考题
在你现有应用程序中，你可以构思一个使用类和对象的例子吗
第三章 表达式和流程控制
本模块讨论变量、运算符和算术表达式并列出不同的管理运行程序路径的控制结构。
第一节 相关问题
讨论──下列问题与本模块阐述的论题相关。
- 什么类型的变量对程序员有用(例如，其它语言的程序员想了解Java编程语言是如何定义和处理全局变量和局部变量的) ？
- 复合类可以有同名的变量吗？如果可以，它们的作用域有多大？
- 列出用于其它语言的控制结构；一般语言都采用什么方法进行流程控制和中断流程(如在循环或开关语句中) ？
第二节 目 标
完成本模块的学习后，你应该能够：
- 区分实例变量和局部变量；
- 描述实例变量是如何被初始化的；
- 确认并更正编译器错误；
- 辨认、描述并使用Java软件运算符；
- 区分合法和非法原始类型赋值；
- 确认boolean表达式和它们在控制构造中的要求；
- 辨认赋值兼容性和在基本类型中的必要计算；
- 使用if, switch,for,while和do句型结构和break和continue的标号形式作为程序中的流程控制结构。
第三节 表达式
3.3.1 变量和作用域
|
变量和作用域
- 局部(local)变量是在一个方法内定义的变量, 也被称作自动（automatic）、临时（temporary）或栈（stack）变量 - 当一个方法被执行时, 局部变量被创建；当一个方法被终止时, 局部变量被清除 - 局部变量必须使用之前初始化, 否则编译时将出错 |
你已经看到了两种变量的描述方法：原始类型变量和引用类型变量。你也看到了变量被声明的位置：在方法内(方法是面向对象的术语，它可引用函数或子程序，例如：main())或在方法外但在类定义之内。变量也可被定义为方法参数或构造函数参数。
在方法内定义的参数被称为局部(local)变量，有时也被用为自动（automatic）、临时（temporary）或栈（stack）变量。
在方法外定义的变量是在使用new Xxxx ()调用构造一个对象时被创建。在构造一个对象时，可创建两种变量。一是类变量，它是用static关键字来声明的；只要需要对象，类变量就将存在。二是实例变量，它不需用static关键字来声明；只要对象被当作引用，实例变量就将存在。实例变量有时也被用作成员变量，因为它们是类的成员。
方法参数变量定义在一个方法调用中传送的自变量，每次当方法被调用时，一个新的变量就被创建并且一直存在到程序的运行跳离了该方法。
当执行进入一个方法时，局部变量被创建，当执行离开该方法时，局部变量被取消。因而，局部变量有时也被引用为“临时或自动”变量。在成员函数内定义的变量对该成员变量是“局部的”，因而，你可以在几个成员函数中使用相同的变量名而代表不同的变量。 该方法的应用如下所示：
class OurClass {
int i; // instance variable of class OurClass
int firstMethod() {
int j=0; // local variable
// both i and j are accessible from
// this point
...
return 1;
} // end of firstMethod()
int secondMethod(float f) { //method parameter
int j=0; //local variable. Different from the
// j defined in firstMethod().
// Scope is limited to the body of
// secondMethod().
// Both i(instance variable of the
// class OurClass) and j (local
// variable of this method) are
// accessible from this point.
....
return 2;
} // end of secondMethod()
} // end of class OurClass
3.3.2 变量初始化
在Java程序中，任何变量都必须经初始化后才能被使用。当一个对象被创建时，实例变量在分配存储器的同时被下列值初始化：
byte
0
short
0
int
0
long
0L
float
0.0f
double
0.0d
char
'/u0000' (NULL)
boolean
false
All reference types
Null
注意── 一个具有空值的引用不引用任何对象。试图使用它引用的对象将会引起一个异常。异常是出现在运行时的错误，这将在模块7“异常”中讨论。
在方法外定义的变量被自动初始化。局部变量必须在使用之前做“手工”初始化。如果编译器能够确认一个变量在初始化之前可被使用的情形，编译器将报错。
public void doComputation() {
int x = (int)(Math.random() * 100);
int y;
int z;
if (x > 50) {
y = 9;
}
z = y + x; // Possible use before initialization
}
3.3.3 运算符
Java软件运算符在风格和功能上都与C和C++极为相似。表3-1按优先顺序列出了各种运算符（“L to R”表示左到右结合，“R to L”表示右到左结合）
Separator [] () ; ,
R to L ++ -- + - ~ ! (data type)
L to R * / %
L to R + -
L to R << >> >>>
L to R < > <= >= instanceof
L to R == !=
L to R &
L to R ^
L to R |
L to R &&
L to R ||
R to L ?:
R to L = *= /= %= += -= <<= >>= >>>= &= ^= |=
注意──instanceof是Java编程语言特有的运算符，将在模块5“对象和类”中讨论
3.3.4 逻辑表达式
|
逻辑表达式 支持的位运算符如下： ！──NOT &──AND ｜──XOR ^──OR 布尔运算符如下： ~ ──Complement(取反) &──AND ^──XOR ｜ ｜──OR
|
多数Java运算符是从其它语言借取得并且和人们一般期待的功能一样。
关系和逻辑运算符返回布尔结果，int到boolean不能自动转换。
int i = 1;
if ( i ) //generates a compile error
if (i !=0) // Correct
支持的位运算符是！、&、｜、^， 支持的布尔逻辑运算符是NOT、AND、XOR和OR。每个运算都返回布尔结果。运算符&&和｜｜是运算符&和｜的布尔等价物。布尔逻辑运算符将在下一页中讨论。
3.3.5 位运算
Java编程语言支持整数数据类型的位运算，它们的运算符~、&、^和｜分别表示位运算的NOT（为求反）、位AND、位XOR和位OR。移位运算符将稍后在本课程中讨论。
3.3.6 布尔逻辑运算符
|
布尔逻辑运算符 l 运算符是&&(AND)和｜｜（OR） l 运算符使用举例： 见3-11页程序
|
运算符&& (定义为AND)和｜｜（定义为OR）执行布尔逻辑表达式。请看下面的例子：
MyDate d = null;
if ((d! = null) && (d,day() > 31)) ｛
// do something with d
｝
形成if ()语句自变量的布尔表达式是合法且安全的。这是因为当第一个子表达式是假时，第二个子表达式被跳过，而且当第一个子表达式是假时，整个表达式将总是假，所以不必考虑第二个子表达式的值。类似的，如果使用｜｜运算符，而且第一个表达式返回真， 则第二个表达式不必求值，因为整个表达式已经被认为是真。
3.3.7 用加号（+）进行串链接
| 用加号（+）进行串链接 运算符 + 能够： l 进行String链接 l 生成一个新的String 例如： String salutation = "Dr. "; String name = "Jack " + "Arthur"; String title = salutation + name; 最后一行的结果是： Dr. Jack Arthur 一个自变量必须是String对象 非串被自动转换为String对象 |
运算符 + 能够进行String对象的链接并生成一个新的String：
String salutation = "Dr. ";
String name = "Jack " + "Arthur";
String title = salutation + name;
最后一行的结果是：
Dr. Jack Arthur
如果+运算符中有一个自变量为String对象，则其它自变量将被转换成String。所有对象都可被自动转换成String，尽管这样做的结果可能是意义含糊的。不是串的对象是通过使用toString() 成员函数而转换成串的等价物的。
3.3.8 右移位运算符>>和>>>
|
右移位运算符>>和>>>
算术或符号右移位如下所示： 见3-13页 l 在移位的过程中， 符号位被拷贝 逻辑或非符号右移位运算符(>>>) l 作用于位图 l 在移位的过程中， 符号位不被拷贝
|
Java编程语言提供了两种右移位运算符
运算符>>进行算术或符号右移位。移位的结果是第一个操作数被2的幂来除，而指数的值是由第二个数给出的。例如：
128 >> 1 gives 128/2 1 = 64
256 >> 4 gives 256/2 4 = 16
-256 >> 4 gives -256/2 4 = -16
逻辑或非符号右移位运算符>>>主要作用于位图，而不是一个值的算术意义；它总是将零置于最重要的位上。例如：
1010 ... >> 2 gives 111010 ...
1010 ... >>> 2 gives 001010 ...在移位的过程中， >>运算符使符号位被拷贝。
注意──移位运算符将它们右侧的操作数模32简化为int类型左侧操作数, 模64简化为long类型右侧操作数。因而, 任何int x, x >>> 32都会导致不变的x值, 而不是你可能预计的零。
注意------值得称赞的重要一点是: >>>运算符仅被允许用在整数类型, 并且仅对int和long值有效。如果用在short或byte值上, 则在应用>>>之前, 该值将通过带符号的向上类型转换被升级为一个int。有鉴于此，无符号移位通常已成为符号移位。
3.3.9 左移位运算符(<<)
|
左移位运算符(<<) 128 << 1 等于 128*21 = 256 16 <<2 等于 16*22 =64 |
运算符<<执行一个左移位。移位的结果是：第一个操作数乘以2的幂，指数的值是由第二个数给出的。例如：
128 << 1 gives 128*21 = 256
16 <<2 gives 16*22 =64
3.3.10 类型转换
|
类型转换
l 如果赋值的信息丢失，程序员必须采用类型转换的方法确认赋值 l 在short和char之间的赋值需要一个显式转型 见3-16程序 |
在赋值的信息可能丢失的地方，编译器需要程序员用类型转换（typecast）的方法确认赋值。例如，它可以“挤压”一个long值到一个int变量中。显式转型做法如下：
long bigValue =99L;
int squashed =（int） （bigValue）;
在上述程序中，期待的目标类型被放置在圆括号中，并被当作表达式的前缀，该表达式必须被更改。一般来讲，建议用圆括号将需要转型的全部表达式封闭。否则，转型操作的优先级可能引起问题。
注意──重温short的范围是：-215至215-1；char的范围是：0至215-1。
因而在short和char之间的赋值总需要一个显式转型
3.3.11 升级和表达式的类型转换
| 升级和表达式的类型转换 - 变量被自动升级为一个较长的形式（如：int至long的升级） - 如果变量类型至少和表达式类型一样大（位数相同），则表达式是赋值兼容的。
|
当没有信息丢失时，变量可被自动升级为一个较长的形式（如：int至long的升级）
long bigval = 6; // 6 is an int type, OK
int smallval = 99L; // 99L is a long, illegal
double z = 12.414F; // 12.414F is float, OK
float z1 = 12.414; // 12.414 is double, illegal
一般来讲，如果变量类型至少和表达式类型一样大（位数相同），则你可认为表达式是赋值兼容的。
对 + 运算符来说，当两个操作数是原始数据类型时，其结果至少有一个int，并且有一个通过提升操作数到结果类型、或通过提升结果至一个较宽类型操作数而计算的值，这可能会导致溢出或精度丢失。例如：
short a，b，c
a=1；
b=2；
c= a+b；
上述程序会因为在操作short之前提升每个short至int而出错。然而，如果c被声明为一个int，或按如下操作进行类型转换：
c = (short)(a+b);
则上述代码将会成功通过。
第四节 分支语句
|
分支语句 if, else语句 if (布尔表达式)｛ 语句或块； ｝ if (条件为真) ｛ 语句或块； ｝ else ｛ 语句或块； ｝
|
条件语句使部分程序可根据某些表达式的值被有选择地执行。Java编程语言支持双路if和多路switch分支语句。
3.4.1 if, else语句
if, else语句的基本句法是：
if (布尔表达式)｛
语句或块；
｝ else ｛
语句或块；
｝
例：
int count;
1.count = getCount(); // a method defined in the program
2.if (count < 0) {
3.System.out.println("Error: count value is negative.");
4.}else {
5.System.out.println("There will be " + count +
6." people for lunch today.");
7.}
在Java编程语言中，if ()用的是一个布尔表达式，而不是数字值，这一点与C/C++不同。前面已经讲过，布尔类型和数字类型不能相互转换。因而，如果出现下列情况：
if (x) // x is int
你应该使用下列语句替代：
if (x ! = 0)
全部else部分是选择性的，并且当测试条件为假时如不需做任何事，else部分可被省略。
3.4.2 switch语句
|
分支语句 switch语句 switch语句的句法是： switch (expr1)｛ case expr2: statements; break; case expr3: statements; break; default: statements; break; ｝ |
switch语句的句法是：
switch (expr1)｛
case expr2:
statements;
break;
case expr3:
statements;
break;
default:
statements;
break;
｝
注意──在switch (expr1) 语句中，expr1必须与int类型是赋值兼容的；byte, short或char类型可被升级；不允许使用浮点或long表达式。
当变量或表达式的值不能与任何case值相匹配时，可选缺省符（default）指出了应该执行的程序代码。如果没有break语句作为某一个case代码段的结束句，则程序的执行将继续到下一个case，而不检查case表达式的值。
例1：
1.switch (colorNum) {
2.case 0:
3.setBackground(Color.red);
4.break;
5.case 1:
6.setBackground(Color.green);
7.break;
8.default:
9.setBackground(Color.black);
10.break;
11.}
例2：
1.switch (colorNum) {
2.case 0:
3.setBackground(Color.red);
4.case 1:
5.setBackground(Color.green);
6.default:
7.setBackground(Color.black);
8.break;
9.}
例2设定背景颜色为黑色，而不考虑case变量colorNum的值。如果colorNum的值为0，背景颜色将首先被设定为红色，然后为绿色，再为黑色。
第五节 循环语句
| 循环语句 for语句 for (init_expr; boolean testexpr; alter_expr)｛ statement or block ｝
|
循环语句使语句或块的执行得以重复进行。Java编程语言支持三种循环构造类型：for, while和do loops。for和while循环是在执行循环体之前测试循环条件，而do loops是在执行完循环体之后测试循环条件。这就意味着for和while循环可能连一次循环体都未执行， 而do loops将至少执行一次循环体。
3.5.1 for循环
for循环的句法是：
for (init_expr; boolean testexpr; alter_expr)｛
statement or block
｝
例如：
for (int i = 0; i < 10; i++) {
System.out.println("Are you finished yet?");
}
System.out.println("Finally!");
注意──Java编程语言允许在for () 循环结构中使用逗号作为分隔符。 例如，for (i= 0, j = 0; j<10; i++, j++)是合法的；它将i值初始化为零，并在每执行完一次循环体后，增加一次它们的值。
3.5.2 while循环
|
循环语句 while循环 while (布尔表达式) ｛ 语句或块 ｝
|
while循环的句法是：
while (布尔表达式) ｛
语句或块
｝
例如：
int i = 0;
while (i < 10) {
System.out.println("Are you finished yet?");
i++;
}
System.out.println("Finally!");
请确认循环控制变量在循环体被开始执行之前已被正确初始化，并确认循环控制变量是真时，循环体才开始执行。控制变量必须被正确更新以防止死循环。
3.5.3 do循环
|
循环语句 do/while语句 do ｛ 语句或块； ｝ while (布尔测试) |
do循环的句法是：
do ｛
语句或块；
｝
while (布尔测试)
例如：
int i = 0;
do {
System.out.println("Are you finished yet?");
i++;
} while (i < 10);
System.out.println("Finally!");
象while循环一样，请确认循环控制变量在循环体中被正确初始化和测试并被适时更新。
作为一种编程惯例，for循环一般用在那种循环次数事先可确定的情况，而while和do用在那种循环次数事先不可确定的情况。
第六节 特殊循环流程控制
|
特殊循环流程控制 l break ［标注］； l continue［标注］； l label: 语句；// where statement must be any // legal statement. |
下列语句可被用在更深层次的控制循环语句中：
l break ［标注］；
l continue［标注］；
l label: 语句；// where statement must be any
// legal statement.
break语句被用来从switch语句、loop语句和预先给定了label的块中退出。
continue语句被用来略过并跳到循环体的结尾。
label可标识控制需要转换到的任何有效语句，它被用来标识循环构造的复合语句。
例如
loop: while (true) {
for (int i=0; i < 100; i++) {
switch (c = System.in.read()) {
case -1:
case ` /n ` :
// jumps out of while-loop to line #12
break loop;
....
}
} // end for
} // end while
test: for (...) {
....
while (...) {
if (j > 10) {
// jumps to the increment portion of
// for-loop at line #13
continue test;
}
} // end while
} // end for
练习：使用表达式
练习目标──你将编写、编译并运行两个使用标识符、表达式和控制结构的算法程序。
一、准备
为成功地完成本练习，你必须具备编译和运行Java程序的能力，并且熟悉流程控制构造。
二、任务
1级：创建一个阶乘应用程序
一个数X的阶乘（通常记作X!）等于X*(X-1)*(X-2)……*1。例如4!等于4×3×2×1=24。
创建一个称作Factor的应用程序，利用该应用程序可打印2，4，6和10的阶乘。
2级：求解一个几何题程序
已知一个直角三角形，其弦（最长边）的长度由下列公式给出：
编写一个称作hypotenuse的Java软件程序，从已知直角三角形的直角边计算最长边。
提示：从mod3/templates目录中提供的模板解决方案入手，从命令行输入；同时注意java.lang.Math类。
三、练习小结
讨论──用几分钟的时间讨论一下在以上练习中你所获得的经验、感想和发现。
经验 解释 总结 应用
四、检查你的进度
在进入下一模块之前，请确认你已经能够：
- 区分实例变量和局部变量；
- 描述实例变量是如何被初始化的；
- 确认并更正“可能的赋值前的引用”的编译器错误；
- 辨认、描述并使用Java软件运算符；
- 区分合法和非法原始类型赋值；
- 确认boolean表达式和它们在控制构造中的要求；
- 辨认赋值兼容性和在基本类型中的必要转型；
- 使用if, switch,for,while和do句型结构和break和continue的标注形式作为程序的流程控制结构。
五、思考题
- 多数编程语言都使用什么数据类型来集合相似的数据元素？
- 你怎样对一组元素进行相同的操作（如一个数组）？
- Java编程语言使用什么数据类型？
第四章 数 组
本模块将描述Java编程语言中如何定义、初始化和使用数组。
第一节 相关问题
讨论──下列问题与本模块阐述的论题相关：
- 一个数组的用途是什么？
第二节 目 标
完成本模块的学习后，你应该能够：
- 声明并创建原始数组、类数组或数组类型
- 解释为什么数组的元素需初始化
- 给出数组定义并初始化数组元素
- 确定一个数组中元素的数量
- 创建多维数组
- 编写从一个数组类型到另一个数组类型数组值的拷贝代码
第三节 数组的声明
|
声明数组 - 相同类型的成组数据对象 - 原始类型或类类型数组声明 - 为一个引用创建空间 - 数组是一个对象，而不是为原始类型储备的存储器 |
典型的数组是用来集合相同类型的对象并通过一个名称来引用这个集合。
你可以声明任何类型的数组──原始类型或类类型：
char s［ ］;
Point p [ ]; // where point is a class
在Java编程语言中，即使数组是由原始类型构成，甚或带有其它类类型，数组也是一个对象。声明不能创建对象本身，而创建的是一个引用，该引用可被用来引用数组。数组元素使用的实际存储器可由new语句或数组初始化软件动态分配。
在以下部分，你将看到如何创建和初始化实际数组。
上述这种将方括号置于变量名之后的声明数组的格式，是用于C、C++和Java编程语言的标准格式。这种格式会使声明的格式复杂难懂，因而，Java编程语言允许一种替代的格式，该格式中的方括号位于变量名的左边：
char［ ］s;
Point［ ］p;
这样的结果是，你可以认为类型部分在左，而变量名在右。上述两种格式并存，你可选择一种你习惯的方式。声明不指出数组的实际大小。
注意----当数组声明的方括号在左边时，该方括号可应用于所有位于其右的变量
第四节 创建数组
|
创建数组
使用关键字new 创建一个数组对象 s = new char [20]; p = new Point [100]; p[0] = new Point(); p[1] = new Point(); · · · |
你可以象创建对象一样，使用关键字new 创建一个数组。
s = new char [20];
p = new Point [100];
第一行创建了一个20个char值的数组，第二行创建了一个100个类型Point的变量。r然而，它并不创建100个Point对象；创建100个对象的工作必须分别完成如下：
p[0] = new Point();
p[1] = new Point();
·
·
·
用来指示单个数组元素的下标必须总是从0开始，并保持在合法范围之内－－大于0或等于0并小于数组长度。任何访问在上述界限之外的数组元素的企图都会引起运行时出错。下面还要谈到一些更好的数组初始化方法。
第五节 初始化数组
| 初始化数组 - 初始化一个数组元素 - 用初始化值创建一个数组 String names [] = { “Georgianna”, “Jen”, “Simon”, }; |
当创建一个数组时，每个元素都被初始化。在上述char数组s的例子中，每个值都被初始化为0 (/u0000-null)字符；在数组p的例子中, 每个值都被初始化为null，表明它还未引用一个Point对象。在经过赋值 p[0] = new Point()之后，数组的第一个元素引用为实际Point对象。
注意－－所有变量的初始化(包括数组元素)是保证系统安全的基础，变量绝不能在未初始化状态使用。
Java编程语言允许使用下列形式快速创建数组:
String names [] = {
“Georgianna”,
“Jen”,
“Simon”,
};
其结果与下列代码等同：
String names [] ;
names = new String [3];
names [0] = “Georgianna”;
names [1] = “Jen”;
names [2] = “Simon”;
这种”速记”法可用在任何元素类型。例如：
Myclass array [] = {
new Myclass (),
new Myclass (),
new Myclass ()
};
适当的类类型的常数值也可被使用：
Color palette [] = {
color.blue,
color.red,
color.white
};
第六节 多维数组
| 多维数组 数组的数组 int twoDim [][] = new int [4][]; twoDim[0] = new int[5]; twoDim[1] = new int[5];
int twoDim [][] = new int [][4]; 非法
每个数组有5个整数类型的4个数组的数组 int twoDim [][] = new int [4][5]; twoDim[0] = new int[5]; twoDim[1] = new int[5]; |
Java编程语言没有象其它语言那样提供多维数组。因为一个数组可被声明为具有任何基础类型，所以你可以创建数组的数组(和数组的数组的数组，等等)。一个二维数组如下例所示：
int twoDim [][] = new int [4][];
twoDim[0] = new int[5];
twoDim[1] = new int[5];
首次调用new而创建的对象是一个数组，它包含4个元素，每个元素对类型array of int的元素都是一个null引用并且必须将数组的每个点分别初始化。
注意－尽管声明的格式允许方括号在变量名左边或者右边，但此种灵活性不适用于数组句法的其它方面。例如: new int [][4]是非法的。
|
多维数组 l 非矩形数组的数组 twoDim[0] = new int [2]; twoDim[1] = new int [4]; twoDim[2] = new int [6]; twoDim[3] = new int [8];
l 每个数组有5个整数类型的4个数组的数组 int twoDim [][] = new int [4][5]; |
多维数组
因为这种对每个元素的分别初始化，所以有可能创建非矩形数组的数组。也就是说，twoDim的元素可按如下方式初始化：
twoDim[0] = new int [2]
twoDim[1] = new int [4];
twoDim[2] = new int [6];
twoDim[3] = new int [8];
由于此种初始化的方法烦琐乏味，而且矩形数组的数组是最通用的形式，因而产生了一种”速记”方法来创建二维数组。例如：
int twoDim [][] = new int [4][5];
可被用来创建一个每个数组有5个整数类型的4个数组的数组。
第七节 数组界限
| 数组界限 所有数组的下标都从0开始 int list [] = new int [10]; for (int i= 0; i< list.length; i++) System.out.println(list[i]); |
在Java编程语言中，所有数组的下标都从0开始。 一个数组中元素的数量被作为具有length属性的部分数组对象而存储; 这个值被用来检查所有运行时访问的界限。如果发生了一个越出界限的访问，那么运行时的报错也就出现了。
使用length属性的例子如下：
int list [] = new int [10];
for (int i= 0; i< list.length; i++)
System.out.println(list[i]);
使用length属性使得程序的维护变得更简单。
第八节 拷贝数组
|
拷贝数组 - 不能调整数组的大小 - 可使用相同的引用变量来引用一个全新的数组 int elements [] = new int [6]; elements = new int [10]; |
数组一旦创建后，其大小不可调整。然而，你可使用相同的引用变量来引用一个全新的数组：
int myArray [] = new int [6];
myArray = new int [10];
在这种情况下，第一个数组被有效地丢失，除非对它的其它引用保留在其它地方。
|
拷贝数组
System.arraycopy()方法 // original array 1.int myArray[] = { 1, 2, 3, 4, 5, 6 }; 2. 3.// new larger array 4.int hold[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; 5.// copy all of the myArray array to the hold 6.// array, starting with the 0th index 7.System.arraycopy(myArray, 0, hold, 0, 8.myArray.length);
|
拷贝数组
Java编程语言在System类中提供了一种特殊方法拷贝数组，该方法被称作arraycopy()。例如，araycopy可作如下使用：
// original array
1.int myArray[] = { 1, 2, 3, 4, 5, 6 };
2.
3.// new larger array
4.int hold[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
5.// copy all of the myArray array to the hold
6.// array, starting with the 0th index
7.System.arraycopy(myArray, 0, hold, 0,
8.myArray.length);
在这一点，数组hold有如下内容：1,2,3,4,5,6,4,3,2,1。
注意—在处理对象数组时，System.arraycopy()拷贝的是引用，而不是对象。对象本身不改变。
练习: 使用数组
练习目标－－在定义并初始化数组后，你将在程序中使用数组。
一、准备
为成功地完成本练习，请务必理解基本的矩阵概念并了解如何定位一个数组以获取它的值。
二、任务
1级：基本数组的使用
1. 创建一个称作BasicArray的类，在...main()方法中声明两个变量，一个是thisArray，另一个是thatArray，它们应属类型array of int。
2. 创建一个数组，它有10个int值，范围从1至10。分配这个第三数组的引用给变量thisArray。
3. 使用for()循环打印thisArray的所有值。如何控制循环的次数？
4. 编译并运行程序。多少值被打印？这些值是什么？
5. 对每个thisArray的元素，建立它的值为索引值的阶乘。打印数组的值。
6. 编译并运行程序。
7. 分配thisArray的引用给变量thatArray。打印thatArray的所有元素。
8. 编译并运行程序。tyatArray的多少值被显示？这些值是什么？它们来自何处。
9. 修改thisArray的某些元素，打印thatArray的值。
10. 编译并运行程序；在thatArray的值中，你注意到了什么？
11. 创建一个有20个int值的数组。分配新数组的引用给变量thatArray，打印thatArray的值。
12. 编译并运行程序。每个数组有多少值被显示? 这些值是什么？
13. 拷贝thisArray的值给thatArray。你将使用什么方法调用? 你将如何限制拷贝元素的数量? thatArray的元素10至19有什么变化？
14. 打印thatArray的值。
15. 编译并运行程序。你所显示的值都是正确的吗？如果不是，你知道有那些内容理解得不对吗？
16. 改变thatArray的某些值；打印thisArray和thatArray。
17. 编译并运行程序。这些值是你所期待的吗？
2级：数组的数组
1. 创建一个称作Array2D的类，在main()方法中声明一个称作twoD的变量，它应属类型array of array of int。
2. 创建一个元素类型为int的数组，该数组应包括4个元素并被赋值到变量twoD的elements[0]。
3. 编写两个嵌套for()循环语句以打印twoD的全部值。以矩阵的格式安排输出 (可采用System.out.print()方法)。
4. 编译并运行程序。 你应该能发现此时出现了运行错误(空指针异常) ，这是因为twoD的elements[1] 至 [3]未被初始化。
5. 分别创建包括5个、6个和7个元素的int数组，将这些数组的引用分别赋予twoD的elements [1]，[2]和[3]；确认完成上述操作的代码是在第3步所描述的嵌套for()循环之前插入的。
6. 编译并运行程序。这次你应该看到一个零值的非矩形布局。
7. 赋予twoD数组的每个元素一个明显的非零值(提示：使用Math.random() 以获得随机值)。
8. 声明一个属类型array of int的称作oneD的变量。然后, 创建一个包括4个元素的int数组。将该数组的引用分别赋予数组array twoD和oneD的第一个元素。赋值后，打印oneD和twoD数组。
9.编译并运行程序。请注意通过打印oneD的值而显示的单个数组与twoD数组的元素是相同的。
3级：字谜游戏
1. 创建一个称作WordScrambler的应用程序，它具有一个词数组(长度最大为8个字符) ，用它可将一个词的字母拼凑(重排顺序) ，然后组成一个新词。
2.允许使用者看到词的拼凑过程，并分解5个游戏的运行过程。
三、练习小结
讨论──用几分钟的时间讨论一下在以上练习中你所获得的经验、感想和发现。
l 经验 解释 总结 应用
四、检查你的进度
在进入下一模块之前，请确认你已经能够：
- 声明并创建原始数组、类数组或数组类型
- 解释为什么数组的元素需初始化
- 给出数组定义并初始化数组元素
- 确定一个数组中元素的数量
- 创建多维数组
- 编写从一个数组类型到另一个数组类型数组值的拷贝代码
五、思考题
你怎样创建一个三维数组？
使用数组的缺点是什么？
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
