讲义(第13讲 Java lang包)

《面向对象程序设计基础》讲义

第13讲 Java lang包

教学目标：

1、掌握String类的常用方法(已经讲过)； 2、掌握StringBuffer类的常用方法与特点； 3、掌握Date Calendar类的使用方法； 4、掌握Radom类的使用方法； 5、了解Math类的使用方法； 6、Class类的理解

教学重点：

1、Date Calendar类的使用方法；

2、掌握StringBuffer类的常用方法与特点；

教学难点：

1、Radom类的使用方法； 2、Class类的理解；

必须掌握的知识点：

淮安信息职业技术学院 面向对象程序设计基础讲义

一、讲义内容

1、String类的常用方法

String中的常用方法总结： （1）charAt()方法

（2）subString（）方法 （3）equals（）方法 （4）idexOf（）方法 （5）contains（）方法

2、StringBuffer类的常用方法

StringBuffer类和String一样，也用来代表字符串，只是由于StringBuffer的内部实现方式和String不同，所以StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用StringBuffer要更加适合一些。

1、StringBuffer对象的初始化 StringBuffer s = new StringBuffer();

StringBuffer s = new StringBuffer(“abc”);

这样初始化出的StringBuffer对象的内容就是字符串”abc”。

需要注意的是，StringBuffer和String属于不同的类型，也不能直接进行强制类型转换，下面的代码都是错误的：

StringBuffer s = “abc”; //赋值类型不匹配

StringBuffer s = (StringBuffer)”abc”; //不存在继承关系，无法进行强转 StringBuffer对象和String对象之间的互转的代码如下： String s = “abc”;

StringBuffer sb1 = new StringBuffer(“123”);

StringBuffer sb2 = new StringBuffer(s); //String转换为StringBuffer String s1 = sb1.toString(); //StringBuffer转换为String

2、StringBuffer的常用方法

StringBuffer类中的方法主要偏重于对于字符串的变化，例如追加、插入和删除等，这个也是StringBuffer和String类的主要区别。

a、append方法

public StringBuffer append(boolean b)

该方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer对象的内容也发生改变，例如：

StringBuffer sb = new StringBuffer(“abc”); sb.append(true);

淮安信息职业技术学院 面向对象程序设计基础讲义

则对象sb的值将变成”abctrue”。

使用该方法进行字符串的连接，将比String更加节约内容，例如应用于数据库SQL语句的连接，例如：

StringBuffer sb = new StringBuffer(); String user = “test”; String pwd = “123”;

sb.append(“select * from userInfo where username=“) .append(user)

.append(“ and pwd=”) .append(pwd);

这样对象sb的值就是字符串“select * from userInfo where username=test and pwd=123”。 b、deleteCharAt方法

public StringBuffer deleteCharAt(int index)

该方法的作用是删除指定位置的字符，然后将剩余的内容形成新的字符串。例如： StringBuffer sb = new StringBuffer(“Test”); sb. deleteCharAt(1);

该代码的作用删除字符串对象sb中索引值为1的字符，也就是删除第二个字符，剩余的内容组成一个新的字符串。所以对象sb的值变为”Tst”。

还存在一个功能类似的delete方法：

public StringBuffer delete(int start,int end)

该方法的作用是删除指定区间以内的所有字符，包含start，不包含end索引值的区间。例如：

StringBuffer sb = new StringBuffer(“TestString”); sb. delete (1,4);

该代码的作用是删除索引值1(包括)到索引值4(不包括)之间的所有字符，剩余的字符形成新的字符串。则对象sb的值是”TString”。

c、insert方法

public StringBuffer insert(int offset, boolean b)

该方法的作用是在StringBuffer对象中插入内容，然后形成新的字符串。例如： StringBuffer sb = new StringBuffer(“TestString”); sb.insert(4,false);

该示例代码的作用是在对象sb的索引值4的位置插入false值，形成新的字符串，则执行以后对象sb的值是”TestfalseString”。

d、reverse方法

public StringBuffer reverse()

该方法的作用是将StringBuffer对象中的内容反转，然后形成新的字符串。例如： StringBuffer sb = new StringBuffer(“abc”); sb.reverse();

经过反转以后，对象sb中的内容将变为”cba”。 e、setCharAt方法

public void setCharAt(int index, char ch)

该方法的作用是修改对象中索引值为index位置的字符为新的字符ch。例如： StringBuffer sb = new StringBuffer(“abc”); sb.setCharAt(1,’D’);

淮安信息职业技术学院 面向对象程序设计基础讲义

则对象sb的值将变成”aDc”。 f、trimToSize方法

public void trimToSize()

该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费。

总之，在实际使用时，String和StringBuffer各有优势和不足，可以根据具体的使用环境，选择对应的类型进行使用。

3、Date calendar

Date类

在JDK1.0中，Date类是唯一的一个代表时间的类，但是由于Date类不便于实现国际化，所以从JDK1.1版本开始，推荐使用Calendar类进行时间和日期处理。这里简单介绍一下Date类的使用。

1、使用Date类代表当前系统时间 Date d = new Date(); System.out.println(d);

使用Date类的默认构造方法创建出的对象就代表当前时间，由于Date类覆盖了toString方法，所以可以直接输出Date类型的对象，显示的结果如下：

Sun Mar 08 16:35:58 CST 2009

在该格式中，Sun代表Sunday(周日)，Mar代表March(三月)，08代表8号，CST代表China Standard Time(中国标准时间，也就是北京时间(东八区))。

2、使用Date类代表指定的时间

Date d1 = new Date(2009-1900,3-1,9); System.out.println(d1);

使用带参数的构造方法，可以构造指定日期的Date类对象，Date类中年份的参数应该是实际需要代表的年份减去1900，实际需要代表的月份减去1以后的值。例如上面的示例代码代表就是2009年3月9号。

实际代表具体的年月日时分秒的日期对象，和这个类似。 3、获得Date对象中的信息 Date d2 = new Date(); //年份

int year = d2.getYear() + 1900; //月份

int month = d2.getMonth() + 1; //日期

int date = d2.getDate(); //小时

int hour = d2.getHours(); //分钟

int minute = d2.getMinutes(); //秒

int second = d2.getSeconds();

淮安信息职业技术学院 面向对象程序设计基础讲义

//星期几

int day = d2.getDay();

System.out.println(\"年份：\" + year); System.out.println(\"月份：\" + month); System.out.println(\"日期：\" + date); System.out.println(\"小时：\" + hour); System.out.println(\"分钟：\" + minute); System.out.println(\"秒：\" + second); System.out.println(\"星期：\" + day);

使用Date类中对应的get方法，可以获得Date类对象中相关的信息，需要注意的是使用getYear获得是Date对象中年份减去1900以后的值，所以需要显示对应的年份则需要在返回值的基础上加上1900，月份类似。在Date类中还提供了getDay方法，用于获得Date对象代表的时间是星期几，Date类规定周日是0，周一是1，周二是2，后续的依次类推。

4、Date对象和相对时间之间的互转 Date d3 = new Date(2009-1900,3-1,10); long time = 1290876532190L;

//将Date类的对象转换为相对时间 long t = d3.getTime(); System.out.println(t);

//将相对时间转换为Date类的对象 Date d4 = new Date(time); System.out.println(d4);

使用Date对象中的getTime方法，可以将Date类的对象转换为相对时间，使用Date类的构造方法，可以将相对时间转换为Date类的对象。经过转换以后，既方便了时间的计算，也使时间显示比较直观了。

5、日期的格式化 Date d = new Date();

SimpleDateFormat f = new SimpleDateFormat(\"yyyy-MM-dd\"); String t = f.format(d);

Calendar类

从JDK1.1版本开始，在处理日期和时间时，系统推荐使用Calendar类进行实现。在设计上，Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些，下面就介绍一下Calendar类的使用。

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

1、使用Calendar类代表当前时间 Calendar c = Calendar.getInstance();

由于Calendar类是抽象类，且Calendar类的构造方法是protected的，所以无法使用Calendar类的构造方法来创建对象，API中提供了getInstance方法用来创建对象。

使用该方法获得的Calendar对象就代表当前的系统时间，由于Calendar类toString实现的没有Date类那么直观，所以直接输出Calendar类的对象意义不大。

2、使用Calendar类代表指定的时间

淮安信息职业技术学院 面向对象程序设计基础讲义

Calendar c1 = Calendar.getInstance(); c1.set(2009, 3 - 1, 9);

使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

set方法的声明为：

public final void set(int year,int month,int date) 以上示例代码设置的时间为2009年3月9日，其参数的结构和Date类不一样。Calendar类中年份的数值直接书写，月份的值为实际的月份值减1，日期的值就是实际的日期值。

如果只设定某个字段，例如日期的值，则可以使用如下set方法： public void set(int field,int value)

在该方法中，参数field代表要设置的字段的类型，常见类型如下： Calendar.YEAR——年份 Calendar.MONTH——月份 Calendar.DATE——日期

Calendar.DAY_OF_MONTH——日期，和上面的字段完全相同 Calendar.HOUR——12小时制的小时数

Calendar.HOUR_OF_DAY——24小时制的小时数 Calendar.MINUTE——分钟 Calendar.SECOND——秒

Calendar.DAY_OF_WEEK——星期几

后续的参数value代表，设置成的值。例如：

c1.set(Calendar.DATE,10);

该代码的作用是将c1对象代表的时间中日期设置为10号，其它所有的数值会被重新计算，例如星期几以及对应的相对时间数值等。

3、获得Calendar类中的信息

//年份 int year = c2.get(Calendar.YEAR);

//月份 int month = c2.get(Calendar.MONTH) + 1; //日期 int date = c2.get(Calendar.DATE);

//小时 int hour = c2.get(Calendar.HOUR_OF_DAY); //分钟 int minute = c2.get(Calendar.MINUTE); //秒 int second = c2.get(Calendar.SECOND); //星期几int day = c2.get(Calendar.DAY_OF_WEEK); System.out.println(\"年份：\" + year); System.out.println(\"月份：\" + month); System.out.println(\"日期：\" + date); System.out.println(\"小时：\" + hour); System.out.println(\"分钟：\" + minute); System.out.println(\"秒：\" + second); System.out.println(\"星期：\" + day);

淮安信息职业技术学院 面向对象程序设计基础讲义

使用Calendar类中的get方法可以获得Calendar对象中对应的信息，get方法的声明如下：

public int get(int field)

其中参数field代表需要获得的字段的值，字段说明和上面的set方法保持一致。需要说明的是，获得的月份为实际的月份值减1，获得的星期的值和Date类不一样。在Calendar类中，周日是1，周一是2，周二是3，依次类推。

4、其它方法说明

其实Calendar类中还提供了很多其它有用的方法，下面简单的介绍几个常见方法的使用。

a、add方法

public abstract void add(int field,int amount)

该方法的作用是在Calendar对象中的某个字段上增加或减少一定的数值，增加是amount的值为正，减少时amount的值为负。

例如在计算一下当前时间100天以后的日期，代码如下： Calendar c3 = Calendar.getInstance(); c3.add(Calendar.DATE, 100);

int year1 = c3.get(Calendar.YEAR); //月份

int month1 = c3.get(Calendar.MONTH) + 1; //日期

int date1 = c3.get(Calendar.DATE);

System.out.println(year1 + \"年\" + month1 + \"月\" + date1 + \"日\");

这里add方法是指在c3对象的Calendar.DATE，也就是日期字段上增加100，类内部会重新计算该日期对象中其它各字段的值，从而获得100天以后的日期，例如程序的输出结果可能为：

2009年6月17日 b、after方法

public boolean after(Object when)

该方法的作用是判断当前日期对象是否在when对象的后面，如果在when对象的后面则返回true，否则返回false。例如：

Calendar c4 = Calendar.getInstance(); c4.set(2009, 10 - 1, 10);

Calendar c5 = Calendar.getInstance(); c5.set(2010, 10 - 1, 10); boolean b = c5.after(c4); System.out.println(b);

在该示例代码中对象c4代表的时间是2009年10月10号，对象c5代表的时间是2010年10月10号，则对象c5代表的日期在c4代表的日期之后，所以after方法的返回值是true。

另外一个类似的方法是before，该方法是判断当前日期对象是否位于另外一个日期对象

淮安信息职业技术学院 面向对象程序设计基础讲义

之前。

c、getTime方法

public final Date getTime()

该方法的作用是将Calendar类型的对象转换为对应的Date类对象，两者代表相同的时间点。

类似的方法是setTime，该方法的作用是将Date对象转换为对应的Calendar对象，该方法的声明如下：

public final void setTime(Date date) 转换的示例代码如下：

Date d = new Date();

Calendar c6 = Calendar.getInstance(); //Calendar类型的对象转换为Date对象 Date d1 = c6.getTime();

//Date类型的对象转换为Calendar对象 Calendar c7 = Calendar.getInstance(); c7.setTime(d);

应用示例

下面以两个简单的示例介绍时间和日期处理的基本使用。 1、计算两个日期之间相差的天数

例如计算2010年4月1号和2009年3月11号之间相差的天数，则可以使用时间和日期处理进行计算。

该程序实现的原理为：首先代表两个特定的时间点，这里使用Calendar的对象进行代表，然后将两个时间点转换为对应的相对时间，求两个时间点相对时间的差值，然后除以1天的毫秒数(24小时X60分钟X60秒X1000毫秒)即可获得对应的天数。实现该示例的完整代码如下：

import java.util.*;

public class DateExample1 {

public static void main(String[] args) { //设置两个日期

//日期：2009年3月11号

Calendar c1 = Calendar.getInstance(); c1.set(2009, 3 - 1, 11); //日期：2010年4月1号

Calendar c2 = Calendar.getInstance(); c2.set(2010, 4 - 1, 1);

//转换为相对时间

long t1 = c1.getTimeInMillis(); long t2 = c2.getTimeInMillis(); //计算天数

淮安信息职业技术学院 面向对象程序设计基础讲义

long days = (t2 - t1)/(24 * 60 * 60 * 1000); System.out.println(days); } }

4、Class类

Class类编辑

Class类（在java.lang包中）：

在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。

2获取Class实例方式编辑 方法1

利用对象调用getClass()方法获取该对象的Class实例； 方法2

使用Class类的静态方法forName()，用类的名字获取一个Class实例（staticClass forName(String className) Returns the Classobject associated with the class or interface with the given stringname. ）；

方法3

运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以采用.TYPE来获取相对应的基本数据类型的Class实例

在newInstance()调用类中缺省的构造方法 ObjectnewInstance()（可在不知该类的名字的时候，创建这个类的实例） Creates a new instance of the class represented by this Classobject.

在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象

5、Radom类

Random类(Java中的随机类) 在实际的项目开发过程中，经常需要产生一些随机数值，例如网站登录中的校验数字等，或者需要以一定的几率实现某种效果，例如游戏程序中的物品掉落等。在Java API中，在java.util包中专门提供了一个和随机处理有关的类，这个类就是Random类。随机数字的生成相关的方法都包含在该类的内部。

Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。

相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。

下面介绍一下Random类的使用，以及如何生成指定区间的随机数组以及实现程序中要

淮安信息职业技术学院 面向对象程序设计基础讲义

求的几率。

1、Random对象的生成

Random类包含两个构造方法，下面依次进行介绍： a、public Random()

该构造方法使用一个和当前系统时间对应的相对时间有关的数字作为种子数，然后使用这个种子数构造Random对象。

b、public Random(long seed)

该构造方法可以通过制定一个种子数进行创建。 示例代码：

Random r = new Random(); Random r1 = new Random(10);

再次强调：种子数只是随机算法的起源数字，和生成的随机数字的区间无关。 2、Random类中的常用方法

Random类中的方法比较简单，每个方法的功能也很容易理解。需要说明的是，Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率是均等的。下面对这些方法做一下基本的介绍：

a、public boolean nextBoolean()

该方法的作用是生成一个随机的boolean值，生成true和false的值几率相等，也就是都是50%的几率。

b、public double nextDouble()

该方法的作用是生成一个随机的double值，数值介于[0,1.0)之间，这里中括号代表包含区间端点，小括号代表不包含区间端点，也就是0到1之间的随机小数，包含0而不包含1.0。

c、public int nextInt()

该方法的作用是生成一个随机的int值，该值介于int的区间，也就是-231到231-1之间。 如果需要生成指定区间的int值，则需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。

d、public int nextInt(int n)

该方法的作用是生成一个随机的int值，该值介于[0,n)的区间，也就是0到n之间的随机int值，包含0而不包含n。

如果想生成指定区间的int值，也需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。

e、public void setSeed(long seed)

该方法的作用是重新设置Random对象中的种子数。设置完种子数以后的Random对象和相同种子数使用new关键字创建出的Random对象相同。

3、Random类使用示例

使用Random类，一般是生成指定区间的随机数字，下面就一一介绍如何生成对应区间的随机数字。以下生成随机数的代码均使用以下Random对象r进行生成：

Random r = new Random(); a、生成[0,1.0)区间的小数

double d1 = r.nextDouble(); 直接使用nextDouble方法获得。 b、生成[0,5.0)区间的小数

double d2 = r.nextDouble() * 5;

淮安信息职业技术学院 面向对象程序设计基础讲义

因为nextDouble方法生成的数字区间是[0,1.0)，将该区间扩大5倍即是要求的区间。 同理，生成[0,d)区间的随机小数，d为任意正的小数，则只需要将nextDouble方法的返回值乘以d即可。

c、生成[1,2.5)区间的小数

double d3 = r.nextDouble() * 1.5 + 1;

生成[1,2.5)区间的随机小数，则只需要首先生成[0,1.5)区间的随机数字，然后将生成的随机数区间加1即可。

同理，生成任意非从0开始的小数区间[d1,d2)范围的随机数字(其中d1不等于0)，则只需要首先生成[0,d2-d1)区间的随机数字，然后将生成的随机数字区间加上d1即可。

d、生成任意整数

int n1 = r.nextInt(); 直接使用nextInt方法即可 e、生成[0,10)区间的整数 int n2 = r.nextInt(10);

n2 = Math.abs(r.nextInt() % 10);

以上两行代码均可生成[0,10)区间的整数。第一种实现使用Random类中的nextInt(int n)方法直接实现。

第二种实现中，首先调用nextInt()方法生成一个任意的int数字，该数字和10取余以后生成的数字区间为(-10,10)，因为按照数学上的规定余数的绝对值小于除数，然后再对该区间求绝对值，则得到的区间就是[0,10)了。

同理，生成任意[0,n)区间的随机整数，都可以使用如下代码： int n2 = r.nextInt(n);

n2 = Math.abs(r.nextInt() % n); f、生成[0,10]区间的整数 int n3 = r.nextInt(11);

n3 = Math.abs(r.nextInt() % 11);

相对于整数区间，[0,10]区间和[0,11)区间等价，所以即生成[0,11)区间的整数。 g、生成[-3,15)区间的整数 int n4 = r.nextInt(18) - 3;

n4 = Math.abs(r.nextInt() % 18) - 3; 生成非从0开始区间的随机整数，可以参看上面非从0开始的小数区间实现原理的说明。 h、几率实现

按照一定的几率实现程序逻辑也是随机处理可以解决的一个问题。下面以一个简单的示例演示如何使用随机数字实现几率的逻辑。

在前面的方法介绍中，nextInt(int n)方法中生成的数字是均匀的，也就是说该区间内部的每个数字生成的几率是相同的。那么如果生成一个[0,100)区间的随机整数，则每个数字生成的几率应该是相同的，而且由于该区间中总计有100个整数，所以每个数字的几率都是1%。按照这个理论，可以实现程序中的几率问题。

示例：随机生成一个整数，该整数以55%的几率生成1，以40%的几率生成2，以5%的几率生成3。实现的代码如下：

int n5 = r.nextInt(100); int m; //结果数字

if(n5 < 55){ //55个数字的区间，55%的几率 m = 1;

淮安信息职业技术学院 面向对象程序设计基础讲义

}else if(n5 < 95){//[55,95)，40个数字的区间，40%的几率 m = 2; }else{

m = 3; }

因为每个数字的几率都是1%，则任意55个数字的区间的几率就是55%，为了代码方便书写，这里使用[0,55)区间的所有整数，后续的原理一样。

当然，这里的代码可以简化，因为几率都是5%的倍数，所以只要以5%为基础来控制几率即可，下面是简化的代码实现：

int n6 = r.nextInt(20); int m1; if(n6 < 11){ m1 = 1;

}else if(n6 < 19){ m1= 2; }else{ m1 = 3; }

在程序内部，几率的逻辑就可以按照上面的说明进行实现。 4、其它问题

a、相同种子数Random对象问题

前面介绍过，相同种子数的Random对象，相同次数生成的随机数字是完全相同的，下面是测试的代码：

Random r1 = new Random(10); Random r2 = new Random(10); for(int i = 0;i < 2;i++){

System.out.println(r1.nextInt()); System.out.println(r2.nextInt()); }

在该代码中，对象r1和r2使用的种子数都是10，则这两个对象相同次数生成的随机数是完全相同的。

如果想避免出现随机数字相同的情况，则需要注意，无论项目中需要生成多少个随机数字，都只使用一个Random对象即

b、关于Math类中的random方法

其实在Math类中也有一个random方法，该random方法的工作是生成一个[0,1.0)区间的随机小数。

通过阅读Math类的源代码可以发现，Math类中的random方法就是直接调用Random类中的nextDouble方法实现的。

只是random方法的调用比较简单，所以很多程序员都习惯使用Math类的random方法来生成随机数字

淮安信息职业技术学院 面向对象程序设计基础讲义

6、java.lang.object

Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类。 可以使用类型为Object的变量指向任意类型的对象。

Object类有一个默认构造方法pubilc Object()，在构造子类实例时，都会先调用这个默认构造方法。

Object类的变量只能用作各种值的通用持有者。要对他们进行任何专门的操作，都需要知道它们的原始类型并进行类型转换。例如：

Object obj = new MyObject(); MyObject x = (MyObject)obj;

Object()

默认构造方法 clone()

创建并返回此对象的一个副本。 equals(Object obj)

指示某个其他对象是否与此对象“相等”。 finalize()

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 getClass()

返回一个对象的运行时类。 hashCode()

返回该对象的哈希码值。 notify()

唤醒在此对象监视器上等待的单个线程。 notifyAll()

唤醒在此对象监视器上等待的所有线程。 toString()

返回该对象的字符串表示。 wait()

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。 wait(long timeout)

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。

wait(long timeout, int nanos)

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

3方法使用说明编辑

1、equals()方法：用于测试某个对象是否同另一个对象相等。它在Object类中的实现是判断两个对象是否指向同一块内存区域。这种测试用处不大，因为即使内容相同的对象，内

淮安信息职业技术学院 面向对象程序设计基础讲义

存区域也是不同的。如果想测试对象是否相等，就需要覆盖此方法，进行更有意义的比较。例如

class Employee{

... //此例子来自《java核心技术》卷一 public boolean equals(Object otherObj){ //快速测试是否是同一个对象 if(this == otherObj) return true;

//如果显式参数为null，必须返回false if(otherObj == null) reutrn false; //如果类不匹配，就不可能相等

if(getClass() != otherObj.getClass()) return false;

//现在已经知道otherObj是个非空的Employee对象 Employee other = (Employee)otherObj; //测试所有的字段是否相等 return name.equals(otherName) && salary == other.salary

&& hireDay.equals(other.hireDay); } }