Java应用教程课件

Java语言概述

1.1Java语言的简述1.1.1Java语言的诞生

1991年出现,”Oak”,用于嵌入家电1.1Java语言的简述1995.5.23

,Sun发布了Java1.0（JavaDevelopmentKit,JDK1.0）从1998.12开始，发布JDK1.2,并使用"Java2"

现在SUN推出Java2Platform,StandardEditionv1.41.1.2Java语言的主要特点

简单性

平台无关性面向对象的技术支持多线程

动态性

安全性

Java语言除上述主要特点外，还有高性能、分布性、强大性、解释性、可移植性等。

1.1.3Java程序的运行机制

Java虚拟机(JavaVirtualMachine)垃圾收集机制(Garbagecollection)代码安全性检测(CodeSecurity)Java虚拟机(JavaVirtualMachine)在一台计算机上由软件或硬件模拟的计算机。Java虚拟机(JVM)读取并处理经编译过的平台无关的字节码class文件。Java编译器针对Java虚拟机产生class文件，因此是独立于平台的。Java解释器负责将Java虚拟机的代码在特定的平台上运行。Java虚拟机(JavaVirtualMachine)垃圾收集机制(Garbagecollection)

不再使用的内存空间应回收垃圾收集。在C/C++等语言中，由程序员负责回收无用内存。Java语言解除了程序员回收无用内存空间的责任。它提供一种系统级线程跟踪存储空间的分配情况。并在JVM的空闲时，检查并释放那些可被释放的存储器空间。垃圾收集在Java程序运行过程中自动进行，程序员无法精确控制和干预。

代码安全性检测(CodeSecurity)

Java执行代码的时候，由JVM对运行的代码进行安全性检测，当进行一些非法操作的时候，比如修改一些系统设置的时候，JVM会发出警告。

Java程序开发过程可以大致分为三个阶段：编写Java源文件：

编译Java源程序运行Java程序：

1.2Java应用开发体系

1.2.1J2SE体系概述

J2SE主要:用于创建典型的桌面与工作站应用的Java平台。从配置上来说，只要安装JDK，就建立了一个J2SE开发和运行平台。

1.2.2J2ME体系概述

J2ME主要用于创建嵌入式应用程序（如PDA、仪表），J2ME开发平台需要J2SE平台的支持。1.2Java应用开发体系1.2.3J2EE体系概述

J2EE的任务是提供一个平台独立的、便携式、多用户、安全以及标准的企业级平台，服务器端部署用Java技术来完成。J2EE主要用于创建可扩展的企业应用，包括13种核心技术规范。

1.3J2EE的N层体系结构J2EE的N层体系结构

1.4Java运行环境的安装配置

1.4.1

Java开发工具包可以从网站下载最新版本。对于不同的操作系统，可下载的文件格式不同。

1.4.2

环境变量的设置在安装Java开发工具包JDK之后，为了保证Java源程序在不同目录下能够正常编译和运行，需要设置环境变量。

1.5Java程序的分类

根据程序结构和运行环境的不同，Java程序可以分为两类：Java应用程序（JavaApplication）和Java小应用程序（JavaApplet）。应用程序以main()方法作为程序入口，由Java解释器加载执行。Java应用程序是完整的程序，能够独立运行，而JavaApplet小应用程序不使用main()方法作为程序入口，需要嵌入到HTML网页中运行，由浏览器或appletviewer加载执行，无法独立运行。1.5.1Java应用程序

案例名称：JavaApplication程序程序1-1：TestHelloWorld.java

publicclassTestHelloWorld{ publicstaticvoidmain(Stringargs[]) { System.out.println("HelloWorld!"); }}应用程序分析类定义

Java程序的基本组成部分是类(class)，如本例中的TestHelloWorld类。main()方法

JavaApplication程序的入口是main()方法。它有固定的书写格式：

publicstaticvoidmain(Stringargs[]){

…… }应用程序分析程序内容由方法体实现程序要完成的功能，方法的实现由一条条语句组成，每条语句使用分号“；”结束。在本例中只有一条语句，如下所示：System.out.println("HelloWorld!");用来实现字符串的输出。注释

“//”用于单行注释。注释从“//”开始，终止于行尾。

“/*…*/”用于多行注释。注释从“/*”开始，到“*/”结束。

JavaApplication的运行javacTestHelloWorld.java

源文件名为TestHelloWorld.java，由javac编译器编译源程序，产生字节码文件(.class文件)。javaTestHelloWorld

由java解释器解释执行。1.5.2JavaApplet程序

范例名称：JavaApplet程序程序1-2：

Welcome.Java

importjava.applet.*;importjava.awt.*;publicclassWelcomeextendsApplet{publicvoidpaint(Graphicsg){g.setColor(Color.red);g.drawString("欢迎你学习Java语言",30,30);

g.setColor(Color.blue);g.drawString("Java一定会给带来快乐!",20,60);}}JavaApplet

的运行

JavaApplet程序没有main()方法作为程序入口，不能直接执行，必须将JavaApplet程序的字节码文件*.class嵌入到HTML文件中，才能被执行。首先使用编译器将Welcome.Java编译成Welcome.class，然后使用记事本编辑文件welcome.html如下：<appletcode=welcome.classheight=100width=300></applet>

使用浏览器或JDK提供的appletviewer工具即可运行该Java小应用程序

1.6Java语言的面向对象特性

1.6.1面向对象编程思想

面向对象的编程思想力图使对计算机语言中对事物的的描述与现实世界中该事物的本来面目尽可能的一致。类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。1.6.2类的定义

类是组成Java程序的基本要素，也是Java中重要的复合数据类型。类封装了一类对象的状态属性和行为方法，是类对象的原型。创建一个新类，就是创建一种新的数据类型，实例化一个类，就创建一个对象。

类的定义包括两部分：类声明和类体。基本格式为：//语法格式：[<修饰符>]class<类名>{[<成员变量声明>][<构造函数声明>][<成员方法声明>]}1.6.3对象

classStudent{//声明类名intage;//声明成员变量intgetAge(){//声明成员方法

returnage;} voidsetAge(inti){//声明成员方法

age=i;}}publicclassTest{//声明类名publicstaticvoidmain(String[]args){ Studentd=newStudent();//声明并创建对象

d.setAge(18);//对象方法调用

System.out.println("本人年龄："+d.getAge()); }}配置VMware虚拟机这里有两种选择，选项“Typical”是典型安装，选项“Custom”是自定义安装，选择“Custom”安装方式。点击按钮“下一步”，进入选择操作系统界面，设置将来要安装的操作系统类型，如图1-10所示。配置VMware虚拟机2.1标识符、分隔符和关键字

2.1.1Java标识符与注释

Java语言中，为各种变量、方法和类等起的名字称为标识符。Java语言标识符的组成有一定的规则，如标识符必须以字母、下划线（_）或美元符（$）开头，后面可以跟任意数目的字母、数字、下划线（_）或美元符（$）。标识符的长度没有限制，标识符可以由编程者自己指定，但是要遵循一定的规则。

Java语言规定标识符命名要符合下列命名规则：

（1）标识符应以字母、下划线、美元符$开头，不能以数字开头；（2）标识符可以由字母、下划线、美元符或数字组合而成。在实际编程时，在命名标识符时，应该使其在一定程度上反映它所表示的变量、常量、类名和对象名的实际意义。（3）Java标识符大小写敏感，长度无限制。（4）系统的关键字（又叫保留字）不能作为标识符。2.1.2Java关键字

Java中一些赋以特定的含义、并用做专门用途的单词称为关键字（keyword）；所有Java关键字都是小写的，TURE、FALSE、NULL等都不是Java关键字；goto和const虽然从未使用，但也作被为Java关键字保留。true、false、null虽用做专门用途，但不是Java关键字。

2.1.3Java分隔符

Java分隔符组成：

分号--“;”、花括号--“{}”、空格--“

”Java分隔符作用：Java语句必须以分号作为结束标记Java允许用花括号“{}”将一组语句括起来，形成一个语句块(block)Java程序源代码中各组成部分之间可以插入任意数量的空格，包括换行。2.1.3Java分隔符Java语句块(block)在程序设计时经常使用，主要用于下列几个方面：(1)在定义类时，类体必须采用语句块形式；(2)在定义方法时，方法体必须采用语句块的形式；(3)在定义循环语句时，循环体可以语句块的形式，采用将0~多条语句集合到一起，作为一个整体进行处理；(4)语句块可以嵌套，嵌套层数无限制，以实现较复杂的功能。2.2常量和变量

2.2.1常量在程序运行过程中，其值不能被改变的量称为常量。Java中常用的常量有不同的类型：布尔型常量、字符型常量、整数型常量、浮点型常量和字符串型常量。布尔型常量包括true和false，分别代表真和假；字符型常量用一对单引号括起来的单个字符表示，如‘a’、‘1’等；整数型常量可以采用八进制、十进制和十六进制表示。八进制的常量用以零开头的数字表示，如011代表十进制的9；十六进制的数用以0x开头的数字表示，如0x11代表十进制的17。

2.2.2变量

程序执行中数值可变的数据称为变量。变量包括变量名和变量值。Java中的变量必须先声明后使用。在使用每一个变量之前，必须清楚地为每一个变量提供一个名字和类型。这个变量的名字必须是一个合法的标识符，对应一定数量的内存存贮单元,其单元数视变量类型而定。变量声明格式数据类型标识符[=确省值]例如:inti;i=5;

或缩写成

inti=5;使用变量的注意事项变量命名不能重复(不同条件下)Java区分大小写变量必须先定义，再使用只有定义过，才能为其分配相应数量的存储单元一旦定义，变量类型才能确定，才能检查其运算的合法性2.3Java的数据类型

Java语言的数据类型如图2-1所示。

图2-1Java语言的数据类型

Java中定义了四类/八种基本数据类型：（1）逻辑型

boolean；（2）字符型

char；（3）整数型

byte,short,int,long；（4）

浮点数型

float,double。每种数据类型都有其固定的表达数据范围和字段长度，不受操作系统的影响。2.3.1逻辑布尔型

使用关键字boolean来定义逻辑布尔型变量，boolean类型适于逻辑运算，一般用于程序流程控制。boolean类型数据只允许取值true或false，不可以0或非0的整数替代true和false。通过下面的例子来说明boolean型变量的定义和用法。booleanb=false; if(b==true){ //dosomething }2.3.2字符型

char型数据用来表示通常意义上“字符”字符常量是用单引号括起来的单个字符charc='A';Java字符采用Unicode编码，每个字符占两个字节，因而可用十六进制编码形式表示charc1='\u0061';Java语言中还允许使用转义字符'\'来将其后的字符转变为其它的含义charc2='\n';//代表换行符2.3.3整数型

（1）整数型常量Java语言中的整数型常量分为三种：十进制整数，如123，456，0。八进制整数，以0开头，017代表十进制整数15，011代表十进制整数9。十六进制整数，以0x或0X开头，如0x2E代表十进制整数46，0x123代表十进制整数291。（2）整数型变量Java语言中的整数型变量分为四种：byte，short，int，long。2.3.3整数型Java各整数类型有固定的表数范围和字段长度，而不受具体操作系统的影响，以保证Java程序的可移植性:类型占用存储空间表数范围byte1字节

-128~127short2字节

-215~215-1int4字节

-231~231-1long8字节

-263~263-12.3.4浮点型（实型）

Java浮点类型有固定的表示范围和字段长度，表2-3列出各类型所在内存的字节数和表示范围。

类型占用存储空间表数范围float4字节

-3.403E38~3.403E38double8字节

-1.798E308~1.798E308publicclassDataType{publicstaticvoidmain(Stringargs[]){ booleanb=true; //声明boolean型变量并赋值 intx,y=99; //声明int型变量

floatf=12.34f; //声明float型变量并赋值

doubled=3.1415; //声明double型变量并赋值

charc; //声明char型变量

c='\u0031'; //为char型变量赋值

x=999; //为int型变量赋值System.out.println("b="+b);

…}}

Java基本数据类型变量声明和赋值

2.3.5引用数据类型

Java语言中除8种基本数据类型以外的数据类型称为引用类型

引用类型数据以对象的形式存在引用类型变量的值是某个对象的句柄，而不是对象本身

声明引用类型变量时，系统只为该变量分配引用空间，并未创建一个具体的对象

Java引用类型应用举例publicclassTestarray{publicstaticvoidmain(Stringargs[]){ int[]s; s=newint[10]; for(inti=0;i<10;i++){ s[i]=3*i+2; System.out.println(s[i]); }}}2.4运算符、表达式和语句

2.4.1运算符(按照运算符功能分)

算术运算符：+，―，*，/，%，++，――；

如:3+2;a-b;i++;--i;关系运算符：>，<，>=，<=，==，!=；

如:a>3;i==0; n!=-1;布尔逻辑运算符：!，&,|,^,&&，||；如:

b=true; !(b); b&&b;运算符

位运算符：〉〉，〈〈，〉〉〉，—，l,^,~；如:

a=10011101; a<<3=11101000;a>>3=11110011a>>>3=00010011;赋值运算符:=，扩展赋值运算符：+=，―=，*=，/=等；如:i=3; I-=2等效于i=I-2运算符条件运算符：？：；条件运算符？：为三元运算符，它的一般形式：x?y:z其中x为boolean类型表达式。其规则是：先计算x的值，若为true，则整个三元运算的结果为表达式y的值，否则整个运算结果为表达式z的值。例如:intscore=50;Stringtype=score<60?“不及格”:“及格”;运算符其它运算符：包括分量运算符．，下标运算符[]，实例运算符instanceof，内存分配运算符new、强制类型转换运算符（类型）、方法调用运算符（）等。Instanceof运算符应用

classInstanceOfDemo{publicstaticvoidmain(Stringargs[]){ InstanceOfDemobob=newInstanceOfDemo(); if(bobinstanceofInstanceOfDemo){System.out.println(“bob是InstanceOfDemo的实例"); }

else{ System.out.println("bob不是InstanceOfDemo的实例！"); }}}Instanceof运算符应用程序的执行结果如图2-9所示。

2.4.2表达式

表达式是符合一定语法规则的运算符和操作数的序列

a 5.0+a (a-b)*c-4 i<30&&i%10!=0表达式的类型和值对表达式中操作数进行运算得到的结果称为表达式的值表达式的值的数据类型即为表达式的类型表达式的运算顺序首先应按照运算符的优先级从高到低的顺序进行优先级相同的运算符按照事先约定的结合方向进行运算符的优先次序表达式的运算按照运算符的优先顺序从高到低进行,同级运算符从左到右进行：优先次序运算符1[].(params)expr++expr--2++expr--expr+expr-expr~!

3new(type)expr

4* / % 5+ - 6>> >>><< 7<><=>=instanceof

8== != 9& 10^ 11| 12&& 13|| 14?: 15=+=-=*=/=%=^= 16&=|=<<=>>=>>>= 运算符的优先次序2.4.3语句和块

●语句语句简单地说等价于自然语言的句子。一个语句组成了一个执行的完整单元。如:weight=123.45;//赋值语句i++;//增量语句System.out.println(weight);//方法调用语句Integera=newInteger(4);//对象创建语句2.4.3语句和块●

块

块是一组处在“{”和“}之间的零条或者多条语句，它可以使用在程序的任何地方。下面的例子给出了两个块，每一个块中包含了一条语句：if(Character.isUpperCase(aChar)){System.out.println("Thecharacter"+aChar+"isuppercase.");}else{System.out.println("Thecharacter"+aChar+"islowercase.");}2.4.4控制流程语句

Java编程语言提供了几个控制流程语句，如表所示。

表2-11Java的控制流程语句语句关键字

循环语句while,do-while,for

判断语句if-else,switch-case

异常处理try-catch-finally,throw

跳转语句break,continue,label:,return2.5条件语句

Java语言中有两种类型的条件语句：if和switch。

if语句的语法格式为：if(表达式){语句块}else{语句块}if语句有如下三种具体形式：

形式1if(boolean类型表达式)语句A功能:当表达式值为真（true）时,执行语句A,否则跳过语句A，流程如图所示。

表达式语句A＝F=T例如:intscore=95;if(score>=90){System.out.println("优秀的感觉真好！");}if(score<60){System.out.println(“还要努力呦！”);}if语句有如下三种具体形式：形式2

if(boolean类型表达式)语句Aelse语句B

功能:表达式为true,执行语句A；表达式为false,执行语句B。其流程图如图2-11所示。例如:inttestscore=76;chargrade;

if(testscore>=90){grade=A;}else{grade=F;}if语句有如下三种具体形式：形式3if(boolean类型表达式1)语句1

elseif(表达式2)语句2……elseif(表达式n)语句nelse语句n其流程如图2-13所示。if语句有如下三种具体形式：形式3流程图if语句有如下三种具体形式：形式2

if(boolean类型表达式)语句Aelse语句B

功能:表达式为true,执行语句A；表达式为false,执行语句B。其流程图如图2-11所示。例如:inttestscore=76;chargrade;

if(testscore>=90){grade=A;}else{grade=F;}if语句举例：publicclassIfElse{publicstaticvoidmain(String[]args){inttestscore=76;chargrade;if(testscore>=90){grade='A';}elseif(testscore>=80){grade='B';}elseif(testscore>=70){grade='C';}elseif(testscore>=60){grade='D';}if语句举例：

else{grade='F';}System.out.println("Grade="+grade);}}使用JCreator编译执行程序运行效果如图2-14所示。2.5.2switch语句

switch语句的使用格式是：switch（表达式）{case值1：{语句块1}break;case值2：{语句块2}break;

…case值N：{语句块N}break;[default:缺省语句块]}switch语句举例：

publicclassSwitchDemo{publicstaticvoidmain(String[]args){intmonth=8;switch(month){case1:System.out.println("January");break;case2:System.out.println("February");break;…

if语句举例：case11:System.out.println("November");break;case12:System.out.println("December");break;}}}

这个switch语句计算它的表达式，在这个例子中是计算month的数值，然后计算适当的case语句。使用JCreator编译执行程序运行效果如图2-15所示。

2.6循环语句

：循环语句功能:在循环条件满足的情况下，反复执行特定代码，被反复执行的程序代码称为循环体。循环语句有下面的四个部分组成：（1）初始化部分（init_statement）（2）循环条件部分（test_exp）

（3）循环体部分（body_statement）

（4）迭代部分（alter_statement）

2.6循环语句

：

Java的循环语句共有三种：for循环、while循环和do-while循环.程序流程如图所示。2.6.1for循环

for语句提供了一个简便的方法来进行循环。For语句的语法如下：for(表达式1;表达式2;表达式3)

{语句块}首先计算表达式1，接着执行表达式2，若表达式2的值=true，则执行语句块，接着计算表达式3，再判断表达式2的值。依此重复下去，直到表达式2的值=false。for循环语句应用

publicclassForLoop{

publicstaticvoidmain(Stringargs[]){intresult=0;for(inti=1;i<=10;i++) {result+=i;}System.out.println("result="+result); }}for循环语句应用使用JCreator编译执行程序运行效果如图2-17所示。注意：可以在for循环的初始化语句中声明一个局部变量。这个变量的作用域只是在for语句的块中，它可以用在终止条件语句和增量表达式中。

2.6.2while循环

当条件保持为true的时候，你可以使用while语句持续执行语句块。while语句的通常语法为：

while(表达式){语句块}首先，while语句执行表达式，它将返回一个boolean数（true或者false），如果表达式返回true，while语句执行相应的语句。while语句继续测试表达式并执行块代码直到表达式返回false。While语句用法举例

publicclassWhileLoop{publicstaticvoidmain(Stringargs[]) {longresult=1; inti=1;while(i<=10){result=result*i;i++;} System.out.println("result="+result);}}While语句用法举例该程序通过while循环求从1加到10的阶乘。使用JCreator编译执行程序运行效果如图所示。

2.6.3do-while语句

Java编程语言提供了另外一个语句，它跟while语句相似，即do-while语句。Do-while的语法为：

do{语句块}while(表达式);不象while语句，do-while语句是先执行循环中的语句后再计算表达式的，所以do-while语句块至少被执行一次。do-while语句用法举例

publicclassDoWhileLoop{publicstaticvoidmain(Stringargs[]){longresult=1;inti=1;do{result=result*i;i++;}while(i<=20); System.out.println("result="+result);}}do-while语句用法举例

该程序使用do-while语句求从1加到20的阶乘。使用JCreator编译执行程序运行效果如图所示。

while语句与do…while语句的区别:当第一次执行时，若表达式=0时,则while语句与do…while有所不同,do…while执行一次后面的语句,而while不执行。2.7跳转语句

Java编程语言支持下面的三种跳转语句：l

break语句；l

continue语句；l

return语句。

2.7.1break语句

作用：使流程从当前的语句块内跳转出来，如在switch语句中，使流程跳转出当前的switch语句，继续执行switch语句下面的一个语句，在循环语句中从某个循环体内跳出，接着执行循环语句下面的语句。break语句分为下面两种情况：未带标志形式的break语句和带标志形式的break语句。2.7.1break语句（1）break语句用于终止某个语句块的执行

{…… break;……}

2.7.1break语句（2）break语句出现在多层嵌套语句块中时，可以通过标签指明要终止的是哪一层语句块。

label1:{…… label2: {……label3: {…… breaklabel2; …… } } }Break语句应用举例

publicclassBreakDemo{publicstaticvoidmain(String[]args){inta[]={1,2,3,4,5,6,7,8,9,10};intsearchfor=5;inti=0;booleanfoundIt=false;for(;i<a.length;i++){if(a[i]==searchfor){foundIt=true;break;}2.7跳转语句

}if(foundIt){System.out.println("Found"+searchfor+"atindex"+i);}else{System.out.println(searchfor+"notinthearray");}}}使用JCreator编译执行程序运行效果如图2-10所示。2.7.2continue语句

continue语句用于跳过某个循环语句块的一次执行；continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

。下面程序使用continue语句计算0~10之间的奇数之和。

publicclassContinueTest{publicstaticvoidmain(Stringargs[]){intsum=0;for(inti=0;i<10;i++){if(i%2==0)2.7.2continue语句

continue;sum=sum+i;}System.out.println("0~10之间的奇数之和="+sum);}}使用JCreator编译执行程序效果如图所示。

2.7.3return语句

可以使用return语句来退出当前的方法，控制流程返回到调用方法的下一个语句，继续该程序的执行。这个return语句有两种形式：一种是返回一个数值，另外一种没有返回数值。为了返回一个数值，简单地，可以将数值放置在return关键字后面即可。例如：

return++count;由return返回的数值类型必须匹配方法声明返回的数值类型。当方法被声明void，return的使用就不返回一个数值。2.7.3return语句

例如：

publicvoidget(Stringname){ if(name==null) return; //语句块}2.1标识符、分隔符和关键字

3.1类的创建

类是组成Java程序的基本要素，也是Java中重要的引用数据类型。类封装了一类对象的状态属性和行为方法，是类对象的原型。创建一个新类，就是创建一种新的数据类型，即引用数据类型。3.1.1类的声明

类的实现包括两部分：类声明和类体。基本格式为：//语法格式：[<修饰符>]class<类名>[<extendsSuperclassName>][<implementsinterfaceNameList>]{[<成员变量声明>][<构造函数声明>][<成员方法声明>]}3.1.1类的声明

其中修饰符可以是pubic、abstract或final，说明类的属性。这个public关键字声明了类可以在其它任何的类中使用；abstract关键字声明了这个类不能被实例化；Final关键字声明了类不能被继承，即没有子类了。l

class是关键字，用来定义类，类名必须是合法的Java标识符；extends是关键字，用来说明该类是SuperclassName.SuperclassName是该类的父类的名字；l

implements是关键字，用来声明本类要执行的一个或多个接口，interfaceNameList是本类所执行的接口的名字列表，它们是以逗号分隔的。

两个大括号以及之间的内容是类体。3.1.2类体

类体是跟在类声明的后面，它是嵌入在大括号“{”和“}”中间的。类体中定义该类中所有的变量和所支持的方法。例如：

classPerson{ intage;//成员变量

intgetAge(){//成员方法

returnage;} voidsetAge(inti){//成员方法

age=i;}}3.1.3成员变量和局部变量

类的状态是由它的成员变量给出的，你可以在类体中声明一个类的成员变量。

成员变量：在类体中，变量声明部分所声明的变量被称为类的成员变量；

局部变量：在方法体中声明的变量和方法中的参数被称为局部变量。对类的成员变量来说，又可以分为实例成员变量和类成员变量，如果在声明时，用修饰符static声明的变量称为类变量，在声明时，没有用修饰符static修饰的变量称为实例变量。3.1.3成员变量和局部变量

成员变量的类型可以是Java中任意的数据类型，包括简单类型、类、接口和数组。成员变量在类的定义中声明，在一个类中成员变量的名字是唯一的。在创建对象的同时创建有关的成员变量，成员变量创建后系统自动对其进行默认初始化或显式初始化。

成员变量依附于对象(局部变量)的存在而存在，具有与对象相同的生存期和作用域。例如：

publicclassPerson{privateintage;publicStringname=“Lila”;}成员变量的限定符

对于一个成员变量，可以使用不同的限定符，以限定不同的访问权限。Private：变量可以被类中的代码访问Friend：变量可以被工程或组件中的代码访问Protected：可以被继承的类访问Public：适用于类外的代码通常，使用Private关键字来声明成员变量，使这些变量仅适用于每个类实例中的代码。同时这种方式也符合类的封装性。成员变量的限定符

对于一个成员变量，还可以使用下面的限定符：

static:

用来制订一个变量使静态变量（类变量），没有static修饰的变量是实例变量。类变量既可以由类方法访问，由可以右实例方法来访问。

final:

用来声明一个常量，作用相当于C语言中define命令，对于用final关键字修饰的常量，在程序中不能作修改，通常常两用答谢字母。

volatile：用来声明一个由多线程共享的变量，使得各线程对该变量的访问能保持一致。定义和使用局部变量案例

publicclassTestvarible{ privateinti=1; publicvoidmethod1(){ inti=4,j=5; this.i=i+j; method2(7);} publicvoidmethod2(inti){ intj=8; this.i=i+j; System.out.println(this.i);} publicstaticvoidmain(String[]args){ Testvariblet=newTestvarible(); t.method1();}}定义和使用局部变量案例程序执行的效果如图所示。思考题：该例中哪些是局部变量和哪些是成员变量？并说明其作用域？3.1.4方法

对象的行为是由它的成员方法来执行的，其它对象通过调用它的方法来访问对象。在JAVA中，你可以在变量声明之后再声明类的成员方法。对类的成员变量来说，可以分为实例成员变量和类成员变量，同样成员方法同样可以分为实例成员方法和类成员方法。如果在声明时，用修饰符static声明的方法称为类方法，在声明时，没有用修饰符static修饰的变量称为实例方法。

方法的定义包括两部分：方法的声明和方法体。定义和使用方法

classTestmethod{doublex,y;staticfloatmark;floattotal(floata,floatb){floattotal;x=0.4;y=0.6;total=(float)(x*a+y*b);returntotal;}staticvoidsetmark(floati){mark=i;}staticfloatgetmark(){returnmark;}续

publicvoiddisplay(){System.out.println("Thetotalscore"+"="+mark);publicstaticvoidmain(String[]args){ Testmethodtm=newTestmethod(); mark=tm.total(67,98); tm.display(); tm.setmark(96); tm.display(); }}程序执行的效果

该例中，方法setmark和getmark是类方法；方法total是实例方法，返回值是float类型，在方法被调用时，形式参数a，b用来接受外部输入的数据（实际参数）。3.1.5方法重载

方法重载（overloading）是指多个方法享有相同的名字，方法的参数列表必须不一样，这里的不一样可能是个数，类型不一样。重载和方法的返回值无关，返回值可以相同，也可以不同。在同一个类中可以定义多个同名方法。如：classTestoverload{voidstudent()；voidstudent(Stringstr)；voidstudent(Stringstr,Stringn)；booleanstudent(Stringstr,inta)；}3.1.6构造函数

在面向对象程序语言中，创建对象的时候总是调用一个特定的方法，这个方法叫做构造函数。在Java语言中，构造函数特点是：构造函数的名字必须与它所在的类的名字完全相同；构造函数不返回任何数据类型，即它是void型，但不能写void；构造函数一般不能有编程人员显示地直接调用，必须通过运算符new调用或者在创建对象时由系统自动调用。默认的构造函数Java语言中，每个类都至少有一个构造方法；如果类的定义者没有显式的定义任何构造方法，系统将自动提供一个默认的构造方法：默认构造方法没有参数默认构造方法没有方法体Java类中，一旦类的定义者显式定义了一个或多个构造方法，系统将不再提供默认的构造方法；默认的构造方法类的定义：publicclassPerson{ privateintage; publicvoidsetAge(intw){age=w;} }等价于：publicclassPerson{ privateintage publicPerson(){} publicvoidsetAge(intw){age=w;} }应用举例：publicclassTest{publicstaticvoidmain(Stringargs[]){Persond=newPerson();d.setAge(16);}}用于覆盖范围规则，代表当前对象本身。当一个方法需要激活它的对象时，即可以利用this实现该功能。因此，this可以看成是类对象的别名，使类中的隐藏数据以及方法可以引用。如：classCollege {inta; publicstaticvoidmain(Stringargs[]) {inta=6; Collegebb=newCollege();System.out.println("main().a="+a);System.out.println("bb.a="+bb.call());}3.1.7this的用法

续

intcall(){inta=9;this.a=a++;System.out.println("call().a="+a);returnthis.a;}}程序执行的效果

3.2继承

继承（inheritance）的思想就是重用其它类中的方法和属性来创建新类。利用继承，可以先创建一个具有某些基本功能的一般类，然后将这些类作为基础去创建具有特殊功能的类。由继承而得到的类称为子类（subclass），被继承的类称为父类或超类（superclass）。父类包括所有直接或间接被继承的类。一个父类可以同时拥有多个子类，由于Java不支持多重继承，所以一个子类只能拥有一个直接父类。在Java中，所有的类都是通过直接或间接继承类java.lang.Object而得到的。类的继承(1)为描述和处理个人信息，定义类Person:publicclassPerson{publicStringname;publicintage;publicDatebirthDate;publicStringgetInfo(){...}}Person+name:String+age:int+birthDate:Date+getInfo():String类的继承(2)为描述和处理学生信息，定义类Student:publicclassStudent{publicStringname;publicintage;publicDatebirthDate;publicStringschool;publicStringgetInfo(){...}}Student+name:String+age:int+birthDate:Date+school:String+getInfo():String类的继承(3)通过继承，简化Student类的定义:publicclassPerson{publicStringname;publicintage;publicDatebirthDate;publicStringgetInfo(){...}}publicclassStudentextendsPerson{publicStringschool;}Person+name:String+age:int+birthDate:Date+getInfo():StringStudent+school:String3.2.3成员变量的隐藏和方法的覆盖

变量的隐藏：如果子类中定义的成员变量和父类中的成员变量完全相同，此时父类中的成员变量将被隐藏，这种现象称为变量的隐藏。

方法的覆盖：如果在子类中定义的方法和父类中定义的方法在名字、返回类型、参数个数和参数类型方面完全相同，此时父类中的方法将被隐藏，这种现象被称为方法的覆盖或重写。案例见3-6，p69.3.2.4关键字static

在Java类中声明变量、方法和内部类时，可使用关键字static做为修饰符。static标记的变量或方法由整个类(所有实例)共享，如访问控制权限允许，可不必创建该类对象而直接用类名加‘.’调用。static成员也称类成员或静态成员，如：类属性、类方法、静态方法等。应用案例见p71例3-7，3-8。3.2.5关键字final和abstract

final的用法在Java中声明类、属性和方法时，可使用关键字final来修饰。final标记的类不能被继承。final标记的方法不能被子类重写。final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。final标记的成员变量必须在声明的同时或在每个构造方法中显式赋值，然后才能使用。应用案例见p73例3-9。3.2.5关键字final和abstract

abstract的用法

如果一个类在声明时被关键字abstract所修饰，说明该类不能直接创建对象，这样的类被称为抽象类。抽象类往往是它的所有子类共有属性的集合。如Java中的Number类就是一个抽象类。抽象类必须产生子类，由子类创建对象。

如果一个方法在声明时被关键字abstract所修饰，那么该方法被称为抽象方法。抽象方法只允许声明，不允许实现。应用案例见p74例3-10。3.2.6关键字super

在子类中隐藏了父类的成员变量或覆盖了父类的方法后，常常还需要调用父类中被隐藏的变量和被覆盖的方法，这是就需使用关键字super来访问父类的变量和方法。关键字this用来引用当前对象，而关键字super用来引用当前对象的父类。使用关键字super不仅可以访问父类中被隐藏成员变量和覆盖的方法，而且还可以调用父类的构造函数。应用案例见p75例3-11。3.3包

由于Java编译器为每个类生成一个字节码文件，且文件名与public的类名相同，因此同名的类有可能发生冲突。为了解决这个问题，Java提供包（package）来管理类名空间和访问保护机制。package语句package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为：

packagepkg1[.pkg2[.pkg3…]];

举例：Beauty.java

packagestudentbiggirl;publicclassBeauty{ publicvoiddisplay(){ System.out.println("I’vebigeyes"); }}Java编译器把包对应于文件系统的目录管理，package语句中，用‘.’来指明包(目录)的层次；

import语句为使用定义在不同包中的Java类，需用import语句来引入所需要的类。语法格式：

importpackage1[.package2…].(classname|*);应用举例：

importstudent.biggirl.Beauty;publicclassTestPackage{publicstaticvoidmain(Stringargs[]){Beautyb=newBeauty(); b.show(); }}3.4访问控制ModiferSameClassSamePackageSubclassUniverseprivateYesdefaultYesYesprotectedYesYesYespublicYesYesYesYes可以对Java类中定义的属性和方法进行访问控制规定不同的保护等级：应用案例见p80-87例3-14-17。3.4访问控制

Java语言支持对成员变量和方法的四个访问等级：private、protected、public以及defaut的等级。3.5接口

接口(interface)是抽象方法和常量值的定义的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。接口定义举例publicinterfaceRunner{ intid=1; publicvoidstart(); publicvoidrun(); publicvoidstop();}3.5接口

多个无关的类可以实现同一个接口一个类可以实现多个无关的接口与继承关系类似，接口与实现类之间存在多态性接口应用如：

classPersonextendsAnimalimplementsRunner,Swimmer

类Person继承类Animal，并使用接口Runner和接口Swimmer。接口应用案例p89,例3-18内部类在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类内部类和外层封装它的类之间存在逻辑上的所属关系Innerclass一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。Innerclass的名字不能与包含它的类名相同；Innerclass可以使用包含它的类的静态和实例成员变量，也可以使用它所在方法的局部变量；接口应用案例p91-03,例3-19、3-204.1对象

在面向对象的程序设计中，将任何实体都看成对象。对象是通过对实体的抽象得到，由属性和方法组成。属性是实体的一些特征值，方法是实体的功能和方法。对象之间通过消息进行传递进行交互，最终完成任务。对象生命周期三个阶段：创建、使用和清除。4.1.1对象的创建

对象是从类来创建的,Java语言中除8种基本数据类型以外的数据类型都称为引用类型。引用类型数据以对象的形式存在，引用类型变量的值是某个对象的句柄，而不是对象本身；声明引用类型变量时，系统只为该变量分配引用空间，并未创建一个具体的对象。Java对象的创建案例classPoint{intx,y;Point(){x=10;y=16;}Point(inta,intb){x=a;y=b;}}Java对象的创建案例

publicclassTestobject{publicstaticvoidmain(Stringargs[]) {Pointp1,p2;p1=newPoint();//为对象分配内存，使用

new和类中的构造方法

p2=newPoint(111,222);System.out.println("点p1的x坐标是："+p1.x);System.out.println("点p1的y坐标是："+p1.y);System.out.println("点p2的x坐标是："+p2.x);System.out.println("点p2的y坐标是："+p2.y); }}程序执行的效果如图所示

下面语句从Point类创建了一个对象，包含了创建对象的三个阶段：创建、实例化和初始化。

Pointp1,p2;p1=newPoint();//为对象分配内存，使用

new和类中的构造方法。

p2=newPoint(100,100);4.1.2对象的使用

对象的使用包括引用对象的成员变量和方法的调用，通过运算符“.”可以实现对变量的访问和方法调用。引用对象的变量访问格式：引用对象.变量引用对象的方法访问格式：引用对象.方法名Java对象的创建和用法案例

classBirthDate{ privateintday; privateintmonth; publicintyear; publicvoidsetDay(intd){day=d;} publicvoidsetMonth(intm){month=m;} publicvoidsetYear(inty){year=y;}publicintgetDay(){returnday;} publicintgetMonth(){returnmonth;} publicintgetYear(){returnyear;} }续

publicclassObjectOperating{ publicstaticvoidmain(Stringargs[]){ BirthDateb=newBirthDate();

b.setDay(1); b.setMonth(10); b.getMonth(); b.setYear(2003); //b.day=2;//不合法，无权访问该私有属性

b.year=2003;

System.out.println(b.getDay()+"-"+b.getMonth()+"-"+b.getYear());}}续程序执行的效果如图4-10所示

4.1.3对象的清除

Java平台允许你创建任意个对象（当然也会受到系统的限制），在当对象不再使用的时候被清除的，这个过程就是所谓的“垃圾收集”。

Java运行时系统通过垃圾收集周期地释放无用对象所使用的内存，完成对象的清除工作。