学习领域1：Java语言概述



〖1〗
Java语言程序设计（第二版）




〖1〗
学习领域1Java语言概述





〖1〗





〖1〗



任务11安装Java开发环境
本部分介绍Java语言的发展历程、技术特点和Java体系结构等，使读者对Java语言有一个基本的认识。随后配置Java开发环境，使初学者能够以较高的效率开发Java应用程序。
111任务内容
Java开发环境的搭建：安装JDK 17和集成开发环境Eclipse，开发执行第一个Hello World程序。执行过程如下。
（1）JDK的安装与配置。
（2）Java开发环境的配置。
（3）IDE集成开发环境Eclipse的安装与配置。
（4）开发执行Java Application应用程序和Java Applet小应用程序。
112相关知识
知识点一：Java语言简介
1991年，Sun公司的James Gosling等人为了解决消费类电子产品的微处理器计算问题，开发出一种名为 “Oak”（中文译为“橡树”）的与平台无关的语言，它就是Java语言的前身。它用于控制嵌入在有线电视交换盒、PDA（Personal Digital Assistant，个人数字助理）、家用电器等的微处理器中。
1993年交互式电视和 PDA 市场用量开始滑坡，而 Internet 正处于发展时期，因此Sun 公司将目标市场转向 Internet 应用程序。
1994年Sun公司将Oak语言更名为Java（Java译为“爪哇”，是印度尼西亚一个盛产咖啡的岛屿），并于1995年正式推出它的第一个版本。Internet的迅猛发展与WWW（万维网）应用的快速增长，为Java的发展带来了契机。Java语言优秀的跨平台特性使之非常适合于Internet编程，最初用Java语言编写的Hot Java浏览器和应用于Web页面的Applet程序，使Java语言成为Internet上最受欢迎的开发语言。Sun公司采取了“开放式”的合作政策，采用了颁发使用许可证的方式来允许各家公司把Java虚拟机（JVM）嵌入自己的操作系统或应用软件中，这吸引了大批公司加入到Sun联盟，如IBM、HP、Netscape、Novell、Oracle、Apple等公司；而且开发平台的源代码完全开放，这使得开发人员很容易只使用一种Java语言来实现网络各平台之间的开发、编程和应用，这也是Java语言得以迅猛发展的一个主要原因。现在全球有近70％的公司使用Java语言开发自己的计算机软件系统。
1995年，Sun公司发布了Java的第一个版本Alpha 10a2版本，开发出Hot Java浏览器。1996年，Sun公司发布了Java的第一个开发包JDK v10。1997年，Sun公司发布了Java开发包JDK v11。1998年，Sun公司发布了Java开发包JDK v12（称为Java 2）。
1999年，Sun公司重新组织了Java平台的集成方法，并将企业级应用平台作为公司今后发展的方向。现在的Java开发平台的编程构架一共有三种：J2SE、J2EE、J2ME。
J2SE （Java 2 Platform, Standard Edition ） ，即Java 2平台标准版，包含构成Java语言核心的类。它是用于工作站、PC的开发平台，也是三个编程构架中最基本的一个构架，J2EE和J2ME就是在J2SE的基础上发展、转化而来的。
J2EE （Java 2 Platform, Enterprise Edition ），即Java 2平台企业版。J2EE应用于可扩展的、基于分布式计算的企业级开发平台，如Intranet（企业内部网），有业界大量的其他软件技术融入J2EE构架中（如微软的XML技术），因此它具有更高的可扩展性、灵活性和集成性。
J2ME （Java 2 Platform，Micro Edition ），即Java 2平台微型版。J2ME用于嵌入式开发，为消费类电子产品软件开发服务，如手机系统或手机游戏软件的开发。
三种版本使用的类库也不尽相同，本书内容的大部分类都来自J2SE构架。
知识点二：Java语言的特点
1简单性与分布式
Java作为一种高级编程语言，在语法规则上和C++类似，C++程序员会比较容易地掌握Java编程技术。Java摒弃了C++容易引起错误的内容，如指针操作和内存管理，使程序设计变得简单、高效。
Java是面向网络的编程语言，它提供了基于网络协议（如TCP/IP）的类库。使用这些类，Java应用程序可以很容易地访问网络上的资源。Java应用程序可通过一个特定的URL对象打开并访问网络资源，就像访问本地文件系统那样简单。
2纯面向对象
面向对象编程技术具有很多优点，比如通过对象的封装，减少了对数据非法操作的风险，使数据更加安全；通过类的继承，实现了代码的重用，提高了编程效率等。Java语言的编程主要集中在类、接口的描述和对象引用方面。面向对象编程技术适合开发大型的、复杂的应用程序，且程序代码易于理解和维护，是编程发展的一个趋势。
3健壮性与安全性
Java语言在编译和运行时具有健壮性，可以消除程序错误带来的影响。Java语言提供了较完备的异常处理机制，在编译和运行程序时，系统对代码进行逐级检查，指出可能产生错误的地方，要求必须对可能存在错误的代码进行必要的处理，以消除因产生错误而造成系统崩溃的情况。它提供自动垃圾收集功能来进行内存管理，防止出现程序员在管理内存时容易产生的错误，这些措施都保证了Java系统运行的可靠性。
作为网络编程语言，安全是至关重要的。一方面，在语言功能上，由于Java不支持指针，消除了指针操作带来的安全隐患；另一方面，Java具有完备的安全结构和策略，代码在编译和运行过程中被逐级检查，可以防止恶意程序和病毒的攻击，如编译器会查找出代码错误，编译之后生成字节码，通过字节码校验器，病毒代码将无所遁形，因此也有人称Java语言为“永远不会感染病毒的语言”，在加载类的时候，还会通过类加载器进行校验。
4平台独立与可移植性
互联网是由各种各样的计算机平台构成的，如果要保证应用程序在网络中任何计算机上都能正常运行，必须使程序具有平台无关性，即软件本身不受计算机硬件系统和操作系统的限制。Java是一种“与平台无关”的编程语言，Java的源文件是与平台无关的纯文本，而Java源文件通过编译后生成的类文件（即字节码文件）通过Java虚拟机（JVM）可以在不同的平台上运行，与具体机器指令无关。Java的基本数据类型在设计上不依赖于具体硬件，为程序的移植提供了方便。
5解释执行
Java是一种先编译后解释执行的编程语言，Java源程序经过编译后生成被称作字节码（Byte Code）的二进制文件，JVM 的解释器解释执行字节码文件。解释器在执行字节码文件时，能对代码进行安全检查，以保证没有被修改的代码才能执行，提高了系统的安全性。另外，JVM由Sun公司特别制作并在网上实时更新，它的运行效率远高于一般的解释性语言的解释器。
6多线程与动态性
多线程机制使程序代码能够并行执行，充分发挥了CPU的运行效率。程序设计者可以用不同的线程完成不同的子功能，极大地扩展了Java语言的功能。支持多线程机制是现今网络开发语言的基本特性之一。
Java在设计上力求适合不断发展的环境。在类库中可以自由地加入新的方法和实例而不会影响用户程序的执行。Java通过接口来支持多重继承，使之比严格的类继承具有更灵活的方式且易于扩展。Java的类库是开放的，所有的程序员可以根据需要自行定义类库。
知识点三：Java平台特性
1了解Java的跨平台特性
什么是平台呢？简单的理解是计算机软件系统与计算机硬件系统的结合体。比如IBM PC Windows机、Apple公司的Mac OS等。我们知道，不同种类的计算机有不同的机器语言（内码），为一种平台编写的代码不能在另一种平台上运行，这是因为它们的内码不同。
编程语言分为三类：机器语言、汇编语言、高级语言。
Java语言是一种“先编译后解释”的高级语言，它的地位等同于C、C++或Visual Basic等语言。从功能上来看，Java也可以实现C、C++或Visual Basic等语言的大部分功能，如控制台（Console）程序和GUI（Graphics User Interface，图形用户界面）程序，只不过侧重点有所不同。Java语言是基于Web开发的一种高级语言，它的“强项”在网络上！
下面我们介绍一下Java的编译和运行过程，如图11所示。

图11 Java编译与运行过程

Java语言通过编译器在本地将源程序（扩展名为java）文件编译成字节码文件（扩展名为class），可以通过复制或通过网络传送到目的平台，然后通过目的平台的解释器（也可能是浏览器的解释器）来解释执行。
那么Java又是如何完成跨平台的呢？如图12所示，Java在运行过程的中间环节引入了解释器来帮助它完成跨平台。

图12 Java语言的运行过程

下面介绍一个非常重要的概念——Java虚拟机（Java Virtual Machine，JVM）。
JVM是在计算机内部模拟运行的假想的计算机。它可以是硬件或软件（通常为软件）。它有自己独立的指令集系统（相当于计算机的CPU、内存和寄存器等设备）。JVM负责将Java字节码程序翻译成机器码，然后由计算机执行。
JVM的主要功能为：加载 class 文件，管理内存，执行垃圾收集。
在计算机执行Java程序时，需要JVM和核心类库的支持。Java采用的方法是：在操作系统和硬件平台上模拟一种抽象化的计算机系统运行时环境（Java Runtime Environment，JRE），而JRE包含了JVM和运行程序所需系统核心类库。JVM和JRE是随着JDK（Java Development Kit，Java 开发工具包）的安装而建立起来的。
对Java语言而言，它的源文件和字节码文件（中间码文件）都是与平台无关的，它们可以通过网络传输到任何一个网络平台中并可以被识别。然后通过目标平台本地的JVM解释执行。但要注意：JVM是与平台相关的。因为字节码是通过网络传输到目标计算机平台上再通过JVM运行的，而不同种类的计算机有不同的内码，从这里就可以推断出，每一个特定平台上应该有一个特定的JVM，即JVM是与平台相关的。
2Java程序的运行时环境
前面介绍了Java虚拟机（JVM）的概念，JVM的核心是解释器。而程序运行时需要的是JRE，可以简单地把JRE理解成工作在操作系统之上的一个小型操作系统，它包含了运行在其上的JVM及本地平台的核心类库，如图13所示。
下面详细描述JRE中各部件的作用。
（1） 类加载器（Class Loader）：用来加载Class文件的部件，同时针对跨网络的类，进行安全性检查。
（2） 字节码校验器（Byte Code Verifier）：基于代码规范，对语法语义、对象类型转换和权限安全性访问进行检查。
（3） 解释器（Interpreter）：JVM的核心部件，把字节码指令映射到本地平台的库和指令上，使之得以执行。

图13 Java运行时环境

（4） JIT代码生成器（Just In Time）：即时代码生成器（即时代码编译器）是另一种解释执行字节码的方法。通常的解释器是逐行解释和运行，而编译器是对代码做全体编译后再连接执行，因此解释型语言的执行效率一般都低于编译型语言。而为了提高运行效率，Java提供了JIT运行方式，它可以一次性地解释完所有代码，再去运行机器码，而且曾经解释过的代码会进入缓存，如果下次再调用这部分代码，就从缓存中取出，这样就极大地提高了Java的运行效率。因为这种解释运行的方式类似于编译器，因此也称其为“JIT即时编译器”。JIT就类似于引擎对于一辆赛车的意义，是JRE的核心部件。
（5） API类库：实现标准Java平台API的代码。
（6） 硬件本地平台接口：提供对底层系统平台资源库的调用接口。
3垃圾收集器
许多计算机语言都有在程序运行时动态分配存储空间的功能，当这部分内存空间不再使用的时候，程序应停止分配内存空间并回收它们。但是回收内存空间却不是件容易的事情，C和C++语言通常需要程序员自行编写代码回收动态内存空间，这增加了程序员的负担，还会因为代码不健壮造成系统问题。
Java语言提供了一个自动进行内存管理的工具，就是垃圾收集器（Garbage Collector）。它是一个系统级的线程，专用于对内存进行跟踪和回收。但因为垃圾收集器是一个优先级比较低的后台线程（Daemon Thread），所以它只在系统有空闲的时候才会回收垃圾内存，而且也无法判断垃圾收集器何时回收内存，以及要运行多长时间，这一切都是自动完成的。这使得程序在运行时会出现不连贯的现象，在一定程度上降低了代码的运行效率，但这个代价还是值得付出的。
知识点四：JDK目录结构
1什么是JDK
JDK（Java Development Kit）即Java 开发工具包，是有助于程序员开发Java 程序的工具包，其中包括类库、编译器、调试器、Java 运行时环境（JRE）。
Sun公司为各种主流平台（如Windows、Solaris、Macintosh等）制作了JDK，可以从网址http://Javasuncom//products/下载JDK。如下载的文件为j2sdk1_6_0betawindowsi586exe，表示此JDK为Java 2标准版，版本号为16（内部版本号为60），beta表示测试版，适用于Windows系统的计算机。
2JDK的目录结构
下载并安装完JDK后，假设安装的目录为：C:\\Program Files\\Java\\j2sdk160。在 \\Java\\j2sdk160目录下有以下文件及子目录。
根目录包括版权、许可和Readme文件，还有构成Java核心API的所有类文件的归档文件srcjar。
bin目录是JDK开发工具的可执行文件，包括编译器、解释器、调试器等。
demo目录中有丰富的演示程序源代码。
include目录支持Java本地机接口（JNI）和Java虚拟机调试程序接口的C语言头文件。
JRE（Java Runtime Environment），即Java运行时环境，包含JVM、运行时的类包和Java链接启动器，但是不包含编译器和调试器。jre目录包含的部分子目录及文件如下。
lib/jawjar：提供了Netscape的JavaScript和Security类。
lib/charsetsjar：字符转换类。
lib/rtjar：Java基本类库（JFC）。
lib/ext/：包含扩展的jar文件。
bin/keytool：密码认证和管理工具。
另外，\\jre\\bin目录下，还包括Java Web Start（JWS）的运行程序Javawsexe。
lib目录包含开发工具使用类的归档文件。其中有：
toolsjar：包含支持JDK的工具和实用程序的非核心类。
dtjar：是Swing组件类BeanInfo文件的DesignTime归档。
sample目录中有一些JNLP（Java网络装载协议）应用的样例程序。JNLP能使远程客户访问和运行那些位于本地机器的应用程序。JNLP应用程序的优点是它可以在网络上实现自安装和自更新。
知识点五：Java程序开发
Java的基础应用中包含两种类型的应用：一种是Java Application，称为Java应用程序；另一种是Java Applet，称为Java小应用程序。
Java Application以main（）方法作为程序入口，由Java解释器解释执行，用以实现控制台或GUI方面的应用。
Java Applet没有main（）方法，但是有init（）和paint（）等方法，由浏览器解释执行，主要用于在网页上显示动画等功能。对此本书只做简单介绍，因为Applet已基本不再被使用。
1Java Application应用程序开发

【例11】编写一个在屏幕上显示“Hello World !”字符界面的应用程序。




public class HelloApp{ // 定义公共类HelloApp
public static void main（String\[ \] args）{// 应用程序入口即main（）方法
Systemoutprintln（"Hello World !"）; // 输出Hello World !
}
}

例11是最简单的Java应用程序，它给出了Java应用程序的基本框架。
注意以下几点内容。

（1） 类是构成Java程序的主体，class是类的说明符号，类中包含了实现具体操作的方法。
（2） 使用“//”声明的部分是Java的注释，它有助于程序的阅读，在编译时不会被编译。
（3） 每个应用程序中必须包含主方法main（），主方法是程序的入口，读者可先记住声明格式，不要改变关键字顺序。
（4） Systemoutprintln（）方法起到输出作用，直接输出括号内的内容。
（5） 读者在编写以上程序时要注意字母大小写，Java语言中严格区分大小写。
2Java Applet小应用程序开发
Applet应用程序是嵌入在HTML（Hypertext Markup Language，超文本标记语言）文件中的Java程序。它可以连同Web页面一起被下载到客户的浏览器中，并由实现了JVM的浏览器运行。编写Applet程序时，需要编写出相应的HTML文件，并在文件中加上调用Applet程序的标记。
【例12】编写在浏览器中显示“Hello World !”的Java Applet程序。




import javaappletApplet; // 打开Applet类所在的包applet
import javaawt.*; // 打开Graphics类所在的包awt
public class SimpleApplet extends Applet{// 创建继承Applet类的SimpleApplet
public void paint（Graphics g） { // 调用Applet类的paint（）方法
gdrawString（"Hello World !",50,50）; // 绘制"Hello World !"
}
}

用于编写HTML文件的工具有很多，复杂的HTML文件可以用目前较为流行的可视化制作工具（如FrontPage、Dreamweaver）创建，简单的文件可以用文本编辑工具直接编写。本例使用的HTML文件的代码如下：




<HTML>
<HEAD>
<TITLE>The Simple Applet</TITLE>
</HEAD>
<BODY>
<APPLET CODE="SimpleAppletclass" WIDTH=200 HEIGHT=100>
</APPLET>
</BODY>
</HTML>

在上面的代码中，“<APPLET CODE="SimpleAppletclass" WIDTH=200 HEIGHT=100>”是调用SimpleAppletclass的标记。可以用Web浏览器或JDK提供的appletviewer运行Applet应用程序。
知识点六：Java语法规则
字符是组成Java程序的基本单位，Java语言源程序使用Unicode字符集。Unicode采用16位二进制数表示1个字符，可以表示65 535个字符。标准ASCII码采用8位二进制数表示1个字符，共有128个字符。如果要表示像汉字这样由双字节组成的字符，采用ASCII码是无法实现的。ASCII码对应Unicode的前128个字符。因此，采用Unicode能够比采用ASCII码表示更多的字符，这为在不同的语言环境下使用Java奠定了基础。
1Java程序注释
注释是用来对程序中的代码进行说明、帮助程序员理解程序代码的，还有利于对程序代码进行调试和修改。在系统对源代码编译时，编译器将忽略注释部分的内容。Java语言有3种注释方式：
（1） 以// 分隔符开始的注释，用来注释一行文字。
（2） 以/* … */ 为分隔符的注释，可以将一行或多行文字说明作为注释内容。
（3） 以/** … */ 为分隔符的注释， 用于生成程序文档中的注释内容。
下面以实例说明以上三种注释的用法。
【例13】注释方法举例。




/****************
*程序名称：HelloWorldjava  *
*作者：Sunlina *
*日期：2014/08/06  *
****************/
public class HelloWorld{
String strMsg="Hello,World!" ; // 定义变量strMsg
/** This method is used to display greeting message!*/
void init（） {// 定义init（）方法 
Systemoutprintln（strMsg） ; // 输出字符串内容
}
public static void main（String\[ \] args） {// 主方法即程序入口 
new HelloWorld（）init（） ; // 引用init（）方法
 }
}

一般情况下，如果阅读源程序代码，用方法（1）和方法（2）给代码加注释。如果程序经过编译之后，程序员得不到源程序代码，要了解程序中类、方法或变量等的相关信息，可以通过生成程序注释文档的方法，使程序员通过阅读注释文档，了解到类内部方法和变量的相关信息。
JDK提供的Javadoc工具用于生成程序的注释文档。将例13程序生成注释文档须执行：


Javadoc private HelloWorldjava
该命令执行结束后，生成名为indexhtml的文件。在浏览器中阅读该文档，可以看到程序中方法和变量的说明信息。参数“private”表示生成的文档中，将包括所有类的成员。如果需要更详细的注释信息，可以在要说明的成员前面用/**…*/加注释，如程序中关于init（）方法的说明，注释的信息将出现在生成的文档中。
2Java的标识符
我们已经接触到简单的Java程序，了解到Java程序的基本组成。Java程序是由类和接口组成的，类和接口中包含方法和数据成员。编写程序时，需要为类、接口、方法和数据成员命名，这些名字称为标识符。
标识符可以由多种字符组成，可以包含字母、数字、下划线、美元符（$），但首字符不能是数字，不能包括操作符号（如+、-、/、*等）和空格等。例如，HelloWorld、setMaxValue、UPDATE_FLAG都是合法的标识符；而123、UPDATEFLAG、ab*cd、begin flag等都是非法的标识符。
Java是区分大小写的编程语言，字符组成相同但大小写不同视为不同的标识符，如strName和StrName标识不同的名称。
3Java的关键字
标识符用于为类、方法或变量命名。按照标识符的组成规则，程序员可以使用任何合法的标识符，但Java语言本身保留了一些特殊的标识符——关键字，它不允许在程序中为程序员定义的类、方法或变量命名。关键字有着特定的语法含义，一般用小写字母表示。以下列出了Java语言中使用的关键字。
abstractdefaultifprivatethis

booleandoimplementsprotectedthrow

break
double
import
public
throws
byte
else
instanceof
return
transient
case
extends
int
short
try
catch
final
interface
static
void
char
finally
long
strictfp
volatile

class
float
native
super
while
const
for
new
switch

continue
goto
package
synchronized

4Java的分隔符
在编写程序代码时，为了标识Java程序各组成元素的起始和结束，通常要用到分隔符。Java语言有两种分隔符：空白符和普通分隔符。
空白符：包括空格、回车、换行和制表符等符号，用来作为程序中各个基本成分间的分隔符，各基本成分之间可以有一个或多个空白符。系统在编译程序时，忽略空白符。
普通分隔符：也用来作为程序中各个基本成分间的分隔符，但在程序中有确定的含义，不能忽略。Java语言有以下普通分隔符。 
● { } 大括号，用来定义复合语句（语句块）、方法体、类体及数组的初始化。
● ；分号，语句结束标志。
● ，逗号，分隔方法的参数和变量说明等。
● ：冒号，说明语句标号。
● \[ \] 中括号，用来定义数组或引用数组中的元素。
● （） 圆括号，用来定义表达式中运算的先后顺序；或在方法中，将形参或实参括起来。
● 用于分隔包，或者用于分隔对象和对象引用的成员方法或变量。
113任务实施
本任务为安装和配置JDK开发环境与Eclipse集成环境。
1任务分析
（1） 掌握安装JDK 18的方法。
（2） 掌握Java开发环境的配置。
（3） 掌握IDE集成开发环境Eclipse的安装与配置。
（4） 掌握如何在Eclipse中建立工程。
（5） 掌握如何在Eclipse中编写和执行Java Application程序。
（6） 掌握如何在Eclipse中编写和执行Java Applet程序。
（7） HTML文档中嵌入Java Applet程序。
2安装JDK环境
（1）从Oracle公司https://wwworaclecom/technetwork/java/javaee/downloads/indexhtml网站下载Windows版的JDK8，双击下载的exe文件，如jdk8u141windowsx64exe，进入安装向导界面，如图14所示。

图14安装向导界面

（2） 单击“下一步”按钮进入“自定义安装”界面，如图15所示。默认安装到“C:\\Program Files\\Java\\jdk180_141\\”目录下，可以通过“更改”按钮对安装路径进行自定义，这里我们使用默认安装路径。


图15自定义安装

（3） 选择安装JDK所有组件后，单击“下一步”按钮进入安装进度界面，如图16所示。

图16安装进度

（4） 接下来询问是否安装JRE（Java Runtime Environment，Java运行环境） ，如图17所示。因为JDK中已经包含Java的开发环境和运行环境。若仅对已有的Java程序进行运行，而不需要进行Java程序的开发，那么可以安装一个独立的JRE，单击“下一步”按钮，如图18所示。

图17JRE安装询问


图18正在安装JRE

（5） JDK安装完成后，进入图19所示界面，下面可以配置Java开发环境了。

图19JDK安装完成

3设置Java开发环境
为了方便使用JDK中的Java工具，需要进行环境变量的配置。环境变量就是操作系统运行环境中的一些参数。Java要使用到操作系统的参数path，它记录了很多命令所属的路径，只要将Java开发中需要的命令所属的路径配置到path参数值中即可。具体操作步骤如下。
（1） 右击桌面上“我的电脑”图标，打开“系统属性”对话框，选择“高级”标签，单击“环境变量”按钮，如图110所示。

图110环境变量设置

（2）  选择名称为Path的变量，单击“编辑”按钮，如图111所示。出现Path变量的编辑对话框。不必删除原有的值，只要将光标移动到第二个文本框的起始处即可，如图112所示。

图111环境变量中选择“Path”进行编辑


图112编辑系统变量“Path”

（3）  复制图113中地址栏的目录路径，将复制内容粘贴到图112最左边光标所在位置，并用分号与原有的值进行分隔，如图114所示，然后单击“确定”按钮完成。

图113复制路径


图114添加路径至系统变量“Path”中

（4）在环境变量窗口里的“Administrator的用户变量”中点击“新建”按钮，如图115所示，增加JAVA_HOME变量。

图115新建环境变量“JAVA_HOME”

（5）按照图116所示，在用户变量JAVA_HOME中，设置变量值为 C:＼Program Files＼Java＼jdk180_141，单击“确定”按钮完成。

图116编辑系统变量“JAVA_HOME”

（6） 最后验证配置正确性。从“开始”菜单中打开“运行”对话框，输入cmd命令，如图117所示，单击“确定”按钮后进入DOS命令提示符界面，输入Javac命令，如果出现图118所示界面，说明环境配置成功，可以进行Java代码开发了。

图117运行cmd命令


图118运行Javac命令

4安装Eclipse环境
这里介绍IBM公司开发的IDE开发环境Eclipse，它是一个开放源代码的、基于Java的可扩展开发平台。
（1） Eclipse的下载
进入Eclipse的官方网站http://www.eclipse.org/downloads，如图119所示，可以自行下载合适的Eclipse安装版本。本教材提供Eclipse oxygen 470的资源安装包，直接安装即可。

图119Eclipse的官方网站

（2） Eclipseoxygen 470软件的解压
如图1-20所示，将“eclipsejeeoxygenRwin32x86_64”软件压缩包放置于E盘进行解压，生成目录“E:＼Eclipse”。

图120解压位置对话框

（3） 运行eclipseexe文件
进入目录“E:＼Eclipse”，在图121中双击运行eclipseexe文件，弹出图122和图123所示的界面。如果无法启动，则说明JDK没有安装好，或者PATH环境变量没有设置正确。

图121运行eclipseexe文件


图122eclipse的启动界面


图123Workspace Launcher对话框

在图123的文本框中输入工作区文件夹，本例为“E:＼Eclipse_java＼lizi”。应该先在E盘建立该目录，再单击右侧的Browse按钮来选择。不要手写目录路径，很可能会写错的。单击“Launch”按钮，启动程序，弹出图124所示的窗口。

图124eclipse的欢迎界面

在图125中单击“新建工程项目”选项，弹出125所示窗口。注意，右上角“Java”透视图表示在此操作界面可以建立和运行Java程序。

图125eclipse的操作界面

5Java Application源程序建立及运行
（1） 建立工程。单击File→New Project选项，如图126所示，选择Java Project，弹出图127所示窗口。之后再次进入可以直接选择已经建立的Java Project项目。

图126建立一个工程的操作界面

在图127的Project name文本框中输入工程名，例如给出的工程名为“c1”，然后单击Finish按钮，弹出如图128所示窗口。

图127New Java Project窗口

在图128中显示建好的“c1”工程，在此操作界面可以编写Java程序。

图128建好的“c1”工程

（2） 建立Java Application源程序。单击File→New→Class选项, 如图129所示。

图129建好的“c1”工程中建立Java源程序

在打开的图130所示窗口的Name文本框中输入Java源程序名，扩展名不用写，默认为“java”。例如，给出的Java源程序名为“C1_1”，在复选框中勾选public static void main后单击Finish按钮，弹出如图131所示窗口。

图130New Java Class窗口

图131中是一个空的Java Application应用程序框架，可以在此编写程序。本例建立的C1_1java源程序如图132所示。

图131空的Java Application应用程序框架


图132编写“C1_1java”程序

（3） 编译运行Java Application源程序。在图132所示的菜单中单击Run→Run As→1 Java Application选项，如图133所示，弹出如图134所示窗口，单击OK按钮，结果如图135所示。如果编译Java Application源程序没有错误，则在Console控制台选项中可以看到运行结果。如果编译Java Application源程序有错误，则在Console控制台选项中可以看到错误信息，需修改源程序再编译运行。本例编写的“C1_1java”程序的运行结果显示在Console控制台选项中。

图133编译运行“C1_1java”程序


图134Save and Launch窗口


图135“C1_1java”程序的运行结果

6Java Applet源程序建立及运行
（1） 建立一个工程。建立工程参照图126和图127的操作。本例中给出的工程名为“c2”，然后单击Finish按钮，弹出如图136所示窗口。

图136建好的“c2”工程

（2）建立Java Applet源程序。在图136中显示建好的“c2”工程，单击File→New→Class选项，如图137所示，弹出如图138所示窗口。

图137在建好的“c2”工程中建立Java源程序

在图138中的Name文本框里输入Java源程序名，扩展名不用写，默认为“java”。


图138在c2工程中建立C1_2 源程序

本例中给出的Java源程序名为“C1_2”，在复选框中勾选Inherited abstract methods（继承的抽象方法），单击Browse按钮，弹出如图139所示窗口。在Choose a type文本框中输入“javaapple”，然后单击OK按钮，弹出如图140所示窗口。从中单击Finish按钮，弹出如图141所示窗口。


图139Superclass Selection窗口



图140c2工程的New Java Class窗口

图141中是一个空的Java Applet程序框架，可在此编写程序。本例建立的C1_2java源程序如图142所示。


图141空的Java Applet程序框架



图142编写“C1_2java”程序

（3）  编译运行Java Applet源程序。在图142的菜单中单击Run→Run As选项，本例编写的“C1_2java”程序的运行结果如图143左上角所示，这是小应用程序浏览器——appletviewer，用于测试和运行Java Applet程序。如果编译Java Applet源程序有错误，需修改源程序后再编译运行。


图143运行“C1_2java”程序的结果

7在HTML文档中嵌入Java Applet程序
（1）  建立一个工程。建立工程与图136的操作过程一样。本例中给出的工程名为“c3”，然后单击Finish按钮，弹出如图144所示窗口。
（2） 建立Java Applet源程序。在图144中显示建好的“c3”工程，建立Java Applet源程序与图142的操作过程一样。本例建立的C1_3java源程序如图145所示。
（3） 建立HTML文档。在图145中单击File→New→File选项，如图146所示，弹出如图147所示窗口。
在图147中的File name文本框里输入文档名，本例名为“c1_3html”，单击Finish按钮，弹出如图148所示的窗口。在其中输入文档内容，结果如图149所示。
HTML文档中使用<applet>标签的codebase代码属性来直接调用相关节点的Java Applet。codebase为字节码文件所在位置；code为字节码文件名；width为宽度；height为高度。宽度和高度是浏览器中显示的Java Applet的窗口宽度与高度（以像素为单位）。
（4） 查看c3工程中C1_3java、C1_3class、c1_3html所在位置。在图149的菜单中单击Window→Show View→Navigator选项，如图151所示，弹出如图152所示窗口。




图144建好的“c3”工程




图145编写“C1_3java”程序




图146建立“c1_3html”文档




图147New File窗口




图148空HTML文档框架



图149“c1_3html”文档



图150选择“Navigator”导航选项

从图151左边区域可以看到c3工程中C1_3java、C1_3class、c1_3html所在位置。


图151显示三个文件所在位置

（5） 解释HTML文档。如图152所示，在c3文件夹下用浏览器解释c1_3html，解释结果如图153所示。


图152找到c1_3html文件



图153c1_3html解释结果

114技能提高
下面介绍在JDK环境中运行Java程序。
1运行Java Application源程序过程
步骤一：使用文本编辑器编辑此源文件，存盘文件名为MyApplicationjava。
步骤二：配置path和JAVA_HOME环境变量。
步骤三：编译文件，启动控制台，进入源文件所在目录。在DOS提示符下输入命令：
Javac MyApplicationjava，将编译成字节码文件MyApplicationclass。
步骤四：解释执行，在DOS提示符下输入命令：Java MyAppliction，会得到程序要求显示的所有信息，如图154所示。


图154编译与解释执行结果（一）

2运行Java Applet源程序过程
步骤一：使用文本编辑器编辑此源文件，存盘文件名为MyAppletjava。
步骤二：配置path和JAVA_HOME环境变量。
步骤三：编译文件，启动控制台，进入源文件所在目录。在DOS提示符下输入命令：Javac MyAppletjava，将编译成字节码文件MyAppletclass。
步骤四：解释运行Applet。运行Applet有两种方法，可以在浏览器中解释运行，或利用JDK提供的AppletViewerexe工具运行。
（1） 在浏览器中解释执行Applet程序的方法如下。
因为Applet是在浏览器中以HTML文件的一部分的形式来运行的，因此需要一个包含它的HTML文件，格式为：

<HTML>
<applet code="MyAppletclass" width=300 height=200>
</applet>
</HTML>
用文本编辑器编辑它，将文件保存到字节码文件所在的目录，可任意命名，假设为HelloApplethtml，然后运行HelloApplethtml，就会在浏览器中看到要显示的所有信息，如图155所示。


图155编译与解释执行结果（二）

（2） 使用AppletViewerexe工具运行Applet程序的方法如下。
AppletViewerexe工具位于JDK安装目录下的bin目录里，运行格式为：

DOS提示符> appletviewer HelloApplethtml
执行命令后在AppletViewer工具窗口中显示出结果，如图156所示。因为JDK类库时常更新，所以不能保证旧版本浏览器中的JVM能准确地解释最新类库制作的Java Applet程序。因为AppletViewer工具随Sun公司官方提供的JDK版本更新，因此能保证支持运行Applet程序。


图156编译与解释执行结果（三）

任务12Java基础程序设计
Java语言的基本元素是数字和字符。要学会用字符和数字编写程序，必须掌握Java的语法规则。本节主要介绍Java语言的基本数据类型、运算符、表达式和程序的流程控制。
121任务内容
编写一个字符界面的Java Application程序，接收用户输入的10个整数，比较并输出其中的最大值和最小值。操作步骤如下。
（1） 声明变量与常量。
（2） 利用输入流与缓冲区读取对象，接收从键盘输入的10个整型数据。
（3） 利用选择结构进行数据比较。
（4） 利用循环结构获取最大值与最小值。
122相关知识
知识点一：数据类型
Java语言有两种类型的数据：基本类型（primitive）和引用类型（reference）。
基本类型包括8种：布尔型（boolean）、字节型（byte）、字符型（char）、短整型（short）、整型（integer）、长整型（long）、浮点型（float）和双精度型（double）。
引用类型包括3种：类（class）、接口（interface）和数组（array）。
不同类型数据的取值及取值范围不同，在内存中所占用的空间也不同。表11给出了基本数据类型的数据取值范围和所占用的内存空间。
字符型数据采用Unicode编码，占用两个字节的内存。同ASCII码字符集相比，Java的字符型数据能够表示更多字符。表中“\\u…”表示采用Unicode编码方式。
表11基本数据类型


数据类型
所占空间（字节）
取值范围
布尔型（boolean）
1
false逻辑假或true逻辑真

字节型（byte）
1
-128~+127
字符型（char）
2
'\\u0000'~'\\uFFFF'
短整型（short）
2
-215~215-1，即-32 768~+32 767

整型（int）
4
-231~231-1，即-2 147 483 648~+2 147 483 647

长整型（long）
8
-263~263-1

浮点型（float）
4
-34E-38~34E+38

双精度型（double）
8
-17E-308~17E+308
知识点二：常量和变量
1常量
在程序中以数据值本身字面意义出现的数据称为直接量（literal）或常量，每个直接量必须属于一种数据类型。例如255是一个int类型的数值。直接量的作用是为变量赋值或参与表达式运算。
（1） 布尔常量
boolean类型的常量只有true和false两个值，代表“真”和“假”。书写时不加单引号（''）或者双引号（""）。
（2） 整型常量
整型常量是不含有小数的整数值，可以用来为整型变量赋值。可以采用十进制数、八进制数和十六进制数来表示整型常量。
八进制整型常量用以0开头的数值表示，如025表示十进制的21；十六进制的整型常量用以0x开头的数值表示，如0x25表示十进制的37。对于长整型的常量，表示时要在相应的数值后加符号L或l，如127L。
（3） 浮点型常量
浮点型常量是含有小数部分的数值常量。依据占用内存空间的多少，分为单精度和双精度浮点数常量。浮点数可以用十进制数形式表示，如123456；也可以用科学记数法形式表示，如123e4和123e4，其中e或E之前必须有数字，而e或E之后必须为整数。float浮点数数值后加F或f，double浮点数可以加D或d，也可以不加后缀。

（4） 字符常量
字符常量是由一对单引号括起来的单个字符，可以是Unicode字符集中的任意一个字符，如'H'、'9'、'$'等；也可以是转义字符，或者直接写出的字符编码。
转义字符是一些具有特殊含义和功能的字符，如执行回车、换行等操作。Java中所有转义字符都用反斜线（\\）开头，后面跟一个表示特定含义的字符。表12列出了常用的转义字符及其代表的含义。
表12转 义 字 符


转义字符
Unicode编码
字符功能

\\b
\\u0008
退格

\\r
\\u000d
回车

\\n
\\u000a
换行

\\t
\\u0009
水平制表符

\\f
\\u000c
进纸

\\'
\\u0027
单引号

\〖WTBKB〗"
\\u0022
双引号
2变量
在程序运行过程中，数值可变的量称为变量。变量用于存放运算的中间结果和保存数据。在程序中变量用合法的标识符命名；在内存中变量对应一定大小的内存空间。变量依据其所表示的数据对象而具有不同的类型。不同类型的变量占用的内存空间各不相同。
（1） 变量的声明
使用变量时，必须指出变量的名称和类型，以便为变量分配足够的内存空间。给变量命名必须遵从标识符的命名规则。但给变量命名，除了按照标识符的命名规则外，还要考虑一些特殊的约定。比如，变量名首字符要小写，变量名前加上表示变量类型的前缀等。定义变量采用以下格式：

\[访问修饰符\]\[存储修饰符\]<数据类型><变量名> ;
其中方括号表示可选项，即访问修饰符和存储修饰符是可选的；尖括号表示必选项，即数据类型和变量名是必选的。修饰符将在后续内容中加以详细介绍。变量名要符合前面提到的标识符命名规则。数据类型中，对基本数据类型要用基本数据类型的代表符号；对引用数据类型要用类的名称。下面举例说明变量的声明方法。
【例14】定义变量训练。




boolean bFlag;// 声明布尔型变量bFlag
char cKeyin;// 声明字符型变量cKeyin
byte btRead;// 声明字节型变量btRead
int iCount;// 声明整型变量iCount
float fSum;// 声明浮点型变量fSum
double dAmount;// 声明双精度浮点型变量dAmount

上面的例子中变量名都加了前缀，这样便于在阅读程序时很容易知道变量的类型。变量名前缀一般取数据类型标识的首字符，作为特例byte类型用bt。
（2） 变量初始化
给变量赋初值，即为变量初始化。Java采用“=”符号为变量赋初值。例如bFlag=true；iCount=100；fSum=255f等。对基本类型的变量，也可在声明的同时进行初始化，如char cKeyin='h'；double dAmount=998等。
【例15】变量初始化和常量显示的方法举例。




public class PrimitiveData{
public static void main（String\[ \] args）{
boolean bFlag=true;
byte btVar=125;
char cVar='J';
int iVar=1096;
float fVar=12356f;





double dVar=12356;
Systemoutprintln（"bFlag初始值= "+bFlag）;
Systemoutprintln（"btVar初始值= "+btVar）;
Systemoutprintln（"cVar初始值= "+cVar）;
Systemoutprintln（"iVar初始值= "+iVar）;
Systemoutprintln（"fVar初始值= "+fVar）;
Systemoutprintln（"dVar初始值= "+dVar）;
Systemoutprintln（"***常量显示***"）;
Systemoutprintln（"短整型常量："+067);
Systemoutprintln（"长整型常量："+0x3a4FL）;
Systemoutprintln（"八进制字符常量："+'\\141');
Systemoutprintln（"十六进制字符常量："+'\\u0061'）;
Systemoutprintln（"浮点型常量："+314F）;
Systemoutprintln（"双精度常量："+314）;
Systemoutprintln（"***非数字常量显示***"）;
Systemoutprintln（"非数字常量："+0d/0d）;
Systemoutprintln（"***常变量赋初值***"）;
final float f2=9f;
Systemoutprintln（"常变量："+f2）;
}
}

【运行结果】




bFlag初始值= true
btVar初始值= 125
cVar初始值= J
iVar初始值= 1096
fVar初始值= 12356
dVar初始值= 12356
***常量显示***
短整型常量：55
长整型常量：14927
八进制字符常量：a
十六进制字符常量：a
浮点型常量：314
双精度常量：314
***非数字常量显示***
非数字常量：NaN
***常变量赋初值***
常变量：90

【代码说明】
给变量赋值时，应当保证“=”号右边的直接量的类型同左边变量的数据类型一致，否则会产生错误。例如，bFlag=123；iCount=12356f等语句都是错误的。

（3） 变量的作用域
变量可分为全局变量和局部变量，而变量的分类取决于作用域。全局变量指具有类块作用域的类成员变量；局部变量指具有方法块作用域的变量。局部变量必须初始化或者赋值，否则不能使用；而全局变量是有默认初始值的，默认初始值的情况见表13。
表13类成员变量的默认值



类成员变量的数据类型
默认值

布尔类型 （boolean）
false

整型（integer）
0

浮点型（float）
00

字符型（character）
'\\u0000'
关于类成员变量及其作用域的概念，会在后面“面向对象编程”的学习领域中详述，这里先举个简单的例子说明类成员变量的默认值的意义。
【例16】变量的作用域。




public class Var {
static int a;// 类的成员变量，是全局变量，作用域在类Var的花括号之间
public static void main（String\[\] args） {
int a=10;// 局部变量，作用域在main（）方法花括号之间
Systemoutprintln（"a="+a）;// 输出a的值
}
}

【运行结果】




a=10

【代码说明】
当作用域重合时，局部变量覆盖全局变量，结果为10。
如果第5行中的a不设初始值会怎样？编译时会有错误提示“variable a might not have been initialized”（变量没有初始化）。
如果去掉第5行的代码又会输出什么？输出a=0，因为这是输出类成员变量，而类成员变量有默认值。
知识点三：数据类型转换
各种数据类型可以混合运算。运算中，不同类型的数据要先转化为指定的一种数据类型，然后再进行运算。转换的方式分为两种：自然转换和强制转换。
1自然转换
在一个表达式中，如果存在不同的数据类型，可以按照字节数少的类型能够自动转换成字节数多的类型规律运算，自然转换规则由低到高如图157所示，运算规律如表14所示。
低高
byte，short，charintlongfloatdouble

图157自然转换规则
表14自然转换规律



操作数1的数据类型
操作数2的数据类型
自然转换后的数据类型

byte或short
int
int

byte、short或int
long
long

byte、short、int或long
float
float

byte、short、int、long或float
double
double

char
int
int
精度不同的两种类型的数据混合运算时，低精度数据自动转换为相应的高精度数据类型。
如果操作数为浮点型，那么只要其中一个为double类型，结果就是double类型；
如果两个操作数都为float型，或者一个是float类型而另一个是整型，结果就是float类型；
如果两个操作数为泛整型，只要其中一个是long类型，结果就是long类型；
低于int型的数据（如byte，short，char）之间混合运算时，自然转换为int型数据类型。
【例17】数据类型的自然转换。




public class TransferType {
public static void main（String\[\] args） {
byte b=1;
short s=2;
char ch='a';
long l1=3L;
float f1=123F;
double d1=456D;
int i=b+s+ch;
long l2=il1;
float f2=b+f1;
double d2=d1/s;
Systemoutprintln（"i="+i）;
Systemoutprintln（"l2="+l2）;
Systemoutprintln（"f2="+f2）;
Systemoutprintln（"d2="+d2）;
}
}


【运行结果】




i=100
l2=97
f2=223
d2=228

2强制转换
如果高精度数据向低精度数据转换，就需要使用强制类型转换运算符“（数据类型）”。但强制转换会造成精度丢失，最好不要使用。示例：

int a;
a=（int）364d;// 强制转换后，a值为3
知识点四：运算符和表达式
在数学运算中，我们用运算符号代表各种运算操作，程序中要进行运算同样需要运算符。Java语言的运算符按功能可分为赋值运算符、算术运算符、关系运算符、逻辑运算符、位运算符、条件运算符等。由运算符将变量、常量、方法等连接起来，便构成表达式。
1赋值运算符
“=”号是最简单的赋值运算符，其左边是变量，右边是表达式。表达式的运算结果应和左边的变量类型一致，或者能够转换为左边变量的类型。例如：

int i;// i为整型变量
float x;// 定义浮点型变量
i=128;// 128为整型值，语句正确
i=256f; // 256f为浮点数，浮点数赋给整型变量，存储格式不同，语句不正确
x=129;// 129为整型数值，赋给x后，先转换成浮点数1290，再赋给x
从上面的例子中可以看出，整型数值可以赋给浮点型变量，反过来是不允许的。赋值时，应遵循以下规则：byte→short→int→long→float→double （→表示可赋给）。
赋值运算符“=”还可以同其他运算符结合，实现运算和赋值双重功能。组合方式为：

<变量><其他运算符> =<表达式>
这种赋值的含义为：将变量与表达式进行其他运算符指定的运算，再将运算结果赋给变量。例如执行：
int i=5;
i+=21;
相当于执行：i=i+21，结果为5+21=26。
2算术运算符
算术运算符分单目运算符和双目运算符。单目运算符只有一个参与运算的操作数，双目运算符有两个参与运算的操作数。表15列出了算术运算符类型、用途和相关说明。
表15算术运算符



运算符
用途
举例
说明

＋＋，－－
自动递增，自动递减
＋＋i，j－－
i先加1,再参与运算；j参与运算再减1

＋，－
取正、负号
i=－25
将25取负号后赋给i

*
乘
i=15*2
将15乘以2后赋给i

／
除
fVar=250f/5
用5去除250，结果赋给fVar

％
取余
j=5%3
将5除3取余，结果为2

＋，－
加、减
x=fVar-89
将fVar减去89，结果赋给x
表中“＋＋”和“－－”为单目运算符，运算符可以放在变量之前，也可以放在变量之后，如＋＋i，i＋＋。虽然两种运算都是自动加1，但用在表达式中，两者是有区别的。前一种操作是在i参与其他运算前，先加1；后一种操作是在i参与运算后，再加1。
【例18】递增运算符应用举例。




public class Let{
public static void main（String\[ \] args）{
int iCount=99 , iSum=0 , iAver=0 ;
iSum+=iCount++ ;// iSum=0+99;iCount=99+1
Systemoutprintln（"iCount="+iCount） ;// iCount=100
Systemoutprintln（"iSum="+iSum） ;// iSum=99
iAver+=++iCount ;// iCount=100+1;iAver=0+101
Systemoutprintln（"iAver="+iAver） ; // iAver=101
}
}

在程序的注释中给出了运算的结果。在设计程序时，应当正确地使用递增或递减运算符。
3关系运算符
关系运算符用于对两个表达式进行比较，返回布尔型的结果true或false。一般与条件运算符共同构成判断表达式，用作分支结构或循环结构的控制条件。表16列出了关系运算符及其用途和相关说明。
表16关系运算符



运算符
用途
举例
说明

＞
表达式1＞表达式2
i＞100
i大于100,返回true,否则,返回false

＜
表达式1＜表达式2
i＜100
i小于100,返回true,否则,返回false

＞＝
表达式1＞＝表达式2
i＞＝128
i大于等于128,返回true,否则,返回false

＜＝
表达式1＜＝表达式2
i＜＝10
i小于等于10,返回true,否则,返回false

＝＝
表达式1＝＝表达式2
i＝＝81
i等于81,返回true,否则,返回false

！＝
表达式1！＝表达式2
i！＝9
i不等于9,返回true,否则,返回false
【例19】关系运算符应用举例。




public class Compare{
public static void main（String\[ \] args）{
int iLeftExp=89 , iRightExp=298 ; 
boolean bResult ;// 定义存放比较结果的变量 
bResult=iLeftExp<iRightExp ;
Systemoutprintln（"iLeftExp>iRightExp is "+bResult） ;
bResult=iLeftExp<=iRightExp ;
Systemoutprintln（"iLeftExp<=iRightExp is "+bResult） ;
bResult=iLeftExp!=iRightExp ;
Systemoutprintln（"iLeftExp!=iRightExp is "+bResult） ;
}
}

【运行结果】




iLeftExp>iRightExp is false
iLeftExp<=iRightExp is true
iLeftExp!=iRightExp is true

4逻辑运算符
逻辑运算符用于连接关系表达式，对关系表达式的值进行逻辑运算。运算符为&&、‖和！。&& 运算符对应AND运算；‖运算符对应OR运算；! 运算符对应NOT运算。表17列出了逻辑运算符及其使用方法。Java中的!、&&和‖运算符采用了电工学中的“短路”方式进行运算，即先求出逻辑运算符左表达式的值，如果其值能够推算出整体表达式的值，就不再运算右侧表达式，这样加快了程序的执行效率，但是也需要注意其中变量值的变化情况。
表17逻辑运算符


运算符
用途
举例
说明

&&
逻辑与运算
（9>6）&&（100<125）
左右表达式均为true,结果返回true

‖
逻辑或运算
（9>6）‖（100>125）
左表达式为true，结果为true

!
取反运算
!（255>125）
比较表达式为true,取反后结果返回false
【例110】观测“短路”运算符的效果。




public class Test{
public static void main（String args\[\]）{
int a=2,b=1;
Systemoutprintln（""+（a>b||++b>=a））;
Systemoutprintln（b）;
}
}

【运行结果】




true
1

【代码说明】
因为逻辑表达式中a>b的值为true，因此整体的表达式就为true，右侧的++b>=a表达式不再参与运算，所以b的值仍为1。
5条件运算符
条件运算符（?:）是唯一的三元运算符，形式为：

表达式1？表达式2：表达式3
表达式1是关系或布尔表达式，返回值为布尔值，如果表达式1的值为true，整体表达式的值为表达式2的值；如果表达式1的值为false，则整体表达式的值为表达式3的值。示例：

int a=1800;
int salary=a>1600 ? 2000 : 1900;// a>1600结果为true，结果salary值为2000
6表达式
由变量、常量、关键字和运算符进行组合，构成表达式。表达式用来执行程序中要求的计算操作，并返回计算的结果。Java中允许使用类型匹配的简单表达式构造复合表达式，表达式返回值的数据类型取决于表达式中使用的元素类型；表达式的运算顺序由运算符的优先级决定，同样也可通过使用圆括号指定运算顺序。
（1） 运算符的优先级


运算符优先级是指同一表达式中多个运算符被执行的次序。同数学中的运算相类似，不同运算符运算的优先顺序是不一样的。比如，在同一表达式中，如果同时有加、减和乘、除运算，优先计算乘、除，再计算加、减。表18列出了Java运算符的优先级顺序。
表18运算符优先级



优先级
运算符

1

\[ \]
（）
操作数++
操作数--

2
++操作数
--操作数
!
~
-

3
new
（type）




4
*
/
%



5
+
-




6
<<
>>
>>>



7
<
>
<=
>=
instanceof

8
= =
!=




9
&





10
^





11
|





12
&&





13
‖





14
? :





15
=
+=
-=



16
*=
/=
%=



17
&=
^=
|=



18
<<=
>>=
>>>=


（2） 运算符运算顺序的规则
由多种运算符连接的变量、常量、成员和表达式构成复合表达式，如表达式：

fVar=fA+fB*fA-fB+iVar++ ;// 表达式（1）
在复合表达式中，先进行哪种运算符的计算，应当按照一定的规则。一般情况下，如果运算符的优先级相同，则按照运算符的优先级顺序进行计算，如乘和除运算优先级相同，加和减运算优先级相同。要改变运算顺序，可以用括号将要优先计算的表达式括起来，如表达式：

fVar=（fA+fB）*（fA-fB）+iV++ ;// 表达式（2）
表达式（1）和表达式（2）的结果是不同的。
在有赋值、算术、比较、逻辑等运算符组成的复合表达式中，运算规律一般为：算术运算→比较运算→逻辑运算→赋值运算。这是可以理解的，因为计算出结果才能进行比较，比较后才能得到逻辑结果，有了逻辑结果才能进行逻辑运算，赋值时将计算结果赋给变量。
知识点五：流程控制
Java程序是由若干条语句组成的，语句本身是由Java的关键字、表达式等构成。每条语句以分号“；”结束，多条语句组合在一起形成复合语句或语句块，复合语句用大括号{}括起来。
一般情况下，计算机按照语句的先后顺序逐条执行语句。在某些情况下，需要有选择地或者重复地执行某条或某些语句时，则使用程序的流程控制语句。
流程控制结构可以分为：顺序结构、选择（分支）结构和循环结构。
1选择语句
分支语句有if语句和switch…case语句两种。
（1） 简单的if语句
if语句用于进行条件判断，根据判断的结果，选择执行相应的语句或语句块。简单的if语句只有一种选择，执行某语句或不执行某语句。其语法格式为：

if（表达式）
语句块
括号中的表达式是一个逻辑表达式，当表达式结果为逻辑“真”时，执行语句块；否则，执行if语句后面的语句。
【例111】将三个整型数中最大数显示出来。




public class DisplayMax{
public static void main（String\[ \] args）{
int iA=3,iB=9,iC=5;
if（iB<iA）// 判断iA和iB的大小
iB=iA;// 大数放在iB中
if（iC<iB）// 判断iB和iC的大小
iC=iB;// 大数放在iC中
Systemoutprintln（"The Max value="+iC）;
}
}

【运行结果】




The Max value=9

（2） if…else语句
在程序设计中，会遇到如果条件满足，执行语句1，否则执行语句2的情况，此时，应使用if…else语句。if…else语句的语法格式为：

if（表达式）
语句块1
else
语句块2
当条件表达式的值为true时，执行语句块1，跳过else和语句块2；否则，条件表达式的值为false时，跳过语句块1，执行语句块2。
【例112】比较两个整型数的大小，并输出较小值。




public class DisplayMinium{
public static void main（String\[ \] args）{
int iA=3,iB=9;
if（iB<iA）// 当iB<iA时，iB<iA返回true 
Systemoutprintln（"The Minium value="+iB）;
else
Systemoutprintln（"The Minium value="+iA）;
}
}

【运行结果】




The Minium value=3

（3） if语句的嵌套
在实际编程中，经常遇到条件关系比较复杂的问题，比如，当满足某个条件时，还需要继续判断是否满足其他条件。在这种情况下，可以在if语句或者if…else语句中，再使用if或if…else语句，这样，便形成了嵌套的if语句。其常见的语法形式为：

if（表达式1）
语句块1
else
if（表达式2）
语句块2
else
if（表达式3）
语句块3
…
else
if（表达式m）
语句块m
else
语句块m+1
如果表达式1为true，则执行语句块1，其他语句块被忽略；否则，继续判断表达式2的值。如果表达式2为true，则执行语句块2；否则，继续判断下面的表达式。如果所有表达式的值为false，则执行最后一个else后面的语句块m+1。
在if语句嵌套时，要注意if和else的搭配关系，否则，容易造成判断错误。要掌握一条原则，即else和距它最近的if构成搭配关系。
【例113】从控制台上读入学生成绩，将该成绩换算成五个等级显示成绩信息。




public class TestIf {
public static void main（String\[\] args） {
int score=IntegerparseInt（args\[0\]）;
if（score>=60）{
if（score<70）{
Systemoutprintln（"你的成绩为及格！"）;
}
if（score>=70&&score<80）{
Systemoutprintln（"你的成绩为中等！"）;
}
if（score>=80&&score<90）{
Systemoutprintln（"你的成绩为良好！"）; 
}
if（score>=90&&score<=100）{
Systemoutprintln（"你的成绩为优秀！"）;
}
}
else{
Systemoutprintln（"你的成绩不及格！"）;
}
}
}

【运行结果】




输入命令格式：DOS控制台>javaTestIf89
结果显示为：你的成绩为良好！

（4） switch语句
使用if语句，能够满足各种条件判断。但在某些情况下，使用if语句不一定很方便。如一个表达式可能有很多取值，要根据不同的取值，决定执行相应的语句。用if语句时，需要较多的if语句进行嵌套，会使程序可读性差，此时可使用switch语句，即多分支选择语句。
switch语句的语法格式为：

switch（表达式）{
case常量表达式1 ：
语句块1
break;
case常量表达式2 ：
语句块2
break;
…
case常量表达式m：
语句块m
break;
default ：
语句块m+1
}
语句中switch、case、default是关键字，表达式的类型应为byte、short和int类型，语法中的default子句可以省略。执行switch语句时，先计算表达式，将表达式的值与各个常量表达式的值进行比较，若与某个常量值相等，就执行该常量后面的语句；若都不相等，就执行default后面的语句。若没有default子句，则直接跳出switch语句。
switch语句和if语句分别适用于不同的情况，if语句用于根据一定范围内的值或者条件进行判断；而switch语句用于根据单个整数值（不包括长整型）进行判断，每个case语句中常量表达式的值应是唯一的，不能有相同的常量值。
在switch语句中，使用break语句能跳过其后的判断语句，否则，程序会执行后面case语句中的程序段，而不进行判断，直到再遇到break语句。
【例114】设计简单的计算器，根据输入的运算符号，将两个整数进行相应的计算。




import javaio*;
public class Calculation{
public static void main（String\[ \] args）throws Exception{
int iA=255,iB=289;
char cOp;
Systemoutprintln（"Please input opterator:"）;
cOp=（char）Systeminread（）;  // read（）返回整型数，须强制转换为char
switch （cOp） { // cOp为字符型，能够转换成整型且不丢失信息
case '+':
 Systemoutprintln（"iA+iB="+（iA+iB））;
 break;
case '-':
 Systemoutprintln（"iA-iB="+（iA-iB））;
 break;
case '*':
 Systemoutprintln（"iA*iB="+（iA*iB））;
 break;
case '/':
 Systemoutprintln（"iA/iB="+（iA/iB））;






 break;
default:
 Systemoutprintln（"Unknown operator！"）;
}
}
}

【运行结果】




Please input operator:
+
iA+iB=544

【代码说明】
switch语句中的表达式是字符型，这是允许的，因为字符型表达式可以转换为整型表达式而不丢失信息。如果表达式是长整型、浮点型或双精度型，必须进行强制类型转换，使之变成整型表达式，并能够计算出确定的值。
2循环语句
循环语句用于反复执行一段代码，直到满足某种条件为止。Java语言有三种循环语句：while、do…while和for循环语句。
当不知道一个循环要重复执行多少次，可以选择while循环（当型循环）或者do…while循环（直到型循环）；如果要执行已知次数的循环，可以使用for循环。但不管怎样，一个完整的循环结构应该包含四个组成部分。
① 初始化部分（initialization）：用于设置循环的初始条件，如设置计数器的初始值。
② 判断部分（estimation）：是一个关系或布尔表达式，用于判断循环是否可以继续运行的条件。
③ 迭代部分（iteration）：修改循环初始条件，用于控制循环的次数，如使计数器的值自增或自减。
④ 循环体部分（body）：循环中反复执行的代码。
（1） while循环语句
while循环又称为“当型循环”，意指当某条件成立时循环执行。while语句的语法格式为：

while（条件表达式）{
语句块
}
while语句首先计算条件表达式的值，若表达式值为true，则执行语句块，再对表达式进行判断，直到表达式的值为false时，停止执行语句块。while语句中的语句块也叫循环体，循环体中应当有改变表达式值的语句，否则，会造成程序无限循环的情况。
【例115】求整数X的N次幂，并显示出结果。




public class X_N{
public static void main（String\[ \] args）{
int iX=2 , iN=7, iXN=1;
int i=0 ; // 循环变量
while（i<iN） {// i<iN为条件表达式,循环体开始
iXN*=iX; // 计算iXN=iXN*iX，共计算iN次
i++;// 改变控制循环次数的变量的值
} // 循环体结束
Systemoutprintln（iX+"的"+iN+"次幂是："+iXN）;
}
}

【运行结果】




2的7次幂是：128

【代码说明】
从程序中看出循环程序包含循环变量、条件表达式、循环体等要素。程序中的变量i是循环变量，i<iN为条件表达式，循环体由两条语句组成。循环变量i的值决定了循环的次数，i取值0~6，0为初值，6为终值。循环体中的i++不断改变i的值,当i=7时，条件表达式为false，结束循环。
（2） do…while循环语句
do…while循环又称为“直到型循环”，意指直到某条件不成立时，循环才终止执行。do…while语句的语法格式为：

do{
语句块
} while（条件表达式）；
do…while 语句先执行循环体中的语句块，再计算while后面的条件表达式。若条件表达式为true，继续执行语句块，否则跳出循环，执行while后面的语句。
do…while语句和while语句的区别之处在于：do…while先执行语句块，后进行条件判断，因此语句块至少被执行一次；while语句先判断条件表达式，如果一开始循环条件即不满足，循环体可能得不到执行。
【例116】用do…while语句，求0~20之间的某个随机整数的阶乘。




import javautilRandom;// 导入Random类
public class CountN{
public static void main（String\[ \] args）{
Random r=new Random（）;// 创建Random类对象
float fX=rnextFloat（）;// 取得随机浮点数





int iN=Mathround（21*fX）;// 取得随机整数
long lResult=1l;// 存放阶乘结果
int iK=1;// 定义循环变量，并赋初值
do{ // 循环体开始
lResult*=iK++;// 循环体
}while（iK<=iN）;// 判断表达式，结果为false循环结束
/*循环结束*/
Systemoutprintln（iN+"!="+lResult）;
}
}

【运行结果】




4!=24

（3） for语句 
for语句也是在条件成立的情况下反复执行某段程序代码，for语句的语法格式为：

for（初始化表达式；条件表达式；循环变量表达式）{
语句块
}
初始化表达式只在循环开始时执行一次；条件表达式决定循环执行的条件，每次循环开始时计算该表达式，当表达式返回值为true时，执行循环，否则循环结束；而循环变量表达式是在每次循环结束时调用的表达式，用以改变条件表达式中变量的值，结果返回给条件表达式，如条件表达式值为false，退出循环，否则，继续执行语句块。
以上三个表达式是可选部分，如果for语句中没有这三个表达式，便构成一个无限循环；在循环体中，应使用其他控制语句，使程序能够适时结束循环。
【例117】求5个随机实数的和。




importjavautilRandom;
public class TestSum{
public static void main（String\[ \] args）{
Random r=new Random（）;
float sum=0;
for（int i=0;i<5;i++）{// 初始化表达式为i=0,i<5为条件表达式，
i++为变量表达式
/*循环体开始*/
float x=rnextFloat（）;
sum+=x;
Systemoutprintln（"x="+x+"\\t\\tsum="+sum）;
}// 循环体结束
}
}

【运行结果】




x=09236592sum=09236592
x=018248057sum=11061398
x=011676085sum=12229006
x=069475585sum=19176564
x=067241156sum=25900679

【代码说明】
循环变量初值为0，满足i<5，进行第1次循环；第1次循环结束后，计算表达式i++,使i=1，此时判断i<5，依然成立，继续下一次循环。如此反复，直至i=5时，条件表达式值为false，结束循环，执行输出语句。
3其他控制语句
在分支、循环体或语句块中，可能需要根据某种情况，控制程序退出循环或跳过某些语句。Java语言的break和continue语句能实现以上功能。
（1） break语句
break语句在switch中，用于结束switch语句；而在循环语句中，则用于跳出循环体。如果是循环嵌套的情况，break语句用于跳出当前循环。
【例118】计算1~9整数的平方。




public class TestBreak{
public static void main（String\[ \] args）{
int i=0;
while（true） { // 条件永远为真，循环开始
i++;
if（i==10） {// 当i超过9时，结束循环
Systemoutprintln（"Ok,run break"）;
break; // 执行该语句跳出while循环
}
Systemoutprint（i+"*"+i+"="+i*i+" "）;
}// 循环结束
Systemoutprintln（"Encounter break!"）; // 跳出循环执行的第1条语句
}
}

【运行结果】




1*1=1 2*2=4 3*3=9 4*4=16 5*5=25 6*6=36 7*7=49 8*8=64 9*9=81 Ok,run break
Encounter break!

【代码说明】
while循环语句中的表达式为true，即值永远为真。如果循环体中没有跳出循环的语句，程序将无限循环下去。当i值为10时，执行break语句，使程序跳过计算平方的语句，转到while循环后的第1条语句继续执行。
（2） continue语句
continue语句用于跳过当前循环体中该语句后的其他语句，转到循环开始，并继续判断条件表达式的值，以决定是否继续循环。
【例119】输出1~9中除6以外所有偶数的平方。




public class TestContinue{
public static void main（String\[ \] args）{
for（int i=2;i<=9;i++） {// i<=9为循环条件，循环开始
if（i==6||i%2!=0） {// i为奇数或6时，不计算
Systemoutprintln（"i="+i+"->Continue!"）;
continue;// 修改i值,并判断i<=9
}
Systemoutprintln（i+"*"+i+"="+i*i+" "）;// i为偶数，计算平方值
}// 循环结束
Systemoutprintln（"Finished,bye!"）;// 循环结束的第1条语句
}
}

【运行结果】




2*2=4
i=3->Continue!
4*4=16
i=5->Continue!
i=6->Continue!
i=7->Continue!
8*8=64
i=9->Continue!
Finished,bye!

【代码说明】
continue语句和break语句不同，continue跳过循环体余下部分语句后，重新转到条件判断语句，在该程序中转到for语句，先修改循环变量i的值，然后判断表达式i<=9的值，如果值为真，继续循环；否则，退出循环。
123任务实施
1任务分析
（1） 声明变量、数组和字符串，后续内容会详细介绍，读者不妨先记住代码编写格式。
（2） 利用输入流与缓冲区读取对象，从键盘输入10个整型数据，后续内容会详细介绍，读者不妨先记住代码编写格式。
（3） 利用选择结构进行数据比较。
（4） 利用循环结构获取最大值与最小值。
2程序实现代码




import javaio*;
public class Max {
public static void main （String args\[\]）throws Exception {
String s;// 声明字符串对象
int a\[\]=new int\[10\];// 声明可容纳10个元素的数组
int max=0;// 声明最大值变量
int min=0;// 声明最小值变量
for（int i=0;i<alength;i++）{// 循环获取10个整型数据
BufferedReader br=new BufferedReader （new InputStreamReader（Systemin））;
s=brreadLine（）;
a\[i\]=IntegerparseInt（s）;
}
if（a\[0\]<a\[1\]）{// 输入两个值进行比较后存放为初始值
max=a\[1\];
min=a\[0\];
}
else{
max=a\[0\];
min=a\[1\];
}
for（int i=2;i<10;i++）{// 将初始值依次与其他值比较
if（（a\[i\]<min）|（a\[i\]==min））{
min=a\[i\];
}
if（（a\[i\]>max）|（a\[i\]==max））{
max=a\[i\];
}





}
Systemoutprintln（"最大值为:"+max+","+"最小值为："+min）;  // 输出结果
}
}

【运行结果】




4 6 7 11 9 3 2 16 10 15
最大值为：16，最小值为：2

124技能提高
本节进行嵌套循环训练。
在循环体中的语句可以是任何语句，包括循环语句。如果循环体中还有循环语句，便形成了循环嵌套的情况。下面举例说明循环嵌套的编程方法。
【例120】求0~100之间的素数。




public class PrimeNumber{
public static void main（String\[ \] args）{
int\[ \] x=new int\[100\]; // 定义具有100个元素的数组x
for（int i=1;i<100;i++） // 循环100次，将1~100赋给x的元素
x\[i\]=i;
for（int j=1;j<xlength;j++） {// 逐次取数组的每个元素
boolean flag=true; // 设置标志
for（int i=2;i<x\[j\];i++） // 某个数x\[j\]同2到x\[j-1\]进行比较
if（x\[j\]%i = = 0） flag=false; // 能被其中某个数整除便不是素数
if（flag） Systemoutprint（x\[j\]+" "）; // 不能被任何数整除，是素数
}
}
}

【运行结果】




1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

【代码说明】
能够被1和自身整除，而不能被其他数整除的数为素数。如果判断一个数是否为素数，可以将该数被从2开始直到该数减1的数相除，如果不能被其中任何数整除，则该数为素数。需要循环判断x\[i\]-2次。如果需要判断100个数，这样的循环需要重复100次。因此这是一个双重循环的应用实例。
任务13数组和字符串程序设计
数组和字符串是程序设计中使用较多的数据类型。合理地使用数组和字符串，会简化程序设计、提高编程效率。Java中的数组和字符串是复合数据类型，因而同其他语言中使用的数组和字符串有较大的区别。本章分别介绍数组和字符串的基本知识，结合具体实例，阐述了这两种数据类型的具体使用方法。
131任务内容
模拟简单的用户登录程序，利用控制台设置初始化参数的方式输入用户名和密码，假设用户名称为sunlina，密码为lnjd。操作步骤如下。
（1）根据要求熟悉利用控制台设置初始化参数的方式。
（2）判断输入的参数个数是否合法，如果不合法，须提示用户的程序执行错误，并退出程序；如果用户正确输入参数，则可以进行用户名及密码的验证。
（3）验证成功，信息正确则显示“欢迎×××光临！”，否则显示“错误的用户名和密码”。
（4）主方法作为客户端，为方便客户使用，尽量设置较少的代码。
132相关知识
知识点一：数组的定义与使用
数组是相同类型变量的集合，这些变量具有相同的标识符即数组名，数组中的每个变量称为数组的元素（array element）。为了引用数组中的特定元素，通常使用数组名连同一个用中括号“\[ \]”括起来的整型表达式，该表达式称为数组的索引（index）或下标。如iArray\[9\]，iArray是数组名，数字9为数组元素的索引。数组元素的索引就是该数组从开始的位置到该元素所在位置的偏移量。第一个元素的索引值为0；第二个元素的索引值为1，iArray\[9\]是iArray数组中的第10个元素。
在Java语言中，数组不是基本数据类型，而是复合数据类型，因此数组的使用方式不同于基本数据类型，必须通过创建数组类对象的方式使用数组。
1数组的定义
数组的定义方式为：typearrayName\[ \];或者type\[ \]arrayName;
其中，type为数据类型，它可以是Java允许的任何数据类型，包括基本数据类型和复合数据类型，arrayName代表数组名，任何合法的标识符都可以作为数组名，\[ \]指明该变量是数组类型的变量。例如：

int\[ \] iPrimes;
char\[ \] cName;
float\[ \] fScore;
以上例子分别定义了整型、字符型和浮点型三个数组变量。定义数组时，系统并没有为其分配内存，也没有指明数组中元素的个数。不能像其他语言（如C语言）那样，在\[ \]中直接指出元素的个数，如int\[9\] icount是非法的数组定义。因为数组本身是对象，必须用new运算符创建数组。假设要创建具有100个元素的整型数组，数组名为iValue，方法如下：

int\[ \] iValue; // 定义数组变量iValue
iValue=new int\[100\]; // 创建数组
以上步骤定义并创建了名为iValue、元素个数为100的数组，其元素为：iVlaue\[0\]… iVlaue\[99\]。可将以上两步合并为：int\[ \] iValue=new int\[100\];这两种方法的结果是一样的。
【例121】定义一个整型数组，显示数组元素被赋值前后的值。




public class DataInt{
public static void main（String\[ \] args）{
int\[ \] iN=new int\[10\];// 定义并创建具有10个元素的整型数组 
for（int i=0;i<10;i++）{// 在数组没有赋值时，显示数组元素的值 
Systemoutprint（"iN\["+i+"\]="+iN\[i\]+" "）;
}
Systemoutprintln（"\\n"）;
for（int i=0;i<iNlength;i++）{// 数组元素赋值后，显示数组元素的值 
iN\[i\]=i;
Systemoutprint（"iN\["+i+"\]="+iN\[i\]+" "）;
}
}
}

【运行结果】




iN\[0\]=0 iN\[1\]=0 iN\[2\]=0 iN\[3\]=0 iN\[4\]=0 iN\[5\]=0 iN\[6\]=0 iN\[7\]=0 iN\[8\]=0 iN\[9\]=0
iN\[0\]=0 iN\[1\]=1 iN\[2\]=2 iN\[3\]=3 iN\[4\]=4 iN\[5\]=5 iN\[6\]=6 iN\[7\]=7 iN\[8\]=8 iN\[9\]=9

结果中第一行是数组元素被赋值前的值，可见整型数组在元素被赋值前，其缺省值为0。第二行是赋值后各元素的值。
2数组的初始化
不同类型的数组在创建之后，有不同的缺省值，如整型数组每个元素的缺省值为0；布尔型数组每个元素的缺省值为false。类的数组的每个元素的缺省值为null。如果要为数组元素赋予其他值，必须对数组元素进行初始化。
数组初始化是为了给数组元素赋予缺省值以外的其他值。初始化有三种方法：
（1） 定义数组时直接初始化；
（2） 直接访问数组元素为部分或全部元素初始化；
（3） 用已初始化的数组初始化另一数组。
【例122】分别定义布尔型、字节型、字符型和类类型的数组，并进行初始化。




boolean\[ \] bFlag={true,false,false,true,false};
byte\[ \] btValue={1,2,3,4,5,6};
char\[ \] cValue={'a','b','c','d','e','f'};
IPCard\[ \] ipcards={new IPCard（123,123L,100）,new IPCard（245,6789L,100）};

该例是采用直接初始化的方法，每条语句确定了数组变量的类型、元素的个数和元素的值。和基本类型不同的是，类类型的数组元素应当以类的具体对象作为元素，因此语句4中用new运算符直接创建类IPCard的两个对象，得到ipcards\[0\]、ipcards\[1\]两个IPCard的实例。
【例123】定义并创建整型、浮点型、双精度型和类类型数组，数组元素为10个，对各数组元素进行初始化。




int\[ \]iValue=new int\[10\];
float\[ \]fValue=new float\[10\];
double\[ \] dValue=new double\[10\];
IPCard\[ \] ipcards=new IPCard\[10\];
for（int i=0;i<10;i++）{
iValue\[i\]=i;
fValue\[i\]=（float）i;
dValue\[i\]=（double）i;
ipcards\[i\]=new IPCard（（i+1）*100+i,（i+1）*123L,99）;
}

语句1～语句4定义并创建了数组iValue、fValue、dValue、ipcards，数组的元素个数为10。语句5～语句10利用for循环语句为数组的元素赋值。访问数组的各个元素时，需要利用数组的索引，即中括号“\[ \]”中的表达式的值。该例中i代表数组的索引，i为0时，指向数组的第一个元素，i为1时，指向数组的第二个元素，依此类推，i为9时，指向数组最后一个元素。
3二维数组
只有一个索引或下标的数组称为一维数组。在实际应用中，经常遇到使用多个索引或下标的情况。比如要记录20家计算机生产厂商在一年内每天生产计算机的数量，可以定义一个具有双下标的数组，一个下标长度为20；另一个下标长度为365，数组定义方法如下：

int \[ \]\[ \] iAmount=new int\[20\]\[365\];
像iAmount这样具有两个索引的数组称为二维数组，第一个索引的取值范围是0～19；第二个索引的取值范围是0～364。数组具有7 300（20×365）个元素。数组中的元素可表示为iAmount\[i\]\[j\]，例如iAmount\[5\]\[99\]表示第6家计算机厂商第100天的计算机产量。如果用一维数组表示，需要定义具有7 300个元素的数组。要明确数组中的某个元素如iAmount\[99\]，对应的是哪家计算机厂商，在哪一天的计算机产量，还需要进行较为复杂的运算，这给后续的数据处理带来了困难。用二维数组表示数据，可使数据所表达的含义更加清楚。
实际上，二维数组相当于一个二维表格，第一个索引代表表格的行，第二个索引代表表格的列，iAmount\[20\]\[365\]是一个具有20行、365列的表格中的元素，每一格存储1个元素。第1行的元素为iAmount\[0\]\[0\]～iAmount\[0\]\[364\]；第2行的元素为iAmount\[1\]\[0\]～iAmount\[1\]\[364\]……直到第20行的元素为iAmount\[19\]\[0\]～iAmount\[19\]\[364\]。在内存中，二维数组元素是以行的顺序存储数组的，如图158所示。


图158二维数组的存储方式

二维数组的长度由行数×列数得到，可以用“数组名length”得到行数，用“数组名\[i\]length”得到每行的列数。例如，iAmountlength的值为20；iAmount\[0\]length的值为365。要注意，iAmountlength所得到的值不是二维数组的总长度。
【例124】计算20家计算机厂商一年中平均每天的计算机产量。




public class CountComputer{
public static void main（String\[ \] args）{
int\[ \]\[ \] iAmount=new int\[20\]\[365\];// 定义并创建二维数组iAmount
int iSum=0,iAverage; // iSum,iAverage为两个存储总数和平均值的整型变量
/*以下循环利用生成的0到100之间的随机数模拟各厂家每天的计算机产量*/
for（int i=0;i<iAmountlength;i++） { // iAmountlength为行数
for（int j=0;j<iAmount\[i\]length;j++） { // iAmountlength为每行的列数
iAmount\[i\]\[j\]=（int）（100*Mathrandom（)）; 
}
}
/*以下循环计算一年内各厂家的总产量*/
for（int i=0;i<iAmountlength;i++）{
for（int j=0;j<iAmount\[i\]length;j++）{
iSum+=iAmount\[i\]\[j\];




}
}
iAverage=iSum/（iAmountlength*iAmount\[0\]length）;//计算机每天的平均产量
Systemoutprintln（"The average amount per day is :"+iAverage）;//显示结果
}
}

【运行结果】




The average amount per day is:64

【代码说明】
首先定义并创建了二维数组iAmount，第一个双重循环为每个数组元素赋值，循环变量的终值采用数组对象的length成员；也可以直接使用“i<20”或“j<365”，但如果数组的长度发生变化，必须修改循环变量的终值，所以采取引用数组对象的length成员的方法比较好。
Mathrandom（）产生的是double类型的00～10之间的随机数，必须用“（int）”进行强制类型转换，变成整型数赋给数组元素。Math是Java的标准类，它提供许多方法，random（）是用于产生随机数的方法。
知识点二：数组的引用传递
方法中可以传递和返回数组，其接收参数必须是符合数据类型的数组。同时在把数组传递进方法后，如果方法对数组本身做出任何修改，修改结果也将保存下来。
1向方法中传递数组
【例125】向方法中传递数组。




public class ArrayRefDemo{
public static void main（String args\[\]）{
int temp\[\] = {2,4,6} ;// 利用静态初始化方式定义数组
fun（temp） ;// 传递数组
for（int i=0;i<templength;i++）{
Systemoutprint（temp\[i\] + "、"） ;
}
}
public static void fun（int x\[\]）{// 接收整型数组的引用
x\[0\] = 8;// 修改第一个元素
}
}

【运行结果】




8、4、6、

【代码说明】
在程序中将一个整型数组temp传递到方法中，然后在fun（）方法中将此数组的第一个元素的内容修改为8。因为数组是引用数据类型，所以，即使方法本身没有任何返回值，修改后的结果也会被保存下来。
2使用方法返回数组
【例126】使用方法返回一个数组。




public class ArrayRefDemo{
public static void main（String args\[\]）{
int temp\[\] = fun（） ;// 通过方法实例化数组
print（temp） ;// 打印数组内容
}
public static void print（int x\[\]）{
for（int i=0;i<xlength;i++）{
Systemoutprint（x\[i\] + "、"） ;
}
}
public static int\[\] fun（）{// 返回一个数组
int ss\[\] = {2,4,6,8,10} ;// 定义一个数组
return ss ;
}
}

【运行结果】




2、4、6、8、10、

3向方法中传递多个数组参数
【例127】数组复制操作。
若给定两个数组，将其中一个数组指定位置的内容复制给另一个数组，可以使用方法来完成。在方法中接收5个参数，分别为源数组名称、源数组起始点、目的数组名称、目的数组起始点、复制长度。




public class ArrayRefDemo{
public static void main（String args\[\]）{
int i1\[\] = {1,2,3,4,5,6,7,8,9} ;// 源数组
int i2\[\] = {11,22,33,44,55,66,77,88,99} ;// 目标数组
copy（i1,3,i2,1,3） ;// 调用复制方法
print（i2） ;
}




public static void copy（int s\[\],int s1,int o\[\],int s2,int len）{
for（int i=0;i<len;i++）{
o\[s2+i\] = s\[s1+i\] ;// 进行复制操作
}
}
public static void print（int temp\[\]）{// 输出数组内容
for（int i=0;i<templength;i++）{
Systemoutprint（temp\[i\] + "\\t"） ;
}
}
}

【运行结果】




114565566778899

当然数组的复制操作在Java中存在类库的支持，可以直接使用Systemarraycopy（）方法，此方法中接收参数的顺序和意义与上例相同。
【例128】使用Java类库中的方法完成数组复制操作。




public class ArrayRefDemo{
public static void main（String args\[\]）{
int i1\[\] = {1,2,3,4,5,6,7,8,9} ;// 源数组
int i2\[\] = {11,22,33,44,55,66,77,88,99} ;// 目标数组
Systemarraycopy（i1,3,i2,1,3） ;// 调用Java中对数组支持复制方法
print（i2） ;
}
public static void print（int temp\[\]）{// 输出数组内容
for（int i=0;i<templength;i++）{
Systemoutprint（temp\[i\] + "\\t"） ;
}
}
}

知识点三：字符串的特点与使用
字符串是由若干字符组成的字符序列，是程序设计中经常使用的数据类型，如显示提示信息，处理名称、标题、地址等都可以使用字符串。Java语言提供了两个标准类——String类和StringBuffer类用于处理字符串。下面介绍这两个类及其使用方法。
1String和StringBuffer类
同其他基本数据类型相似，字符串也有常量和变量。字符串常量是用一对""括起来的字符序列，如"Congratulations!"。字符串变量实际上是String类或StringBuffer类的对象。字符串变量的声明方法如下：

String strName；
该语句声明了名为strName的字符串。字符串变量声明以后，并没有指向任何对象，此时，strName为空值（null）。有两种方法使strName指向具体对象。
（1） 用“=”运算符将其指向某一字符串，例如语句：

strName="Bill Gates"；
（2） 用new运算符创建String类的对象，例如语句：

strName=new String（"Bill Gates"）;
这两种方法的结果是一样的。同String类不同的是，StringBuffer对象不能用“=”创建，必须用new运算符创建，例如语句：

StringBuffer strbTitle=new StringBuffer（"Tsinghua University"）；
StringBuffer strbTitle=new StringBuffer（strName）；
String和StringBuffer的另一个不同之处在于，String对象所指向的字符串，其内容不能改变（immutable）。也就是说，创建了一个字符串对象之后，如果将一个新的字符串内容赋给该对象，该对象不再指向原来的字符串，而是指向一个新的字符串对象。例如，有两个String类型的字符串str1和str2，其中str1="The source string!"，执行str2=str1后，str1和str2均指向同一字符串，str1和str2的内容相同；当再执行str2="The source string! Changed"时，按照对象的引用规则，此时str1和str2的内容均应变为"The source string! Changed"，但事实却相反，str1仍为原来的内容，而str2指向了字符串"The source string! Changed"。以上操作的结果见图159。


图159字符串赋值后的操作结果

对于StringBuffer类来说，执行类似的操作，结果会大不相同。假如执行如下操作：

StringBuffer strb1=new StringBuffer（"The source string!"）;
StringBuffer strb2=strb1;
strb2append（"Changed"）;
上面三条语句执行结束后，strb1和strb2的内容是相同的，执行结果见图160。


图160赋值操作的执行结果

【例129】用实例说明图161和图162的正确性。




public class StringBufferDemo{
public static void main（String\[ \] args）{
String str1="The source string!";
String str2=str1;
Systemoutprintln（"String类：str2 变化前的执行结果"）;
Systemoutprintln（"str1="+str1）;
Systemoutprintln（"str2="+str2）;
str2=str2+"Changed"; //改变str2
Systemoutprintln（"String类：str2 变化后的执行结果"）;
Systemoutprintln（"str1="+str1）;
Systemoutprintln（"str2="+str2）;
StringBuffer strb1=new StringBuffer（"The source string!"）;
StringBuffer strb2=strb1;
Systemoutprintln（"StringBuffer类：strb2 变化前的执行结果"）;
Systemoutprintln（"strb1="+strb1）;
Systemoutprintln（"strb2="+strb2）;
strb2append（"Changed"）; //改变strb2
Systemoutprintln（"StringBuffer类：strb2 变化后的执行结果"）;
Systemoutprintln（"strb1="+strb1）;
Systemoutprintln（"strb2="+strb2）;
}
}

【运行结果】




String类：str2 变化前的执行结果
str1=The source string!
str2=The source string!
String类：str2 变化后的执行结果
str1=The source string!
str2=The source string!Changed
StringBuffer类：strb2 变化前的执行结果
strb1=The source string!
strb2=The source string!
StringBuffer类：strb2 变化后的执行结果
strb1=The source string!Changed
strb2=The source string!Changed

【代码说明】
程序中分别用了两种方法改变字符串的内容：str2=str2+"Changed"语句用于改变str2的内容；strb2append（"Changed"）语句用于改变strb2的内容。从程序执行的结果可以看出，字符串输出的结果和图161、图162给出的结果是一致的。判断两个对象是否指向内存的同一位置，还可以用“==”运算来实现。如果两个对象相等（“==”运算结果为true），说明两个对象是同一个对象，例130用另一种方式说明String类和StringBuffer类的区别。
【例130】演示String类和StringBuffer类的区别。




public class StringDemo{
public static void main（String\[ \] args）{
String str1="The source string!";// 定义str1和str2
String str2;
str2=str1;// str1和str2指向同一字符串
//定义StringBuffer类型的字符串strb1和strb2
StringBuffer strb1=new StringBuffer（"The source string!"）;
StringBuffer strb2=strb1;// strb1和strb2指向同一字符串
if（str1==str2）// 判断str1和str2是否指向同一字符串
Systemoutprintln（"str1 and str2 points the same object"）;
else
Systemoutprintln（"str1 and str2 points the different object"）;
str2="The destination string!";// 改变str2的内容
if（str1==str2）// 判断str1和str2是否指向同一字符串
Systemoutprintln（"str1 and str2 points the same object"）;
else
Systemoutprintln（"str1 and str2 points the different object"）;
Systemoutprintln（"str1="+str1）;// 分别输出str1和str2的内容
Systemoutprintln（"str2="+str2）;
if（strb1==strb2）// 判断strb1、strb2是否指向同一字符串
Systemoutprintln（"strb1 and strb2 points the same object"）;
else
Systemoutprintln（"strb1 and strb2 points the different object"）;
strb2=strb2replace（4,10,"destination"）;// 改变strb2的内容
if（strb1==strb2）// 判断strb1、strb2是否指向同一字符串
Systemoutprintln（"strb1 and strb2 points the same object"）;
else
Systemoutprintln（"strb1 and strb2 points the different object"）;
Systemoutprintln（"strb1="+strb1）;// 分别输出strb1和strb2的内容
Systemoutprintln（"strb2="+strb2）;
}
}

【代码说明】
该程序在执行“str2=str1”或“strb2=strb1”后，输出“str1 and str2 points the same object”或“strb1 and strb2 points the same object”；当改变str2或strb2后，两种字符串对象出现了不同的运行结果，对String 对象，输出“str1 and str2 points the different object”。对StringBuffer对象，仍然输出“strb1 and strb2 points the same object”。因此，StringBuffer对象遵循对象的引用规则，其内容是可变的；而String对象的内容是不可变的。
2常用的字符串处理方法
对字符串可以进行许多种操作，如字符串的连接、比较、搜索等，这些操作可以用字符串类提供的方法来完成。下面介绍几种常用的字符串类提供的方法。
（1）String类的常用方法及应用（见表19）
表19String类定义的主要方法


方法名称
功能说明

public int length（）
返回字符串的长度

public char charAt（int index）
返回字符串中index位置的字符

public String toLowerCase（）
将当前字符串中所有字符变成小写形式

public String toUpperCase（）
将当前字符串中所有字符变成大写形式

public String substring（int p0,int p1）
截取当前字符串从位置p0到位置p1的一部分字符串

public String replace（char p0,char p1）
用字符p1替换字符串中的字符p0

public String concat（String str）
将当前字符串与str连接，返回连接后的字符串

public String equals（String str）
判断两个字符串内容是否相等

public char toCharArray（）
将当前字符串转换为字符数组

public static String valueOf（type variable）
将type类型的variable转换为字符串
【例131】字符串类方法的简单应用。




public class StringMethodDemo{
public static void main（String\[ \] args）{
String strA="How are you!";
String strB="I'm fine!Thank you! And you?";
String strC=new String（）;// 创建一个空字符串 strC
strC="F"+strBsubstring（5,19）;// 创建另一个字符串strC
String strD=strAreplace（'!',''）;// 用替换strA的！
Systemoutprintln（strD）;
Systemoutprintln（strC）;
String strE="!yppah lla era eW";
for（int i=strElength（）-1;i>=0;i--）// 将strE按相反的字母顺序显示出来
Systemoutprint（strEcharAt（i））;
Systemoutprintln（）;
}
}

【运行结果】




How are you
Fine!Thank you!
We are all happy!

字符串中，字符的位置索引同字符数组是对应的，第一个字符的索引为0，第二个字符的索引为1，依此类推，最后一个字符的索引为字符串长度减1。
（2） StringBuffer类的常用方法及应用
StringBuffer类用于处理可变字符串，该类除了具有与String类相同的方法外，还有其特殊的方法，见表110。
表110StringBuffer类定义的主要方法



方法名称
功能说明

public int length（）
返回缓冲区的字符个数

public int capacity（）
返回缓冲区的容量

public synchronized StringBuffer append（type variable）
将variable转换成字符串，然后与当前字符串连接

public synchronized StringBuffer insert（int offset,type variable）
将variable转换成字符串，然后插入到当前字符串
中由offset指定的位置
StringBuffer对象在创建时，系统要为其分配一定容量的空间，以处理可变长度的字符串，创建后的对象可以增加、删除内容，经修改的字符串返回给原对象，这和String对象是不同的。StringBuffer对象中字符串的个数可由其length（）方法得到，而系统为每个对象分配的缓冲区容量由其capacity（）方法获得。创建StringBuffer对象时，系统分配的缓冲区容量等于对象中字符个数加上16。执行追加、插入字符或字符串时，也将改变以上两个方法的返回值。
【例132】字符串StringBuffer类方法的简单应用。




public class StringBufferDemo{
public static void main（String args\[\]）{
StringBuffer buf = new StringBuffer（） ;// 声明StringBuffer对象 
bufappend（"World!!"） ;// 添加内容
bufinsert（0,"Hello "） ;// 在第一个内容之前添加内容
Systemoutprintln（buf） ;// 输出修改的结果
bufinsert（buflength（）,"LNJD~"） ;// 再次添加内容
Systemoutprintln（buf） ;// 输出修改的结果
String str = bufreverse（）toString（） ;// 将内容反转后变为String类型
Systemoutprintln（str） ;// 将内容输出
}
}

【运行结果】




Hello World!!
Hello World!! LNJD~
~DJNL!!dlroW olleH

133任务实施
验证登录信息基本功能实现代码如下。




public class LoginDemo{
public static void main（String args\[\]）{
if（argslength!=2）{// 判断输入的参数个数是否是2
Systemoutprintln（"输入的参数不正确，系统退出！"） ;
Systemoutprintln（"格式：javaLoginDemo 用户名 密码"） ;
Systemexit（1） ;// 系统退出
}
String name = args\[0\] ;// 取出用户名
String password = args\[1\] ;// 取出密码
if（nameequals（"sunlina"）&&passwordequals（"lnjd"））{// 验证用户名和密码
Systemoutprintln（"欢迎" + name + "光临！"） ;
}else{
Systemoutprintln（"错误的用户名或者密码！"） ;
}
}
}

【运行结果】
没有输入参数时，显示以下信息：




输入的参数不正确，系统退出！
javaLoginDemo用户名 密码

输入错误的用户名或者密码时，显示以下信息：




错误的用户名或者密码！

输入正确的用户名或者密码时，显示以下信息：




欢迎sunlina光临！

【代码说明】
虽然以上程序可以实现基本功能，但在主方法中代码较多，不利于作为客户端进行操作。最简单的做法是：客户端只要得到最终的判断结果即可，中间的过程可以设置其他的类来封装具体的判断过程。在掌握学习领域2的知识点后，改造上例得到实现代码如下。




class Check{// 完成具体的验证操作
public boolean validate（String name,String password）{
if（nameequals（"sunlina"）&&passwordequals（"lnjd"））{// 验证用户名和密码
return true ;// 登录信息正确
}else{
return false ;// 登录信息错误
}
}
}
class Operate{// 本类只是调用具体的验证的操作
private String info\[\] ;// 定义一个数组属性，用于接收全部输入参数
public Operate（String info\[\]）{
thisinfo = info ;// 通过构造方法取得全部的输入参数
}
public String login（）{
Check check = new Check（） ;// 实例化Check对象，用于检查信息
thisisExit（） ;// 判断输入的参数是否正确
String str = null ;// 用于返回信息
String name = thisinfo\[0\] ;// 取出姓名
String password = thisinfo\[1\] ;// 取出密码
if（checkvalidate（name,password））{// 登录验证
str = "欢迎" + name + "光临！" ;
}else{
str = "错误的用户名和密码！" ;
}
return str ;// 返回信息给用户
}
public void isExit（）{// 判断参数个数，来决定是否退出程序
if（thisinfolength!=2）{
Systemoutprintln（"输入的参数不正确，系统退出！"） ;
Systemoutprintln（"格式：java LoginDemo 用户名 密码"） ;
Systemexit（1） ;// 系统退出
}
}
}
public class LoginDemo{
public static void main（String args\[\]）{
Operate oper = new Operate（args） ;// 实例化操作类的对象
Systemoutprintln（operlogin（）） ;// 取得验证之后的信息
}
}

【代码说明】
经过程序改造后，可以发现：主方法代码较少，方便客户使用；Check类的主要功能是验证操作，只需要输入用户名和密码即可完成验证；Operate类的主要功能是封装Check类的操作，并把验证后的信息返回给方法调用处。
134技能提高
下面进行数组排序训练。
1采用冒泡法对数组进行排序




public class ArrayDemo1{
public static void main（String args\[\]）{
int score\[\] = {57,89,87,69,90,100,75,90} ;// 使用静态初始化声明数组
for（int i=1;i<scorelength;i++）{
for（int j=0;j<scorelength;j++）{
if（score\[i\]<score\[j\]）{// 交换位置
int temp = score\[i\] ;// 中间变量
score\[i\] = score\[j\] ;
score\[j\] = temp ;
}
}
}
for（int i=0;i<scorelength;i++）{// 循环输出
Systemoutprint（score\[i\]+"\\t"） ;
}
}
}

【运行结果】




57 69 75 87 89 90 90 100

冒泡算法是把数组中的每一个元素进行比较，如果第i个元素大于第i+1个元素，就把两个数字进行交换。这样反复进行比较就可以将一个数组按照由小到大的顺序进行排序了。我们将上例进行改造，观察每次循环后输出的结果。




public class ArrayDemo2{
public static void main（String args\[\]）{
int score\[\] = {57,89,87,69,90,100,75,90} ;// 使用静态初始化声明数组
for（int i=1;i<scorelength;i++）{
for（int j=0;j<scorelength;j++）{
if（score\[i\]<score\[j\]）{// 交换位置





int temp = score\[i\] ;// 中间变量
score\[i\] = score\[j\] ;
score\[j\] = temp ;
}
}
Systemoutprint（"第" + i + "次排序的结果："） ;
for（int j=0;j<scorelength;j++）{// 循环输出
Systemoutprint（score\[j\]+"\\t"） ;
}
Systemoutprintln（""） ;
}
Systemoutprint（"最终排序的结果："） ;
for（int i=0;i<scorelength;i++）{// 循环输出
Systemoutprint（score\[i\]+"\\t"） ;
}
}
}

【运行结果】




第1次排序的结果：57 100 87 69 89 90 75 90
第2次排序的结果：57 87 100 69 89 90 75 90
第3次排序的结果：57 69 87 100 89 90 75 90
第4次排序的结果：57 69 87 89 100 90 75 90
第5次排序的结果：57 69 87 89 90 100 75 90
第6次排序的结果：57 69 75 87 89 90 100 90
第7次排序的结果：57 69 75 87 89 90 90 100
最终排序的结果：57 69 75 87 89 90 90 100

2 利用方法调用对数组进行排序




public class ArrayDemo3{
public static void main（String args\[\]）{
int score\[\] = {67,89,87,69,90,100,75,90} ;// 定义整型数组
int age\[\] = {31,30,18,17,8,9,1,39} ;// 定义整型数组
sort（score） ;// 数组排序
print（score） ;// 数组打印
Systemoutprintln（"\\n----------------"） ;
sort（age） ;// 数组排序
print（age） ;// 数组打印
}




public static void sort（int temp\[\]）{// 执行排序操作
for（int i=1;i<templength;i++）{
for（int j=0;j<templength;j++）{
if（temp\[i\]<temp\[j\]）{
int x = temp\[i\] ;
temp\[i\] = temp\[j\] ;
temp\[j\] = x ;
}
}
}
}
public static void print（int temp\[\]）{// 输出数组内容
for（int i=0;i<templength;i++）{
Systemoutprint（temp\[i\] + "\\t"） ;
}
}
}

【运行结果】




67697587899090100
----------------
1891718303139

当然对于排序操作，Java也有类库支持，利用javautilArrayssort（）方法可以对数组进行排序，改造上一个实例可以实现相同效果。




public class ArrayDemo4{
public static void main（String args\[\]）{
int score\[\] = {67,89,87,69,90,100,75,90} ;// 定义整型数组
int age\[\] = {31,30,18,17,8,9,1,39} ;// 定义整型数组
javautilArrayssort（score） ;// 数组排序
print（score） ;// 数组打印
Systemoutprintln（"\\n-----------"） ;
javautilArrayssort（age） ;// 数组排序
print（age） ;// 数组打印
}
public static void print（int temp\[\]）{// 输出数组内容
for（int i=0;i<templength;i++）{
Systemoutprint（temp\[i\] + "\\t"） ;
}
}
}







学习领域2：面向对象编程









〖1〗
Java语言程序设计（第二版）




〖1〗
学习领域2面向对象编程





〖1〗





〖1〗


任务21面向对象编程技术初步
前面所学习的知识属于Java的基本程序设计范畴，是结构化的程序开发，但是使用结构化程序设计方法开发的软件的稳定性、可修改性、可重用性较差，因为其本质将功能分解，围绕实现处理功能的过程来构造系统。而在软件开发中用户的需求是随时变化的，为更好地解决软件技术多变性，适应用户的变化需求，产生了面向对象编程技术。
211任务内容
定义测试一个Student的类，包含的属性有“学号”“姓名”及“英语”“数学”“计算机”科目成绩，设计获取总成绩、平均成绩、最高成绩、最低成绩的方法。
（1） 根据要求写出类所包含的所有属性，所有属性需要进行封装（private），封装后的属性通过setter方法和getter方法设置和获取。
（2） 设置与使用构造方法，根据任务要求添加相应方法，类中所有定义的方法不要直接输出结果，而是交给被调用处输出。
（3） 学会应用this和static关键字。
212相关知识
知识点一：面向对象特性
程序设计经历了“面向问题”“面向过程”和“面向对象”的不同阶段，下面通过实例讲解“面向过程”和“面向对象”的关系。例如,现在“面向过程”和“面向对象”两位师傅需要设计教室内的课桌椅。
“面向过程”师傅的做法是：用户提出要求，师傅就针对用户的要求直接制作出一件完整的东西，并不用提前准备好制作课桌椅所需要的工具，而是需要什么时再单独拿出来。
“面向对象”师傅的做法是：针对用户提出的要求进行分析，将分析的结果设计成一张完整的图纸，与需求的用户确认后，准备所有需要的工具，再分块制作，最后将各个分块部分组装在一起。
由此可见，“面向对象”师傅比“面向过程”师傅更能适应用户需求变化，因为一旦发生变化，“面向过程”师傅要放弃之前的所有工作，推倒重做。
如今“面向对象”的概念和应用已超越程序设计和软件开发的范畴，扩展到许多领域，例如，数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等。
OOP（面向对象编程）有三个基本特性，分别是封装性（encapsulation）、继承性(inheritance)和多态性(polymophism)。这里仅对继承性和多态性的概念作简要介绍，在后面相应的章节里再作详细介绍。
1封装性
把类中的一些描述细节隐藏内部，用户只能通过接口来访问类中的内容，这种组织模块的方式称为“封装”。
封装是一种信息隐藏的技术，用户在访问对象的时候，只能看到对象表面上的东西，它们是留给用户访问对象的接口（Application Program Interface，API），而外界用户是不能直接访问内部信息的，这就保证了类中数据的安全。OOP的封装性图示如图21所示。


图21OOP的封装性图示

可以把类理解成一个透明的玻璃柜，属性和行为是柜子里一个私有的不透明的黑盒子，外界用户无法直接访问内部属性和行为区的内容。可在柜子上钻一个孔，在外界用户和属性行为的黑盒子之间设置一个公有管道，用于访问私有的属性及行为。这样既提高了数据访问的安全性，也提高了代码复用能力。
2继承性
为了代码复用，OOP语言允许一个类（子类）使用另一个类（父类）的属性和方法，这种子类使用父类属性和方法的特性称为“继承”;反之则称为“派生”。例如，公司的雇员（Employee）派生为销售员（Saler）和部门经理（Manager）两类，销售经理（Sale_Manager） 又继承了销售员和经理两个类的共同特征。如图22所示，箭头方向表示被继承的父类。


图22OOP的继承性举例

在Java程序设计中，已有的类可以是Java开发环境所提供的最基本的程序——类库，用户开发的程序类可继承这些已有的类。这样，类库中所描述的属性和行为，在继承的类中完全可以使用。被继承的类称为父类或者超类，而经过继承产生的类称为子类或者派生类。根据继承机制，子类继承父类的所有成员，同时相应地增加自己新的成员，以突出子类与父类的不同之处。
从图22中可以看出，一个父类可以被多个子类继承（单继承），一个子类也可以继承多个父类的属性和方法（多继承）。也就是说，如果一个子类只继承自一个直接父类，就称为单继承；如果一个子类同时继承自多个父类，就称为多继承。图22中Saler类与Employee类之间就是单继承的关系，因为Saler类只有一个直接父类Employee；同样地，Manager类与Employee类之间也是单继承的关系。而Sale_Manager类因为同时继承自两个父类Saler类和Manager类，所以它们之间是多继承的关系。
不过，在Java中只支持单继承方式，这使得Java的继承方式比C++等OOP语言要简单得多。虽然Java不支持多继承，但是并不意味着Java不能实现多继承的效果，在后面讲述的“接口”（Interface）可以实现多继承的效果。继承机制可以增强程序代码的可复用性，提高软件的开发效率，降低程序产生错误的可能性，为程序的修改扩充提供便利。
3多态性
“多态”在实际生活中是有应用的，如H2O在不同温度下可能是固态、液态或者气态；而在编程上，简单讲就是“类的不同对象可以对同一个消息作出不同的响应”。多态更多的是从程序整体设计的高度上体现的一种技术，简单地说就是“会使程序设计和运行时更灵活”。对象封装了多个方法，这些方法调用形式类似，但功能不同，对于使用者来说，不必去关心这些方法功能设计上的区别，对象会自动按需选择执行，这不仅减少了程序中所需的标识符的个数，对于软件工程整体的简化设计也有重大意义。多态性使程序的抽象程度和简洁程度提高，有助于程序设计人员对程序的分组协同开发。
多态分为静态多态和动态多态两种。静态多态是编译时多态，比如方法重载（在一个类中，允许多个方法使用同样的名字，但方法的参数不同，完成的功能也不同）；动态多态是运行时多态（子类对象可以与父类对象进行相互转换，而且根据其使用的子类不同，完成不同的功能），典型的应用是方法重写和接口的引用，将在任务22中详细介绍。
知识点二：类和对象
面向对象编程思想力图使得程序设计与开发和现实世界中具体实例是完全一致的。类和对象是OOP中最基本的两个概念，类是对象的模板，对象是类的具体实现，如图23所示。人们通过观察对象的属性和行为来了解对象。对象的属性描述对象的状态，对象的行为描述对象的功能。


图23OOP的类与对象

“实例化”是将类的属性设定为确定值的过程，是从“一般”到“具体”的过程；“抽象”是从特定的实例中抽取共同的性质以形成一般化概念的过程，是从“具体”到“一般”的过程。
假如学生是一个类的话，那么班级里所有的同学都是对象，他们都具有学生的基本特征，但各个同学之间的某些特性可能不一样，如身高、性别、学习习惯等。当这些属性特征确定了以后，一个对象就确定了下来，这就是实例化的过程。
如果把所有学生的共同特点进行总结，会得到如下信息：凡是学生都有性别、年龄、班级、选修专业等属性特征，而且有学习习惯、说话方式等行为特征。把这些共有的特征集成到一个模块中就形成了类，这就是抽象的过程。
在面向对象编程中，“类”是对某种类型的对象定义变量和方法的原型，表示对现实生活中一类具有相同特征的事物的抽象；“对象”是类的具体存在。类和对象是面向对象编程思想的核心和基础。类是作为对象的蓝图而存在的，所有的对象都依据相应的类来产生。
知识点三：类的定义
Java中的类是由类声明和类体组成，如图24所示。
1类声明部分：由类修饰符、类关键字class、类名称等组成
修饰符分为“访问修饰符”和“存储类型修饰符”两类。访问修饰符有public和缺省两种；存储类型修饰符有abstract和final两种。其中，public用于说明该类能被其他包中的类使用，若无public关键字，则表示该类只能被同一包内的类访问；用abstract修饰的类为抽象类，抽象类必须被其他类继承；用final修饰的类为最终类，这种类不能被其他类继承。由此可见，abstract和final不能同时修饰一个类，因为两者的作用是相反的。
类的关键字为class，其后给出类的名称。类名称可以是任何合法的Java标识符，习惯上类名称的首字符用大写字母。
类可以继承其他类，用extends关键字指出被继承的类。Java规定，一个类只能有一个父类，即只能单重继承。如果要实现多重继承的效果，必须采用实现接口的方式，此时使用关键字implements后跟接口名；如果要实现多个接口，可以用逗号隔开。有关接口的内容将在任务22中介绍。



图24类的定义格式

2类体：由成员变量和成员方法组成
成员变量可以是Java的基本数据类型变量，也可以是复合数据类型的变量，如数组和类的对象。成员方法主要用于实现特定的操作，如进行数据处理、显示等，它决定了类要实现的功能。类体也可以包含静态块（static block），用来初始化类的静态成员。
【例21】定义Student类。




class Student{
private String name ;//声明姓名属性
public void setName（String n）{//设置姓名方法
name = n ;
}
public String getName（）{//获取姓名方法
return name ;
}
}
public class ExampleDemo01{
public static void main（String args\[\]）{//主方法，程序入口点
Student stu = new Student（） ;//声明学生对象
stusetName（"sunlina"） ;//引用对象方法，设置姓名
Systemoutprintln（"学生姓名：" + stugetName（）） ;//引用对象方法，显示姓名
}
}

【运行结果】




学生姓名：sunlina

在上面的程序中，Student类定义了name属性，表示学生的姓名，它是被private（私有）访问限定符修饰的变量。这说明该变量只能被Student类自身的方法访问，其他类的对象不能直接引用该变量，只能通过类提供的方法访问name。例如程序中通过设置姓名方法setName（String n）给该变量赋值。同时又定义获取姓名的方法getName（）来显示姓名，方法的类型修饰符为String，表明该方法是有返回值型方法，因此需要return语句返回方法值。
方法main（String\[\] args）是类的主方法，一般应用程序以主方法为程序的入口。main（）方法中参数数组args\[\]用于取得命令行参数，这是用户控制程序运行的“句柄”。new运算符用于创建类的对象（或称“实例”），会在内存中开辟一段空间存放实例的属性值，然后将空间的地址赋给引用名stu。操作成员属性和成员方法时，可以使用这个实例的引用名来操作，如stusetName（"sunlina"）。
知识点四：属性的声明
Java程序设计中，属性即成员变量，而成员变量的声明或定义格式为：

\[成员访问修饰符\]\[成员存储类型修饰符\]数据类型成员变量\[=初值\];
（1） 类的成员变量在使用前必须加以声明，除了声明变量的数据类型之外，还需要说明变量的访问属性和存储方式。访问修饰符包括public、protected、private和缺省（即不带访问修饰符）（参见表21）；存储类型修饰符包括static、final、volatile、transient（参见表22）。Java中允许为成员变量赋初值。
（2） 成员变量根据在内存中的存储方式和作用范围可以分为类变量和实例变量。普通的成员变量也称实例变量。成员变量如果用static修饰，表示成员变量为静态成员变量（也称类变量）。类变量作用范围属于类，而一般实例变量是依赖于对象的。一般实例变量伴随着实例创建而创建，伴随着实例消亡而消亡。静态成员随着类的定义而诞生，被所有实例所共享。
（3） 访问成员变量格式：对象成员变量。如果考虑static关键字，那么访问格式可以细化为：对象 静态成员变量（或实例成员变量），或者类名静态成员变量。
表21成员变量的访问修饰关键字的功能



关键字
用途说明

public
此成员能被任何包中的任何类访问

protected
此成员能被同一包中的类和不同包中该类的子类访问

缺省（没有修饰符）
此成员能被同一包中的任何类访问

private
此成员能被同一类中的方法访问，包以外的任何类不能访问
表22成员变量的存储修饰关键字的功能



关键字用途说明

static声明类成员，表明该成员为所有对象所共有

final声明常变量，该变量将不能被重新赋值

volatile易失的变量，可以被异步的线程修改，不常用

transient暂时的变量，将指定 Java 虚拟机认定该暂时性变量不属于永久状态，以实现不同对象的存档功能，不常用
用final修饰符修饰的成员变量就是常成员变量，在Java中常变量习惯用大写的标识符表示，例如：finaldoublePI=314159。
需要强调的是：在一个类中声明成员变量时，必须在任何方法之外声明，它的作用范围是整个类，如果定义在方法体内部就成为局部变量。另外需要注意的是，不要把语句写在方法外部（属性定义区），如下所述：

public classStudent {
Stringname=new String（"tom"）;// 这是正确的
void setName（） { … }
}
public classStudent {
Stringname；
name=new String（"tom"）;// 这是不正确的，语句不能放在属性区
void setName（（） { … }
}
public classStudent {
Stringname；
void setName（） {// 也可以这样改动
name= new String（"tom"）;
… 
}
}
这就是初始化与赋值之间的区别：语句String  name=new  String（"tom"）; 是创建字符串实例兼初始化，属于定义语句，因此可以写在属性区。而语句name=new String（"tom"）;则属于赋值语句，只能写在方法体内部。而成员变量的初始值的规则如表23所示。
表23成员变量的初始值规则



成员变量的数据类型
初始值

整型（byte，short，int，long）
0

字符型
'\\u0000'

布尔型
false

浮点型
00
局部变量在调用时则必须初始化，这是与全局变量（成员变量、类变量）的区别。实例如下所示。
【例22】定义Student类。




class Student{
int age;//声明年龄属性
void getAge（）{//获取年龄方法
//int age;
Systemoutprintln（"学生年龄："+age） ;//输出年龄值
}
}
public class ExampleDemo02{
public static void main（String args\[\]）{//主方法，程序入口点
Student stu = new Student（） ;//声明学生对象
stuage = 30;
stugetAge（） ;//引用对象方法，显示年龄
}
}

【运行结果】




学生年龄：30

如果去掉第四行的注释号，则运行结果为：

variableage might not have been initialized（提示变量age尚未初始化）
知识点五：行为的声明
Java程序设计中，行为即成员方法，而成员方法的声明格式如下：

\[访问修饰符\]\[存储类型修饰符\]数据类型成员方法（\[参数列表\]）\[throws  Exception\];
成员方法定义的格式：

\[访问修饰符\]\[存储类型修饰符\]数据类型成员方法（\[参数列表\]）\[throws  Exception\]{
\[<类型><局部变量>；\]
… 方法体语句；
};
（1） 类的成员方法在声明或定义前，除了声明方法的返回值数据类型之外，还需要说明方法的访问属性和存储方式。访问修饰符包括public、protected、private和缺省；存储类型修饰符包括static、final、abstract、native、synchronized。各种成员方法访问修饰符的作用与成员变量相同，参见表21。表24给出了各种成员方法存储修饰符的作用。
（2） 如果类体中一个方法只有声明，没有定义（即没有方法体），则此方法是abstract的，类体和方法体定义前都须加abstract关键字修饰。
表24成员方法的存储修饰关键字的功能



关键字
用途说明

static
声明类方法，表明该方法为所有对象所共有

abstract
声明抽象方法，没有方法体，该方法需要其子类来实现

final
声明最终方法，该方法将不能被子类重写

native
声明本地方法，本地方法用另一种语言如C语言实现

synchronized
声明同步方法，该方法在任一时刻只能由一个线程访问
（3） 访问成员方法的格式：对象成员方法。如果考虑static关键字，那么访问格式可细化为：对象 静态成员方法（或实例成员方法），或者类名静态成员方法。
（4） 方法按返回值可以分为两类：无返回值的方法和有返回值的方法。有返回值方法的返回值类型可以是Java允许的任何数据类型。无返回值的方法用void关键字声明，不能包含return语句；有返回值的方法需在方法名前指出方法的返回值类型，并且包含return语句，return语句后面为返回的结果，结果的数据类型即返回值类型，如实例21所示。
（5） 在声明方法中的参数时，需要说明参数的类型和个数。参数之间用逗号隔开，参数的数据类型可以是Java认可的任何数据类型。参数名称在它的作用范围内是唯一的，即同一个方法中的参数名称不能相同。当然对象也可以作为方法的参数，将在214节技能提高中加以介绍。
知识点六：构造方法
构造方法是一种特殊的方法，用来创建类的实例。声明构造方法时，可以附加访问修饰符，但没有返回值，不能指定返回类型。构造方法名必须和类同名。调用构造方法创建实例时，用new运算符加构造方法名，格式如下：

类名称对象名称 = new 类名称（）
如创建Student类的实例：

class Student{
public Student（）{}// 构造方法
public static void main（String args\[ \]）{
Student tom=new Student（）;// 调用构造方法来创建实例
}
}
为实例的属性设置值有两种方式：一种是先创建实例，后调用自己的普通成员方法来完成设置，这称为“赋值”；另一种是使用new运算符调用构造方法，一次性地完成实例的创建和属性值设置，这称为“初始化”。
比较两种方式可以容易地知道构造方法的使用时机和作用：构造方法是专门用于构造实例的特殊成员方法，在创建实例时起作用；而使用普通成员方法为实例属性赋值，是在实例创建后才调用。构造方法可以自行定义，以满足程序的需要。在创建实例并设置属性值时虽然有两种选择，但推荐使用构造方法的形式来创建实例，这会使程序更简洁和易于理解，运行效率也更高。
知识点七：方法重载
在同一个类体中有多个名称相同的方法，但这些方法具有不同的参数列表（或参数的个数不同，或参数的类型不同），这种现象称为方法的重载。实例如下所示。
【例23】定义Sum类。




public class Sum {
static int add（int x,int y）{
return x+y;
}
static int add（int x,int y,int z）{
return x+y+z;
}
static float add（float x,float y）{
return x+y;
}
public static void main（String\[\] args） {
Systemoutprintln（add（2,3））;
Systemoutprintln（add（2,3,4））;
Systemoutprintln（add（21f,32f））;
}
}

方法重载是一种静态多态，有时也称为“编译时绑定”。编译器习惯上将重载的这些方法确认为不同的方法，因此它们可以存在于同一作用域内。调用时，根据不同的方法调用格式自动判断、定位到相应的方法定义地址。使用方法重载，会使程序的功能更清晰、易理解，并使得调用形式更简单。
构造方法也是根据需要自行定义的，具有不同参数列表的构造方法也可以构成重载的关系。一个类如果没有定义构造方法，Java系统会自动生成一个不带参数的构造方法用于创建实例，这个方法就是默认构造方法。在具有自定义构造方法的类体中，如果调用了默认构造方法来创建实例，那么默认构造方法必须显式地书写在类体中，不能省略。实例如下所示。
【例24】定义Person类。




class Person{
private String name ;// 声明姓名属性
private int age ;// 声明年龄属性
public Person（）{}// 声明无参的构造方法
public Person（String n）{// 声明有参数的构造方法,为name属性赋值





thissetName（n） ;
}
public Person（String n,int a）{// 声明构造方法，为类中的属性初始化
thissetName（n） ;// 为name属性赋值
thissetAge（a） ;// 为age属性赋值
}
public void setName（String n）{// 设置姓名
name = n ;
}
public void setAge（int a）{// 设置年龄
if（a>0&&a<150）{
age = a ;
}
}
public String getName（）{// 获取姓名
return name ;
}
public int getAge（）{// 获取年龄
return age ;
}
public void tell（）{// 获取信息
Systemoutprintln（"姓名：" + thisgetName（） + "，年龄：" + thisgetAge（）） ;
}
}
public class ExampleDemo03{
public static void main（String args\[\]）{
Person per = new Person（"孙莉娜",30） ;// 调用带参数的构造方法实例化对象
pertell（） ;// 输出信息
}
}

【运行结果】




姓名：孙莉娜，年龄：30

读者可以自行尝试调用不带参数的构造方法和带一个参数的构造方法，查看相关结果。
知识点八：对象的创建与使用
如果把程序设计比作一项建筑工程，完成类定义相当于设计出施工图纸。根据一张图纸可以建起多座建筑物，同样，可以为每个类创建多个对象。
1创建对象
类是一种数据类型，对象相当于这种数据类型的变量，它在使用前要先定义或声明。例如对于上面定义的Person类，要声明一个per对象，使用语句Person per；。
声明类的对象之后，并没有创建该对象，此时对象的值为null。这和定义基本类型的变量相似，不同之处在于：基本数据类型的变量在声明之后，即使没有初始化，变量有一个初始值，如整型变量的初始值为0，布尔型变量的初始值为false；而类对象的初始值却为null。要想让对象指向某一具体值，需要用类的构造方法创建对象。
以per为例，创建方法如下：per = new Person（"孙莉娜",30）；。
也可以在声明对象的同时创建该对象，例如Person per = new Person（"孙莉娜",30）；。
2使用对象
声明变量是为了在程序中使用变量，同样创建对象也是为了使用对象。同基本类型变量不同之处在于：基本类型的变量包含的信息相对简单，而对象中包含了属性和处理属性的方法。使用对象属性和方法，采用以下形式：对象名称属性或方法。之前例22已显示使用方法。当然也可以同时创建多个对象，每个对象会分别占据自己的空间，实例如下所示。
【例25】定义Student类，改造例22。




class Student{
int age;// 声明年龄属性
void getAge（）{// 获取年龄方法
Systemoutprintln（"学生年龄："+age） ;// 输出年龄值
}
}
public class ExampleDemo02{
public static void main（String args\[\]）{// 主方法，程序入口点
Student stu1 = new Student（） ;// 声明学生1对象
Student stu2 = new Student（） ;// 声明学生2对象
stu1age=30;
stu1getAge（） ;// 引用学生1对象方法，显示年龄
stu2age=20;
stu2getAge（） ;// 引用学生2对象方法，显示年龄
}
}

【运行结果】




学生年龄：30
学生年龄：20