声明声明 本本 PPTPPT 讲述了讲述了 JAVAJAVA 的基础知识的基础知识

由于由于 JAVAJAVA 和和 CC 本身很接近本身很接近 ,, 所以本所以本 PPTPPT 主要侧主要侧重于说明两者的区别重于说明两者的区别

制作这个制作这个 PPTPPT 的目的的目的 : : 力图大家可以从对比中轻力图大家可以从对比中轻松的掌握松的掌握 JAVAJAVA 语言语言

本本 PPT PPT 配有一些例子程序，都比较短小，适合大配有一些例子程序，都比较短小，适合大家直接用记事本直接编写家直接用记事本直接编写

内容内容 第一章 初识 第一章 初识 JAVAJAVA 第二章 第二章 JAVAJAVA 的基本元素的基本元素 第三章 类第三章 类 第四章 其他操作第四章 其他操作

第第 11 章 初识章 初识 JAVAJAVA

第第 11 章 初识章 初识 JAVA JAVA JAVA JAVA 简介简介 JAVA JAVA 程序的执行程序的执行 JAVA JAVA 的安装的安装 第一个第一个 JAVA JAVA 程序程序

JAVA JAVA 简介简介 JAVA JAVA 是一种完全面向对象的程序是一种完全面向对象的程序 JAVA JAVA 程序中只有类程序中只有类 ,, 而而 C++C++ 中可以没有中可以没有

类类 JAVA JAVA 程序分类程序分类

JAVA JAVA 应用程序应用程序 JAVA AppletJAVA Applet

JAVAJAVA 程序的执行程序的执行 JAVAJAVA 程序的执行原理是程序的执行原理是 :: 先将源代码编译先将源代码编译

为字节代码为字节代码 (.class(.class 文件文件 )) 然后字节代码可以在然后字节代码可以在 JAVAJAVA 虚拟机虚拟机 (JVM (JVM

Java Virtual Machine)Java Virtual Machine) 上解释执行上解释执行

JAVA JAVA 的安装的安装 JAVA JAVA 的安装的安装 JAVA JAVA 环境变量的设置环境变量的设置

下载安装下载安装JDK JDK 官方下载地址官方下载地址

http://java.sun.com/javase/downloads/indhttp://java.sun.com/javase/downloads/index.jspex.jsp 可以选择 可以选择 JDK6 JDK6 的安装包的安装包

TIPS:TIPS: 安装的时候会提示您选择安装在什么目安装的时候会提示您选择安装在什么目录下录下 , , 建议安装路径不要有空格建议安装路径不要有空格 , , 所以不宜安所以不宜安装在装在 \Program Files\Program Files 目录下目录下

环境变量设置环境变量设置安装完安装完 JDK JDK 之后需要进行之后需要进行系统环境变量系统环境变量的设置的设置 右键点我的电脑右键点我的电脑 ,, 选择属性选择属性 ->-> 高级高级 ->-> 环境变量环境变量

假如假如 JDKJDK 安装的目录是安装的目录是 C:\jdk1.6C:\jdk1.6 添加一个名为添加一个名为 JAVA_HOMEJAVA_HOME 的系统变量的系统变量 ,, 值为值为 C:C:

\jdk1.6\jdk1.6 然后在然后在 PATHPATH 这个变量的最后这个变量的最后

加入 加入 ;%JAVA_HOME%\bin;%JAVA_HOME%\bin 加入加入 CLASSPATHCLASSPATH 这个变量 其值为空的这个变量 其值为空的 需要设置这个环境变量，不过它的值是空的需要设置这个环境变量，不过它的值是空的 !! 不不

然可能运行的时候会出错然可能运行的时候会出错 ..

第一个第一个 JAVAJAVA 程序程序现在可以用记事本敲一个现在可以用记事本敲一个 JAVAJAVA 程序了程序了 ,, 先来个先来个 HelloWorlHelloWorl

dd 程序程序

代码如下代码如下 : (HelloWorld.java): (HelloWorld.java)public class HelloWorldpublic class HelloWorld{{

public static void main(String [] args)public static void main(String [] args){{

System.out.println("Hello World");System.out.println("Hello World");}}

}}

第一个第一个 JAVAJAVA 程序程序运行方法运行方法 : : 开始菜单开始菜单 ->-> 运行运行 ->cmd->cmd去到去到 JAVAJAVA 文件的目录下文件的目录下 (( 例如我的电脑是例如我的电脑是 C:\java)C:\java)

执行以下命令执行以下命令 :: C:\java>javac HelloWorld.javaC:\java>javac HelloWorld.java C:\java>java HelloWorldC:\java>java HelloWorld

一切正常的话一切正常的话 ,, 您将可以看到您将可以看到 Hello World Hello World 这行字这行字如果出现任何异常如果出现任何异常 , , 请看本请看本 PPTPPT 下一页的建议下一页的建议

说明说明 JAVAJAVA 程序中程序中 , , 类名要与文件名一致类名要与文件名一致 例如例如 HelloWorld HelloWorld 程序中程序中 ,, 类的名字是类的名字是 HelloWorld,HelloWorld,

那么保存文件的时候那么保存文件的时候 ,, 就应该保存为就应该保存为 HelloWorld.javaHelloWorld.java

执行的时候需要使用执行的时候需要使用 javacjavac 将源代码转化为字节代码将源代码转化为字节代码 ,,其执行语句是 其执行语句是

javac javac 类名类名 .java (.java ( 执行结果将产生执行结果将产生 .class.class 文件文件 )) 真正执行程序的语句是真正执行程序的语句是

java java 类名 类名 (( 该句将执行该类的该句将执行该类的 mainmain 函数函数 ))

第第 22 章 章 JAVAJAVA 基本元基本元素素

第第 22 章 章 JAVAJAVA 基本元素 基本元素 大家可以看到大家可以看到 JAVA JAVA 程序与程序与 C++C++ 程序非常相似，只是一程序非常相似，只是一些细节上的不同。由于大家对些细节上的不同。由于大家对 C++C++ 都已经非常熟悉，所都已经非常熟悉，所以下面主要讲述的是他们的区别以下面主要讲述的是他们的区别

本章讲述的内容有：本章讲述的内容有： JAVA JAVA 程序框架程序框架 JAVA JAVA 数据类型数据类型 JAVA JAVA 表达式表达式 JAVA JAVA 对象和引用变量对象和引用变量 JAVA JAVA 的的 StringString 类类 JAVA JAVA 的输入输出的输入输出 JAVA JAVA 中的方法中的方法 JAVA JAVA 的方法中的参数传递方式的方法中的参数传递方式 JAVA JAVA 数组数组 JAVA JAVA 包的使用包的使用

JAVA JAVA 程序框架程序框架如何才能创建一个如何才能创建一个 JAVAJAVA 应用程序呢？应用程序呢？我们先来看看 我们先来看看 HelloWorld HelloWorld 程序的意义程序的意义

第一行第一行 public class HelloWorldpublic class HelloWorld它定义了一个类它定义了一个类 ,public,public 表示可以被外部访问表示可以被外部访问 ,, 它它的意义以后还会解释的意义以后还会解释

第二行第二行 public static void main(String [] args)public static void main(String [] args)这是这个类的主函数这是这个类的主函数 ,, 程序将从这个地方开始执程序将从这个地方开始执行行

mainmain 中的语句是输出一个字符串中的语句是输出一个字符串

JAVA JAVA 程序框架程序框架 一个一个 javajava 文件只能有一个声明为文件只能有一个声明为 publicpublic 的类的类 ,,

而且这个类的类名应该与主文件名一致而且这个类的类名应该与主文件名一致 类中必须有一个 类中必须有一个 public static void main public static void main 方方

法法这是程序执行的起点这是程序执行的起点

注注 :: 以上都是针对只有一个以上都是针对只有一个 javajava 源代码文件的程序源代码文件的程序而言的而言的 , , 多个源代码文件的情况以后再做说明多个源代码文件的情况以后再做说明

数据类型数据类型JAVA JAVA 的数据类型分为两大类的数据类型分为两大类 简单数据类型（共简单数据类型（共 88 种）种） 除了上面的几种外，除了上面的几种外， JAVAJAVA 中只存在类，类对中只存在类，类对

象的定义全部是引用变量 （象的定义全部是引用变量 （注：注：我在后面的描我在后面的描述中，把除了简单数据类型之外的数据类型称述中，把除了简单数据类型之外的数据类型称为“为“对象数据类型对象数据类型”）”）

它们有着本质的区别，主要是内存分配方它们有着本质的区别，主要是内存分配方式不不同式不不同 . . 它们的区别将在本章的 “它们的区别将在本章的 “ JAVJAVA A 对象和引用变量” 一节中进行叙述对象和引用变量” 一节中进行叙述

简单数据类型 简单数据类型 简单数据类型有简单数据类型有 33 个大类个大类分别是分别是 :: 整数数据类型整数数据类型 浮点数据类型浮点数据类型 布尔数据类型布尔数据类型

整数数据类型整数数据类型 char 0 ~ 65535char 0 ~ 65535 byte -128 ~ 127byte -128 ~ 127 short -32768 ~ 32767short -32768 ~ 32767 int -2^31 ~ 2^31-1 int -2^31 ~ 2^31-1 long -2^63 ~ 2^63-1long -2^63 ~ 2^63-1

charchar 类型对应的是类型对应的是 Unicode Unicode 字符集字符集 ,, 其中 其中 0-127 0-127 对对应了我们常用的应了我们常用的 ASCIIASCII 码码 .. 该类型该类型 C++C++ 中的使用方法中的使用方法在在 JavaJava 中是可行的中是可行的 ,, 只是它在只是它在 JAVAJAVA 中可以覆盖更多中可以覆盖更多的字符的字符

浮点数据类型浮点数据类型 float -3.4E+38 ~ 3.4E+38float -3.4E+38 ~ 3.4E+38 double -1.7E+308 ~ 1.7E+308double -1.7E+308 ~ 1.7E+308

布尔类型布尔类型 boolean boolean 其值为其值为 true true 或者 或者 false false

简单数据类型就只有上面介绍的简单数据类型就只有上面介绍的 33 大类共大类共 88 种种

表达式及表达式计算表达式及表达式计算

表达式计算的优先顺序，运算符的优先顺表达式计算的优先顺序，运算符的优先顺序，类型强制转换及隐式转换的规则与序，类型强制转换及隐式转换的规则与 C+C+++ 完全一样。完全一样。举例：举例：

（（ 4+74+7 ）） ** （（ 45/745/7 ）） （（ 4+74+7 ）） ** （（（（ doubledouble ）） 45/745/7 ） ）

JAVA JAVA 对象和引用变量对象和引用变量 简单数据类型只有前面那简单数据类型只有前面那 88 种种 ,, 和和 C++C++ 很类似很类似 对象数据类型定义的变量则是“对象数据类型定义的变量则是“指向指向类对象的引类对象的引

用”，这种变量是“引用变量”用”，这种变量是“引用变量”

简单数据类型与对象数据类型有本质的区别简单数据类型与对象数据类型有本质的区别 简单数据类型定义的是一个“变量”简单数据类型定义的是一个“变量” ,, 它的内存空间是它的内存空间是

在定义的时候就分配的在定义的时候就分配的 对象数据类型定义的是某个类的一个“引用变量”对象数据类型定义的是某个类的一个“引用变量” ,, 它它仅仅是一个指针仅仅是一个指针 . . 该类变量需要使用该类变量需要使用 newnew 运算符进行运算符进行内存分配内存分配 . . 在分配空间以后在分配空间以后 , , 该“引用变量”就指向该“引用变量”就指向了这片申请的空间的地址。了这片申请的空间的地址。

例子例子先用一个例子来说明先用一个例子来说明简单数据类型中有简单数据类型中有 intint 类型类型JAVAJAVA 系统中还定义了一个与之对应的类系统中还定义了一个与之对应的类 : Integ: Integ

erer考虑以下语句：考虑以下语句：

int x; int x; x=30;x=30;

Integer y;Integer y; y=new Integer(67);y=new Integer(67);

30X

2700 67X

X

地址2700

X 的值

Integer 对象

简单数据类型 简单数据类型 int x; int x; 在定义的时候，就为在定义的时候，就为 xx 分配了内存空间分配了内存空间x=30 x=30 语句是对语句是对 xx 进行赋值进行赋值

对象数据类型 对象数据类型 Integer y; Integer y; 这句话声明的是一个指向这句话声明的是一个指向 Integer Integer 对象的引用。对象的引用。

它定义时并不分配内存，其实它的变量只是一个指针（即它定义时并不分配内存，其实它的变量只是一个指针（即该变量存储的只是一个地址）该变量存储的只是一个地址）执行执行 y=new Integer(67); y=new Integer(67); 一句时才为它分配指向一句时才为它分配指向 IntegerInteger 类型的内类型的内

存空间存空间在这里在这里 yy 是“引用变量”是“引用变量”

补充：有人说，补充：有人说， JAVAJAVA 是一种没有指针的语言是一种没有指针的语言我想正确的理解应该是：我想正确的理解应该是： JAVAJAVA 是有指针的，只是是有指针的，只是

它在它在 内部为你工作，对程序员是透明的。但是由于程序内部为你工作，对程序员是透明的。但是由于程序员员 不能直接进行指针操作，所以不能直接进行指针操作，所以 JAVAJAVA 数据处理的灵数据处理的灵活性活性 要低于要低于 C++C++

几种对象数据类型几种对象数据类型

与与 88 种基本数据类型相对应，种基本数据类型相对应， javajava 系统中系统中定义了定义了 88 种相应的对象数据类型，分别为：种相应的对象数据类型，分别为：

Character Byte Short Integer Long Character Byte Short Integer Long Float Double Float Double Boolean Boolean

StringString 类类 String String 类是类是 JAVAJAVA 最重要的类之一最重要的类之一

在输入输出等很多地方都需要用到它在输入输出等很多地方都需要用到它 定义定义

String name;String name; name=“Rhode”;name=“Rhode”; 以上第以上第 22 行等价于行等价于

name=new String(“Rhode”);name=new String(“Rhode”); 因为因为 StringString 类中定义了一个“类中定义了一个“ =”=”赋值运算符，所以赋值运算符，所以

使用使用 StringString 类的时候，可以不使用类的时候，可以不使用 newnew 运算符运算符

String String 类的用法类的用法String String 类重载了很多运算符，使用方便类重载了很多运算符，使用方便

String s1 , s2 , t;String s1 , s2 , t; s1=“My”; s1=“My”; s2=“Book”;s2=“Book”; t=s1+s2; // MyBookt=s1+s2; // MyBook int i=3;int i=3; t=s1+i; // My3t=s1+i; // My3

一些特殊的例子一些特殊的例子n1=12; n2=3; String str;n1=12; n2=3; String str;str=“Sum : ”+n1+n2; // str=“Sum : ”+n1+n2; // 执行后 执行后 str=“Sum : 123”;str=“Sum : 123”;str=“Sum : ”+(n1+n2); // str=“Sum : ”+(n1+n2); // 执行后 执行后 str=“Sum : 15”;str=“Sum : 15”;str=n1+n2+”is the Sum” // str=n1+n2+”is the Sum” // 执行后 执行后 str=15+“is the Sustr=15+“is the Sum”;m”;

执行顺序从左向右，加法执行是整数相加执行顺序从左向右，加法执行是整数相加

String String 类常用的方法类常用的方法 举例 举例 str=“The book”;str=“The book”; char charAt (int index) char charAt (int index) 取第取第 indexindex 个字符个字符 int compareTo (String str1); int compareTo (String str1); 与与 str1str1 比较大小，返回比较大小，返回

比较的值，功能与比较的值，功能与C++C++ 中中 strcmpstrcmp 类似类似

String concat (String str1); String concat (String str1); 把把 str1str1 加到原字符加到原字符串上串上

boolean equals (String str1);boolean equals (String str1); 比较两个字符串是比较两个字符串是否相同，返回否相同，返回 值为值为 true true 或者 或者 falsefalse

int length ()int length ()； ； 返回字符串的长度返回字符串的长度 String substring(int s, int l) String substring(int s, int l) 返回从第返回从第 ss 个字符个字符

到第到第 ll 个字符的子串个字符的子串 String toUpperCase(); String toUpperCase(); 返回全部转化为大写字母返回全部转化为大写字母

的字符串的字符串 String toLowerCase(); String toLowerCase(); 返回全部转化为小写字母返回全部转化为小写字母

的字符串的字符串

String String 对象的理解对象的理解这是类的对象这是类的对象 ,, 它的变量是“引用变量”它的变量是“引用变量”是指向是指向 StringString 对象的指针对象的指针

1300 Rhodename

地址1300

name 的值

String 对象

加深理解加深理解 比较两个字符串是否相等比较两个字符串是否相等

现在有定义如下：现在有定义如下：String str1=new String(“abc”);String str1=new String(“abc”);String str2=new String(“abc”);String str2=new String(“abc”);String str3=str1;String str3=str1;

语句语句 11 ：： if (str1==str2)if (str1==str2)语句语句 22 ：： if (str1.equals(str2))if (str1.equals(str2))语句语句 33 ：： if (str1==str3)if (str1==str3)

以上以上 22 个语句是不同的，我们说过个语句是不同的，我们说过 str1,str2str1,str2 叫引用变量，这样的变量是叫引用变量，这样的变量是只是一个“引用”，它的内涵你可以理解为指针，也就是地址。只是一个“引用”，它的内涵你可以理解为指针，也就是地址。

由于由于 str1,str2str1,str2 分配不同的空间，他们地址不同，所以语句分配不同的空间，他们地址不同，所以语句 11返回返回 falfalsese

真正的字符串内容的比较用的是语句真正的字符串内容的比较用的是语句 22 ，他的值是，他的值是 truetrue 由于由于 str1,str3str1,str3 他们指向了同一个对象（即他们的地址相同），所以他们指向了同一个对象（即他们的地址相同），所以

语句语句 33返回返回 truetrue

StringString 类常用的转换类常用的转换 将将 String String 类转化为类转化为 int int 或者 或者 double double 等类型的等类型的

方法：使用方法：使用 IntegerInteger 类或者类或者 DoubleDouble 类的静态方类的静态方法来转化，举例：法来转化，举例： 转化为 转化为 int int

int x = Integer.ParseInt(“45”); // int x = Integer.ParseInt(“45”); // 执行后 执行后 x=45x=45 转化为 转化为 doubledouble

double x = Double.ParseDouble(“7.5”); // double x = Double.ParseDouble(“7.5”); // 执行后 执行后 x=7.5x=7.5 将将 intint或者或者 double double 转化为转化为 String String 比较简单，可比较简单，可

以利用 以利用 StringString 类提供的运算符来巧妙的转化：类提供的运算符来巧妙的转化：例如：将例如：将 intint 装化为装化为 String String 可以用下面的语句可以用下面的语句

int x; int x; String str = “”+x;String str = “”+x;

JAVAJAVA 的输入输出的输入输出JAVAJAVA 写控制台程序的输入需要自己处理写控制台程序的输入需要自己处理 JJAVAAVA 提供的只是输入的字符流处理提供的只是输入的字符流处理

我们需要定义一个我们需要定义一个 InputStreamReaderInputStreamReader对象和一个对象和一个 BufferdReader BufferdReader 对象，这样我对象，这样我们可以获得需要的字符串，如果需要再将们可以获得需要的字符串，如果需要再将字符串转化为整数或者浮点数。字符串转化为整数或者浮点数。

具体做法如下：具体做法如下：

JAVAJAVA 的输入的输入 首先定义一个首先定义一个 InputStreamReaderInputStreamReader 对象和一个对象和一个 BuBu

fferdReaderfferdReader 对象如下：对象如下： InputStreamReader charReader=InputStreamReader charReader=

new InputStreamReader(System.in);new InputStreamReader(System.in); BufferdReader keyboard=BufferdReader keyboard=

new BufferdReader(charReader);new BufferdReader(charReader);以上两句可以合并写为下面这一句：以上两句可以合并写为下面这一句：

BufferedReader keyboardBufferedReader keyboard=new BufferedReader=new BufferedReader(new InputStreamReader(System.i(new InputStreamReader(System.i

n));n));

有了上面的定义后，就可以进行以下操怍有了上面的定义后，就可以进行以下操怍 读入单个字符 读入单个字符 ch=(char)keyboard.read();ch=(char)keyboard.read(); 读入整行的字符串 读入整行的字符串 str=keyboard.readLine();str=keyboard.readLine(); 读入整数 读入整数

num=Integer.parseInt (keyboard.readLine());num=Integer.parseInt (keyboard.readLine()); 读入浮点数读入浮点数

dbnum=Double.parseDouble (keyboard.readLinedbnum=Double.parseDouble (keyboard.readLine())())

可以看出，输入操作只能得到字符流可以看出，输入操作只能得到字符流如果要获得数字的输入，还需要自己转换如果要获得数字的输入，还需要自己转换

JAVAJAVA 输出输出 输出的语句是 输出的语句是

System.out.println(String str);System.out.println(String str); System.out.print(String str);System.out.print(String str); System.out.flush(); // System.out.flush(); // 清空缓冲区清空缓冲区

输出举例输出举例 字符串输出字符串输出 : System.out.println(“Hell: System.out.println(“Hell

o”);o”); 整数变量输出整数变量输出 : System.out.println(“”+i);: System.out.println(“”+i);

综合例子综合例子 输入一个数字输入一个数字 ,, 输出它的输出它的 22倍倍 ,,并输出它个位的数字并输出它个位的数字

(ReadWrite.java)(ReadWrite.java)

import java.io.*;import java.io.*; public class ReadWritepublic class ReadWrite {{ public static void main(String [] args) throws IOExceptionpublic static void main(String [] args) throws IOException {{ BufferedReader key=new BufferedReaderBufferedReader key=new BufferedReader

(new InputStreamReader(System.in));(new InputStreamReader(System.in)); String st=key.readLine();String st=key.readLine(); int num=Integer.parseInt(st);int num=Integer.parseInt(st); System.out.println("System.out.println(" 它的两倍是：它的两倍是： "+num*2);"+num*2); System.out.println("System.out.println(" 个位是个位是 : "+st.charAt(st.length: "+st.charAt(st.length

()-1));()-1)); }} }}

程序说明程序说明 InputStreamReader InputStreamReader 和 和 BufferedReaderBufferedReader

这两个类包含在这两个类包含在 java.iojava.io 这个包中这个包中所以程序第一句需要引用这个包所以程序第一句需要引用这个包

main main 函数定义的最后 函数定义的最后 throws IOExceptionthrows IOException这是因为这是因为 IOIO 输入有可能出错输入有可能出错 ,JAVA,JAVA 要求对错误要求对错误抛出异常抛出异常 . . 如果没有这个部分如果没有这个部分 ,, 编译将不能通过编译将不能通过

令牌化输入令牌化输入 前面的输入中，只能够每次读入一行前面的输入中，只能够每次读入一行 如果想输入多个整数如果想输入多个整数 (( 这这 NN 个整数可以在一行 内个整数可以在一行 内

输入并用空格隔开输入并用空格隔开 ,,也可以分行输入也可以分行输入 ,,并且这些数并且这些数字用空格隔开字用空格隔开 ),), 要怎么做呢 ？要怎么做呢 ？

实现这样的以空格为分界的输入就需要下面的令实现这样的以空格为分界的输入就需要下面的令牌化输入方法牌化输入方法

令牌的意义我们可以看作是每两个空格分隔符间令牌的意义我们可以看作是每两个空格分隔符间的字符串的字符串

令牌化输入由令牌化输入由 StringTokenizer StringTokenizer 这个类实现这个类实现 ,, 它它的使用需要引用的使用需要引用 java.utiljava.util 这个包这个包

其使用方法如下其使用方法如下 :: 设置一个令牌字符串对象设置一个令牌字符串对象 ,, 不断读入不断读入

它的 它的 nextToken() nextToken() 方法可以获得下一个空格以前的字符串方法可以获得下一个空格以前的字符串它的它的 hasMoreToken() hasMoreToken() 方法可以判断还有没有令牌方法可以判断还有没有令牌

使用使用 ::StringTokenizer k;StringTokenizer k;k=new StringTokenizer(keyboard.readLine());k=new StringTokenizer(keyboard.readLine());while (while ( 输入的停止条件不成立输入的停止条件不成立 )){{

number=Integer.parseInt(k.nextToken());number=Integer.parseInt(k.nextToken());if (!k.hasMoreToken())if (!k.hasMoreToken())

k=new StringTokenizer(keyboard.readLinek=new StringTokenizer(keyboard.readLine());());}}

格式化输出格式化输出 对浮点数进行格式化输出需要使用对浮点数进行格式化输出需要使用 DecimalFDecimalF

ormatormat 类的对象类的对象 , , 它在它在 java.textjava.text 包中包中 使用方法使用方法 ::

DecimalFormat df=new DecimailFormat(“0.DecimalFormat df=new DecimailFormat(“0.00”);00”);格式化小数点后格式化小数点后 22位位

DecimalFormat df=new DecimailFormat(“0.DecimalFormat df=new DecimailFormat(“0.##”);##”); 格式化小数点后格式化小数点后 22位位 ,,末尾的末尾的 00 用空格填空用空格填空

例如 例如 df.format(45.75367) df.format(45.75367) 将会返回 将会返回 45.7545.75

综合例子综合例子 不断的输入浮点数字不断的输入浮点数字

如果输入的数字等于如果输入的数字等于 00 ，则程序结束，则程序结束 ; ; 如果输入的数字不等于如果输入的数字不等于 00 ，则将浮点数规范化为，则将浮点数规范化为 22位小数输出位小数输出

(UseToken.java)(UseToken.java) import java.io.*;import java.io.*; import java.util.*;import java.util.*; import java.text.*;import java.text.*;

public class UseTokenpublic class UseToken {{ public static void main (String [] args) throws IOExceptiopublic static void main (String [] args) throws IOExceptio

nn {{ BufferedReader keyboard=new BufferedReaderBufferedReader keyboard=new BufferedReader

(new InputStreamReader(System.in));(new InputStreamReader(System.in));

DecimalFormat df=new DecimalFormat("0.00");DecimalFormat df=new DecimalFormat("0.00");

String t;String t; StringTokenizer k;StringTokenizer k; k=new StringTokenizer(keyboard.readLine());k=new StringTokenizer(keyboard.readLine());

t=k.nextToken();t=k.nextToken(); while (!t.equals("0"))while (!t.equals("0")) {{ double num;double num; num=Double.parseDouble(t);num=Double.parseDouble(t); System.out.println(""+df.format(num));System.out.println(""+df.format(num)); if (!k.hasMoreTokens()) if (!k.hasMoreTokens()) k=new StringTokenizer(keyboard.readk=new StringTokenizer(keyboard.read

Line());Line()); t=k.nextToken();t=k.nextToken(); }} }} }}

JAVA JAVA 中的方法中的方法 对简单数据类型来说对简单数据类型来说 , , 以下几点均与以下几点均与 C++C++ 一致一致 , ,

不再赘述不再赘述 运算符 运算符 ( ( 包括四则运算、比较运算、优先顺序、强制包括四则运算、比较运算、优先顺序、强制

转换等 转换等 ) ) 选择结构 选择结构 (if , if …else , switch)(if , if …else , switch) 循环语句（循环语句（ for, while , do…while, break, continufor, while , do…while, break, continu

ee）） C++C++ 中有函数的概念中有函数的概念 ,, 它可以游离于类之外它可以游离于类之外 ,, 而而 JJ

AVAAVA 中不可以存在这样的函数中不可以存在这样的函数 C++C++ 中的类有成员函数的概念中的类有成员函数的概念 ,,

JAVAJAVA 中也有中也有 , , 在在 JAVAJAVA 中将其称为中将其称为“方法”“方法”

一些概念一些概念public int absf(float a)public int absf(float a){{

if (a>0) return a; else return -a;if (a>0) return a; else return -a;}}这是一个这是一个 JAVAJAVA 类的方法的例子类的方法的例子我们把其中我们把其中 public int absf(float a)public int absf(float a) 称为方法的“题称为方法的“题头”，方法名后面是“形参列表”头”，方法名后面是“形参列表”题开最开始的地方是限定词，限定词包括题开最开始的地方是限定词，限定词包括 33 组：组：1.1. public, private, protectedpublic, private, protected2.2. static, abstractstatic, abstract3.3. final final 每一组中都可以选择一个加到方法题头前面表示某种意义，具体含每一组中都可以选择一个加到方法题头前面表示某种意义，具体含义在“类”一章中讲述义在“类”一章中讲述

JAVAJAVA 的方法中的参数传递方式的方法中的参数传递方式

JAVAJAVA 参数传递方式是按值传递参数传递方式是按值传递 ,, 程序首先为程序首先为形参分配一个空间，再把实参复制到形参中 形参分配一个空间，再把实参复制到形参中 ( ( 这是跟这是跟 C++C++ 不同的地方不同的地方 ,C++,C++ 可以有按地址传可以有按地址传

递递 )) 对于简单数据类型对于简单数据类型 , , 在方法中对形参的改变不会在方法中对形参的改变不会影响实参的值影响实参的值

对于对象数据类型对于对象数据类型 (( 引用变量引用变量 ), ), 形参和实参位于形参和实参位于两个不同的内存空间两个不同的内存空间 ,,但是他们都是对同一个对但是他们都是对同一个对象的引用象的引用

JAVAJAVA 的按值传递带来了一些问题的按值传递带来了一些问题例如例如 ,, 我们需要写一个方法实现交换我们需要写一个方法实现交换 22 个简个简单数据类型的整形变量的值单数据类型的整形变量的值 , JAVA, JAVA 就没有就没有比较简单的办法比较简单的办法 ..

下面是我自己写过的一个错误的例子下面是我自己写过的一个错误的例子 我开始认为对象数据类型是指向类对象的引用我开始认为对象数据类型是指向类对象的引用 , ,

和和 C++C++ 类似类似 ,, 所以可以采用与所以可以采用与 C++C++ 类似的方法类似的方法来实现来实现 22 个数字的交换，于是写了下面一个错个数字的交换，于是写了下面一个错误的版本误的版本

错误版本错误版本

public class MethodSpecialpublic class MethodSpecial {{ public static void main(String [] args)public static void main(String [] args) {{ Integer A=new Integer(2);Integer A=new Integer(2); Integer B=new Integer(4);Integer B=new Integer(4); swap(A,B);swap(A,B); System.out.println("A="+A);System.out.println("A="+A); System.out.println("B="+B);System.out.println("B="+B); }} static void swap(Integer i,Integer j)static void swap(Integer i,Integer j) {{ Integer k;Integer k; k=i; i=j; j=k;k=i; i=j; j=k; }} }}

JAVAJAVA 将会这样运行程序将会这样运行程序 :: 先生成了先生成了 A,BA,B 的值的值 , , 分别是分别是 22 和和 44 swapswap被调用的时候被调用的时候 , , 程序首先为形参分配一个空间，再把实参复制到形程序首先为形参分配一个空间，再把实参复制到形

参中参中 ((副本副本 ). ). 此时此时 , i , i 和和 AA 同时指向了同时指向了 Integer(2)Integer(2) 的地址的地址 , j, j 和和 BB 同时同时指向了指向了 Integer(4)Integer(4) 的地址的地址 , , 不过不过 ii 与与 AA 这两变量存放在不同的内存空间这两变量存放在不同的内存空间 , , jj 与与 BB 这两变量也存放在不同的内存空间这两变量也存放在不同的内存空间

swapswap调用完后调用完后 , i, i指向了指向了 Integer(4)Integer(4) 的地址的地址 , j, j指向了指向了 Integer(2)Integer(2) 的地址的地址 ,, 这个没有错误这个没有错误 , , 也没有问题也没有问题 , , 不过不过 ii 的地址并不是的地址并不是 AA 的地址的地址 , , 所以所以 A,BA,B没有改变过没有改变过 ..

而如果是而如果是 C++C++ 使用指针进行交换使用指针进行交换 , , 那么那么 ii 和和 A A 是属于同一片内存是属于同一片内存 ,,当当 ii 和和jj 的值调换时的值调换时 , , 就是调换了就是调换了 A,BA,B 的值 的值 ( ( 即调换了即调换了 A,BA,B 所指向的内存的位置 所指向的内存的位置 ))

区别在于引用 —— 在 区别在于引用 —— 在 C++ C++ 中当传递给函数的参数是引用时，传递的中当传递给函数的参数是引用时，传递的就是这个引用，或者内存地址（按引用传递）。在 就是这个引用，或者内存地址（按引用传递）。在 Java Java 应用程序中，应用程序中，当对象引用传递给方法的一个参数时，传递的是该引用的一个副本当对象引用传递给方法的一个参数时，传递的是该引用的一个副本（按值传递），而不是引用本身。（按值传递），而不是引用本身。

实现实现 swapswap功能的原理如下功能的原理如下 : : 改变形参改变形参 (( 同时也是实参同时也是实参 )) 所指向的内存所指向的内存空间的值空间的值 . . 这样这样 ,, 方法调用结束后方法调用结束后 , , 实参所指向的内存空间的值就改实参所指向的内存空间的值就改变了变了

具体实现的时候具体实现的时候 , , 我们需要自己定义一个类我们需要自己定义一个类 IntClass IntClass 来完成任务来完成任务 , , 必必须自己定义一个类的原因是须自己定义一个类的原因是 IntegerInteger 类没有提供赋值的操作 类没有提供赋值的操作

( MethodSpecial.java)( MethodSpecial.java) public class MethodSpecialpublic class MethodSpecial {{ public static void main(String [] args)public static void main(String [] args) {{ IntClass A=new IntClass(2);IntClass A=new IntClass(2); IntClass B=new IntClass(4);IntClass B=new IntClass(4); swap(A,B);swap(A,B); System.out.println("A="+A.getNum());System.out.println("A="+A.getNum()); System.out.println("B="+B.getNum());System.out.println("B="+B.getNum()); }} static void swap(IntClass i,IntClass j)static void swap(IntClass i,IntClass j) {{ int k;int k; k=i.getNum();k=i.getNum(); i.setNum(j.getNum());i.setNum(j.getNum()); j.setNum(k);j.setNum(k); }} }} class IntClassclass IntClass {{ public int x;public int x; public IntClass(int t) {x=t;}public IntClass(int t) {x=t;} public int getNum() {return x;}public int getNum() {return x;} public void setNum(int t) {x=t;}public void setNum(int t) {x=t;} }}

String String 对象作为参数的问题对象作为参数的问题首先你要知道首先你要知道 String String 的赋值语句的工作原理的赋值语句的工作原理

String str1=“abc”; String str1=“abc”; str1=str1+“de”;str1=str1+“de”;

以上第一句执行完给以上第一句执行完给 str1 str1 指向的对象分配了空间，它的值是一个指向的对象分配了空间，它的值是一个地址地址 ,, 该地址指向了一个该地址指向了一个 StringString 对象“对象“ abc”abc”

第二句执行时，将会重新给第二句执行时，将会重新给 str1str1 指向的对象分配空间，这个对象指向的对象分配空间，这个对象是“是“ abcde”abcde”

问题在于：我们希望问题在于：我们希望 StringString 对象的形参返回给实参是不对象的形参返回给实参是不可能的！因为如果在方法中改变过可能的！因为如果在方法中改变过 StringString 对象的值，那对象的值，那么对象的内存空间已经被重新分配过，此时，实参将不再么对象的内存空间已经被重新分配过，此时，实参将不再是“新的字符串”的引用，所以，没办法把是“新的字符串”的引用，所以，没办法把 StringString 对象对象返回给实参！ （参见例子程序 返回给实参！ （参见例子程序 StringObject.javaStringObject.java））

1500

str1

abc 1900

str1

abcde

abc

为解决这个问题，为解决这个问题， JAVAJAVA 引入引入 StringBuffeStringBufferr 这个类，使用它作为形式参数不存在以上这个类，使用它作为形式参数不存在以上问题。它的类对象字符串自定义起，其对问题。它的类对象字符串自定义起，其对象在内存中的起始位置就不会改变。象在内存中的起始位置就不会改变。

它支持以下一些方法它支持以下一些方法 insert, delete, append insert, delete, append

它的例子见 （它的例子见 （ UseStringBuffer.javaUseStringBuffer.java ））

JAVAJAVA 数组数组 JAVA JAVA 数组的定义是比较特殊的数组的定义是比较特殊的 . . 这里首先讲述的是这里首先讲述的是 JAVAJAVA 数组与数组与 CC

++++ 数组定义上的不同数组定义上的不同 定义 定义 ( ( 需要需要 22 个步骤 个步骤 ))

int [ ] a; //int [ ] a; // 可以写为 可以写为 int a[ ]; int a[ ]; 不过习惯上不这样写不过习惯上不这样写 a=new int[20]; // a=new int[20]; // 分配 分配 ((实例化过程实例化过程 ))

因为数组实际是一个对象因为数组实际是一个对象 , , 所以它需要分配所以它需要分配 , , 分配的过程就是实例化的过程分配的过程就是实例化的过程数组名指向数组的基地址，即数组首元素的地址数组名指向数组的基地址，即数组首元素的地址 (( 同同 C++)C++)数组是一个对象数组是一个对象 ,, 所以可以使用所以可以使用 lengthlength 方法获得数组的长度方法获得数组的长度 ,, 如上面 如上面 a.lena.len

gth() gth() 的值为 的值为 2020

注意注意 : : 在在 JAVAJAVA 中不可以这样定义 中不可以这样定义 int a[20];int a[20];但是可以直接初始化定义 但是可以直接初始化定义 int [] b={5,8,12};int [] b={5,8,12};

使用使用 表示 表示 a[1] a[2] a[i] a[1] a[2] a[i] 使用方法和使用方法和 C++C++ 一样，这里不再叙述一样，这里不再叙述

对象数组对象数组以上讨论的是简单数据类型的数组以上讨论的是简单数据类型的数组

对象数组道理相同对象数组道理相同例如我们现在写了例如我们现在写了 ClockClock 这个类这个类

Clock [ ] Cks; //1Clock [ ] Cks; //1Cks=new Clock[12]; //2 Cks=new Clock[12]; //2 for (i=0;i<12;i++) Cks[i]=new Clock(); //3for (i=0;i<12;i++) Cks[i]=new Clock(); //3

由以上的定义可以看出由以上的定义可以看出 , , 第第 11 第第 22 行只是创建了数组行只是创建了数组 ,, 我我们还需要使用第们还需要使用第 33 行来创建对象行来创建对象 !!

注意注意 ::　数组使用　　见例子（　数组使用　　见例子（ Clocks.javaClocks.java））

二维数组定义二维数组定义int [ ][ ] matrix = new int [20][15];int [ ][ ] matrix = new int [20][15];

特殊的二维数组特殊的二维数组JAVAJAVA允许每行有不同的元素个数允许每行有不同的元素个数

int [ ][ ] b;int [ ][ ] b;b=new int [5]; // b=new int [5]; // 创建了创建了 55 行行b[0]=new int [4]; // b[0]=new int [4]; // 创建第创建第 11 行行b[1]=new int [2]; // b[1]=new int [2]; // 创建第创建第 22 行行b[2]=new int [4]; // b[2]=new int [4]; // 创建第创建第 33 行行b[3]=new int [3]; // b[3]=new int [3]; // 创建第创建第 44 行行b[4]=new int [8]; // b[4]=new int [8]; // 创建第创建第 55 行行

JAVAJAVA 中包的使用中包的使用 前面我们看到了使用前面我们看到了使用 InputStreamReaderInputStreamReader 类来输入的程类来输入的程

序中有这么一句序中有这么一句imports java.io.*imports java.io.*

这句的意义就是引入这句的意义就是引入 java.iojava.io 这个包中的类这个包中的类 InputStreamReaderInputStreamReader 类就是定义在这个包中的类就是定义在这个包中的又例如前面又例如前面 DecimalFormatDecimalFormat 类就需要引入类就需要引入 java.utiljava.util

这些包都是系统自定义的。你会发现，我们前面的程序中这些包都是系统自定义的。你会发现，我们前面的程序中有的并没有引入任何包，这又如何解释呢？这是因为系统有的并没有引入任何包，这又如何解释呢？这是因为系统中有中有 java.langjava.lang 这个包，该包是默认自动加载的。就是说这个包，该包是默认自动加载的。就是说我们所有的程序都默认加上了 我们所有的程序都默认加上了 imports java.lang.* imports java.lang.* 这句这句话。话。

Integer, Double, String, Math Integer, Double, String, Math 都基本的类都包含在都基本的类都包含在 javjava.langa.lang 这个包中。这个包中。

注注 :: 系统各个包中有什么类系统各个包中有什么类 ,, 可参见 “ 可参见 “ jdkjdk 中文版中文版 .chm ”.chm ”

下面是一些系统基本包下面是一些系统基本包 (lang)(lang) 提供的功能提供的功能Math Math 类 类 (( 用于数学计算用于数学计算 ))

Math.abs(x)Math.abs(x) Math.exp(x)Math.exp(x) Math.log(x)Math.log(x) Math.min(x,y)Math.min(x,y) Math.sqrt(x)Math.sqrt(x) Math.sin(x)Math.sin(x)

Character Character 类 （处理字符）类 （处理字符） Character.isDight(ch)Character.isDight(ch) Character.isLetter(ch)Character.isLetter(ch) Character.isLowerCase(ch)Character.isLowerCase(ch) Character.toLowerCase(ch)Character.toLowerCase(ch)

创建自己的包创建自己的包 包的程序也是包的程序也是 javajava 源代码，它的第一行为下面形源代码，它的第一行为下面形

式式 package package 包名包名

例如我们要写一个包例如我们要写一个包 ,, 包名为包名为 computecompute ，包中有，包中有一个一个 PlusPlus 类类 , , 该类提供一个方法计算该类提供一个方法计算 22 个数的和个数的和的功能，代码如下：（的功能，代码如下：（ Plus.javaPlus.java））

package compute;package compute;public class Pluspublic class Plus{{

public static int plus(int a ,int b){return apublic static int plus(int a ,int b){return a+b;}+b;}

}}

现在我们来使用刚才自定义的包现在我们来使用刚才自定义的包代码如下：代码如下： ( Invoke.java )( Invoke.java )import compute.Plus; import compute.Plus; public class Invoke{public class Invoke{

public static void main(String [] args) {public static void main(String [] args) {System.out.println(Plus.plus(3,6));System.out.println(Plus.plus(3,6));

}}}}程序第一行是引入了程序第一行是引入了 computecompute 包的包的 PlusPlus 类，也可以写类，也可以写成这样的形式： 成这样的形式： import compute.*import compute.*

写完代码，编译包需要按如下方法来做：写完代码，编译包需要按如下方法来做：建立一个以包名为名称的文件夹建立一个以包名为名称的文件夹 ,,并把包的并把包的 javajava源代码源代码 COPYCOPY 到这个文件夹下到这个文件夹下编译主文件时要加上一个参数 –编译主文件时要加上一个参数 – dd

我们上面的例子的编译过程如下我们上面的例子的编译过程如下 我现在我现在 C:\javaC:\java 下放着下放着 Invoke.java . Invoke.java . 创建创建 computecompute 目录目录 ,,把把 Plus.java Plus.java 放在 放在 C:\java\compute\C:\java\compute\ 目录下目录下

编译指令如下编译指令如下 : : C:\java\ javac –d . Invoke.javaC:\java\ javac –d . Invoke.java参数–参数– d d 后面跟着一个点后面跟着一个点 , , 表示在当前目录下寻找包表示在当前目录下寻找包

编译完就可以使用下面的语句运行编译完就可以使用下面的语句运行 ::C:\java\java InvokeC:\java\java Invoke

第３章　类第３章　类

第３章　类第３章　类本章将讲述本章将讲述 JAVAJAVA 的类，具体包括以下内容：的类，具体包括以下内容：

类定义类定义 类继承类继承 抽象类抽象类 接口接口

类定义类定义定义形式定义形式 (public) class ClassName(public) class ClassName {{

类成员 …类成员 … }}在一个文件中在一个文件中 ,, 只能有一个类声明为只能有一个类声明为 public, public, 这个类名这个类名

与文件名相同与文件名相同，如果多个类声明为，如果多个类声明为 public,public, 编译将不能编译将不能通过通过

注注 : : 整个类定义的部分有一个代码演示整个类定义的部分有一个代码演示((详见详见 Clocks.java)Clocks.java)

类的使用类的使用 , , 注意类是对象数据类型注意类是对象数据类型 , , 所以所以它们申它们申请的变量是引用变量请的变量是引用变量

(Clocks.java (Clocks.java 中的中的 ClockClock 类定义类定义 )) class Clockclass Clock {{ public int h,m,s;public int h,m,s; public Clock() { System.out.println("Creation!"); h=m=s=0;}public Clock() { System.out.println("Creation!"); h=m=s=0;} public void finalize() {System.out.println(“Decreation!”);} public void finalize() {System.out.println(“Decreation!”);}

////析构析构 public String toString() {String st=""+h+":"+m+":"+s; return spublic String toString() {String st=""+h+":"+m+":"+s; return s

t;}t;}

public void showTime() {System.out.println(""+h+m+s);}public void showTime() {System.out.println(""+h+m+s);} public void setH(int hour) {this.h=hour;}public void setH(int hour) {this.h=hour;} public void setM(int mins) {this.m=mins;}public void setM(int mins) {this.m=mins;} public void setS(int secs) {this.s=secs;}public void setS(int secs) {this.s=secs;} public void setTime(int h,int m,int s) {setH(h); setM(m); setSpublic void setTime(int h,int m,int s) {setH(h); setM(m); setS

(s);}(s);} }} 可以看出可以看出 ,, 和和 C++C++ 是非常相象的是非常相象的 , , 但是一般每个变量但是一般每个变量 ,,每个方法前都加了每个方法前都加了 pp

ublic,privateublic,private等来修饰等来修饰

使用类使用类 public class Clockspublic class Clocks {{ public static void main(String [] args)public static void main(String [] args) {{ Clock [] cks;Clock [] cks; cks=new Clock[10]; // cks=new Clock[10]; // 这是对数组的初始化这是对数组的初始化 int i;int i;

// // 下面是对对象的初始化下面是对对象的初始化 for (i=0;i<10;i++) cks[i]=new Clock();for (i=0;i<10;i++) cks[i]=new Clock();

cks[4].setTime(3,32,8);cks[4].setTime(3,32,8); for (i=0;i<10;i++) System.out.println(cks[i]);for (i=0;i<10;i++) System.out.println(cks[i]); }} }}

类成员类成员 它可以是一个变量它可以是一个变量 它可以是一个方法 它可以是一个方法 (( 方法可以重载方法可以重载 , , 规则与规则与 C++C++ 一一

致致 )) 类成员的修饰语类成员的修饰语

public public 公有的 可以在类外部访问公有的 可以在类外部访问 private private 私有的 不能在类外部访问私有的 不能在类外部访问 protected protected 受保护的 用于继承受保护的 用于继承 static static 静态的静态的 abstract abstract 抽象的抽象的 final final 常数常数

特殊的方法特殊的方法 复制构造函数复制构造函数 : : 方法名与类名相同的方法方法名与类名相同的方法 , , 与与 C++C++ 的的拷贝构造函数一样拷贝构造函数一样

finalize finalize 方法方法 : : 它与它与 C++C++ 的析构函数的意义是一样的的析构函数的意义是一样的 ,, 一个类最多只能有一个一个类最多只能有一个 finalizefinalize 方法方法

toString toString 方法方法 : : 系统会为每个类自己添加这样一个方系统会为每个类自己添加这样一个方法法 , , 它用在一些需要转换的场合它用在一些需要转换的场合 , , 例如用例如用 printlnprintln 方方法输出一个对象时法输出一个对象时 ,, 系统就会自动调用这个方法系统就会自动调用这个方法 . . 如果如果不重载这个方法，直接调用系统的方法可能会有意想不重载这个方法，直接调用系统的方法可能会有意想不到的后果不到的后果 , , 所以一般需要重载这个方法所以一般需要重载这个方法

静态方法静态方法 我们以前用过 我们以前用过 Integer.parseInt Integer.parseInt 这样的方法这样的方法 ,, 它就是它就是 IntegerInteger 类类

的静态方法的静态方法 , , 静态方法可以在不创建类实例对象的情况下直接使静态方法可以在不创建类实例对象的情况下直接使用用

在我们定义的类方法的题头中在我们定义的类方法的题头中 ,, 加入修饰语加入修饰语 staticstatic ，就可以定义，就可以定义为静态成员为静态成员 ,, 如如 ::

public static void MethodName();public static void MethodName(); 静态数据成员和静态方法可以通过类名来访问静态数据成员和静态方法可以通过类名来访问 静态方法可以访问静态数据成员静态方法可以访问静态数据成员 ,, 不可以访问非静态的数据成员不可以访问非静态的数据成员 , , 否则编译将不能通过否则编译将不能通过

其原理与其原理与 C++C++ 的一致的一致 this this 引用引用

this this 是指向类对象本身的引用是指向类对象本身的引用 与与 C++C++ 基本一样基本一样 , , 只不过将只不过将 C++C++ 中的 “中的 “ ->”->” 运算符改为 “运算符改为 “ .” .”

运算符运算符

类继承类继承 JAVA JAVA 类继承为单继承类继承为单继承 , , 不可以同时从多不可以同时从多

个类中派生个类中派生 被继承的类在被继承的类在 JAVAJAVA 中被称为“超类”，中被称为“超类”，继承别的类的类叫做“子类”继承别的类的类叫做“子类”

类继承中的方法类继承中的方法 构造函数构造函数 : : 子类调用超类的构造函数子类调用超类的构造函数 ,, 使用 使用 super()super()

参数列表是超类构造函数的形参列表参数列表是超类构造函数的形参列表 ,, 而且必须出现在子类构而且必须出现在子类构造函数的第一句造函数的第一句

方法重写方法重写 : : 子类中定义的方法与超类完全一致子类中定义的方法与超类完全一致 (( 包括方包括方法名和形参列表都一样法名和形参列表都一样 ))

方法重载方法重载 :: 子类中定义的方法与超类的某个方法的名称子类中定义的方法与超类的某个方法的名称一样一样 ,,但参数不同但参数不同

若要调用超类中的方法若要调用超类中的方法 , , 需要使用 “需要使用 “ super.super. 方法名”方法名”的形式进行调用的形式进行调用

( ( 参见 参见 ShowClass.java , ShowClass.java , 代码较长代码较长 ,, 没有贴出没有贴出 ,, 代码中代码中有必要的注释有必要的注释 ))

超类与子类的对象超类与子类的对象 JAVAJAVA默认使用动态绑定默认使用动态绑定 例子例子

Rectangle Rectangle 是超类是超类 , , 它有一个方法 它有一个方法 printfprintf Box Box 是其子类 是其子类 , , 它重写了超类的方法 它重写了超类的方法 printfprintf 那么那么 ::

Box b=new Box(11,22,33);Box b=new Box(11,22,33);Rectangle r;Rectangle r;r=b; //r=b; //超类类型的引用变量可指向其子类的对象超类类型的引用变量可指向其子类的对象r.printf(); // r.printf(); // 将执行将执行 b b 这个对象的这个对象的 printf printf

父类指针指向子类对象父类指针指向子类对象 ,,此时执行的方法将是子类所定义的方此时执行的方法将是子类所定义的方法法 , , 这就是动态绑定这就是动态绑定 (C++(C++默认是静态绑定默认是静态绑定 ))

抽象类抽象类 抽象方法和抽象类抽象方法和抽象类

仅声明了题头而没有主体的方法叫“抽象方法”，使用仅声明了题头而没有主体的方法叫“抽象方法”，使用 absabstract tract 关键字进行声明关键字进行声明

一个类包含抽象方法，它必须声明为抽象类一个类包含抽象方法，它必须声明为抽象类 不能实例化抽象类类型的对象，仅能声明引用变量不能实例化抽象类类型的对象，仅能声明引用变量

下面是一个简单的抽象类的例子下面是一个简单的抽象类的例子public abstract class AbsClasspublic abstract class AbsClass{{

public abstract void AbsPrint();public abstract void AbsPrint();}}

(UseAbsClass.java )(UseAbsClass.java )

abstract class AbsClass // abstract class AbsClass // 抽象类抽象类 {{ public abstract void AbsPrint(); //public abstract void AbsPrint(); // 定义抽象方法定义抽象方法 }}

class kk extends AbsClass // class kk extends AbsClass // 一个类对抽象进行扩展一个类对抽象进行扩展 {{ public void AbsPrint() // public void AbsPrint() // 对抽象方法进行重写对抽象方法进行重写 {System.out.println("This is the use of Abstract Class");};{System.out.println("This is the use of Abstract Class");}; }}

public class UseAbsClasspublic class UseAbsClass {{ public static void main(String [] args)public static void main(String [] args) {{

// // 使用使用 kk b=new kk();kk b=new kk(); b.AbsPrint();b.AbsPrint(); }} }}

接口接口 接口（接口（ interfaceinterface ））

由于由于 JAVAJAVA 不能实现多继承，所以引入了接口。不能实现多继承，所以引入了接口。 JAVAJAVA允许类实允许类实现多个接口，实际上相当于是现多个接口，实际上相当于是 JAVAJAVA实现多继承的方式实现多继承的方式

接口其实就是仅包含抽象方法（只有题头）的类，必须由继承着接口其实就是仅包含抽象方法（只有题头）的类，必须由继承着是实现是实现

它不能被实例化它不能被实例化 , , 用用 implementsimplements 来实现它来实现它 一个定义一个定义

public interface WListener // public interface WListener // 接口定义接口定义{{

public void MethodName(); // public void MethodName(); // 方法定义方法定义}}public class InterFaceClass implements WListener // public class InterFaceClass implements WListener // 接口接口实现实现{ … { … 在这里实现 在这里实现 MethodName() MethodName() 方法 方法 }}

等我以后找到合适的例子再给出等我以后找到合适的例子再给出

第四章 其他操作第四章 其他操作

主要包括了以下内容主要包括了以下内容 文件操作文件操作 异常捕捉异常捕捉

文件操作文件操作 文件输入与键盘输入很相似，区别仅使用文件输入与键盘输入很相似，区别仅使用

的类不是的类不是 InputStreamReaderInputStreamReader 而是而是 FileRFileReadereader ，其它都一样，其它都一样

文件输出使用的类是文件输出使用的类是 FileWriter FileWriter 与 与 PrintPrintWriterWriter

这部分很简单，请直接看代码这部分很简单，请直接看代码 (FileOp.jav(FileOp.java)a)

异常捕获异常捕获 可以用下面的语句块来捕获程序异常可以用下面的语句块来捕获程序异常

try {}try {}catch (Exception 1 )catch (Exception 1 ) {}{}catch (Exception 2 )catch (Exception 2 ) {}{}

……catch (Exception n)catch (Exception n) {}{}finally{}finally{}

在在 trytry块中如果发生异常，则块中如果发生异常，则 trytry块剩余的语句将不会被块剩余的语句将不会被执行。如果有执行。如果有 catchcatch块与之对应，则跳转执行对应的块与之对应，则跳转执行对应的 ccatchatch块的代码。最后块的代码。最后 finallyfinally块的代码一定会被执行。块的代码一定会被执行。

常见的常见的 ExceptionException 大类型大类型ArithmeticException ArithmeticException 数学运算错误数学运算错误NumberFormatException NumberFormatException 格式错误格式错误IOException IOIOException IO 错误错误

可以使用 可以使用 printStackTrace() printStackTrace() 方法来得知哪个地方出错方法来得知哪个地方出错 具体参见代码 具体参见代码

UseExRead1.java // UseExRead1.java // 异常演示 作除法异常演示 作除法UseExRead2.java //UseExRead2.java // 使用了 使用了 instanceof instanceof

和 和 eRef.prieRef.printStackTracentStackTrace

UseExThrow.java // UseExThrow.java // 抛出异常的使用抛出异常的使用由于代码较多由于代码较多 , , 就没有贴在这里就没有贴在这里

第五章 第五章 GUIGUI

本章内容：本章内容： GUIGUI 输入输出框输入输出框 最简单的窗口应用程序最简单的窗口应用程序

GUIGUI 输入输出框输入输出框 使用 使用 JOptionPane JOptionPane 类，位于类，位于 javax.swingjavax.swing 包中包中 显示输入框显示输入框

name=JOptionPane.showInputDialog("Enter your namname=JOptionPane.showInputDialog("Enter your name");e");

显示输出框显示输出框JOptionPane.showMessageDialog(JOptionPane.showMessageDialog(父窗口，父窗口， Msg, Title, Msg, Title, Type)Type)

Type Type 一般可以选择以下的某一种一般可以选择以下的某一种 JOptionPane.ERROR_MESSAGE JOptionPane.ERROR_MESSAGE 一个“一个“ X”X”或者一或者一横横

JOptionPane.INFORMATION_MESSAGE JOptionPane.INFORMATION_MESSAGE 一个 “一个 “ i”i” JOptionPane.PLAIN_MESSAGE JOptionPane.PLAIN_MESSAGE 不带图标不带图标 JOptionPane.QUESTION_MESSAGE JOptionPane.QUESTION_MESSAGE 一个问号一个问号 JOptionPane.WARNING_MESSAGE JOptionPane.WARNING_MESSAGE 一个叹号一个叹号

见代码 见代码 SomeBox.javaSomeBox.java

最简单的窗口应用程序最简单的窗口应用程序