第七章 常用工具一,Java的类库二、数组和向量类三、字符串一,Java的类库类库：系统中的标准类根据实现功能的不同，可以分成不同的集合，每个集合是一个包，
合称类库。
1,Java的类库结构：
（ 1） Java的几个版本并非完全地向下兼容
（ 2）根据功能的不同,Java的类库被划分成若干不同的包，每个包中都有若干个具有特定功能和相互关系的类和接口
（ 3）要想在程序中使用 Java的类库，只需用 import语句将相关的包加载到程序中基本类 图形接口类 数据库类 网络程序设计类 其他
java.lang
java.io
java.math
java.util
java.text
java.awt
javax.swing
java.applet
java.sql java.net
java.security
java.servlet
java.rmi
java.beans
java.corba
常使用的包：
（ 1） Java.lang包
Java.lang包为 Java基本数据类型提供了 字符串、线程和包装类 。
注意,你可以使用此包中的类和接口，而不用限定它们的名称或者使用 import语句
java.lang.Clonealbe接口 实现了此类的定义意味着可以使用 Object.clone()方法
java.lang.Comparable接口 声明比较对象的方法
java.lang.Runnable 接口 声明 run方法，实现此接口可以定义一个线程的行为
Boolean,Byte,Character,Double,Float,Integer,Long,Short－处理基本数据类型的类，而这些均继承 Number这个抽象（ abstract）类 。
另外在 java.math中的两个子类,BigDecimal,BigInteger也继承
Number类 。
String,StringBuffer：处理字符串，字符串缓冲。 String为固定长度的字符串。 StringBuffer为可弹性增减长度的字符串 。
Math与 StrictMath：提供基本数学运算，像指数、对数、平方根、
三角函数等，但因版本不同而有所差异 。
Throwable-所有 Java 语言中的错误（ error）与异常（ exception）的顶层类。包含了 Error及 Exception两个次类 。
（ 2） Java.io包
Java.io包主要与文件和控制台输入 /输出有关。（ java.awt包处理 GUI的输入和输出，而 java.net处理网络的输入 /输出） File类封装了文件路径、文件名称和文件与目录的属性。要读写文件，
可以使用 FileInputStream和 FileOutputStream,然后 把该对象转换成更灵活的类型，例如 DataInputStream。 DataInputStream类也可以用来读取键盘输入。 java.io类相对较大，因为它支持许多基本的文件输入 /输出的变化
Java.io.DataInput接口 声明读取 java基本数据类型的方法
Java.io.DataOutput接口 声明写入 java基本数据类型的方法
Java.io.FilenameFilter接口 声明接受或拒绝文件名的方法，一般用于对话框中过滤输出的文件名
try{
FileInputStream fis=new FileInputStream(“stuff.dat”);
DataInputStream dis=new DataInputStream(fis)
}catch(IOException e){System.out.println(e);}
（ 3） java.util包
java.util包具有一些在程序设计中经常使用的支持类。如 Date类
Vector类,Stack类
（ 4） java.awt包
java.awt包实现了 Java抽象窗口工具包（ AWT).java.awt包含了创建一个基本用户接口所需的所用类和接口。尽管在其他包中的类也能够影响屏幕的显示，但是 java.awt包是最直接参与用户接口的问题的，
该包包括了所有的组件和窗口类，以及重要的 Event类,Graphics类
Image类
（ 5） java.applet包
Java.applet包含有一个类 (Applet)和三个支持创建 applet的接口。
Applet代码通常会使用到类 Applet。两个相关的接口 ——
AppletContext和 AppletSub——是较低级的，并且不常使用；它们必须由加载和启动 applet的应用程序（例如浏览器）实现。
Java.applet.AudioClip接口 定义声音的播放方法
Java.applet.AppletContext接口
2、语言基础类库
（ 1） Object类是唯一一个没有超类的 java公共类，作为所有 java类的根类。 Object
类定义了被所有其他类继承的通用方法。注意,Object类没有继承任何类或实现任何接口。
其中 clone(),equals(),finalize()和 toString()等几个方法通常需要被子类重载。 getCalss(),notify(),notifyAll()和 wait()在你自己的类定义中是不能取代的，它们在 Object类的定义中已经使用过关键字 final”固定
“下来了,
构造函数
Object()
方法
protected Object clone()制造和返回此对象的复制
boolean equals(Object obj)意指其他对象是否与此对象,相等,
protected void finalize()当资源回收测知对此对象无任何的参考时，由资源回收器调用此方法
Class getClass()返回对象的执行时间（ runtime）类
int hashCode()返回对象的散列码
void notify()唤醒正等待于此对象 manitor上的单一线程
void notifyAll()唤醒所有等待于此对象 manitor上的线程
String toString()返回代表此对象的字符串
void wait()使目前线程等待，直到被其他线程调用
void wait(long timeout) 使目前线程等待，直到被其他线程调用，或一定时间timeout（豪秒）过去后 。
void wait(long timeout,int nanos)使目前线程等待，直到被其他线程调用或中断，
或一定时间 nanos（秒）过去后 。
public class ObjectTest_1 {
public static void main(String[] args) {
String objname_1,objname_2;
int hashcode_1,hashcode_2;
Object obj_1= new Object();
Object obj_2= new Object();
objname_1=obj_1.toString();
objname_2=obj_2.toString();
hashcode_1=obj_1.hashCode();
hashcode_2=obj_2.hashCode();
System.out.println("对象一的名称,"+objname_1);
System.out.println("对象一的散列码,"+hashcode_1);
System.out.println("对象二的名称,"+objname_2);
System.out.println("对象二的散列码,"+hashcode_2);
System.exit(0);
}
}
范例
执行结果,
对象一的名称,
java.lang.Object@273d3c
对象一的散列码,
2571580
对象二的名称,
java.lang.Object@256a7c
对象二的散列码,
2452092
例如：确定一个对象的类型
getClass()方法 在所有类中都是由 Object类继承的，它会返回一个类型为 class的对象，识别出定义一个对象的类。假设有一个类型为 Animal的 pet变量，它可能会引用一个 Dog,Cat,Duck等类型的对象，为了找出实际是什么类型，可以编写下列语句
class objecttype=pet.getClass();
System.out.println(objecttype.getName());
对象的复制：
protected Object clone() 用来生成当前对象的一个拷贝，
并返回这个复制对象,注：只有当要复制的对象的类指出允许克隆的时候才可以进行这种操作。当该类实现了
Cloneable 接口时才能被复制。所以让一个类实现的复制所需的就是在该类定义的第一行中声明这个接口
class PetDog implements Cloneable
{
…………………..
}
Public class Test
{ public static void main(String[] args)
{ PetDog mypet=new PetDog(“fang”,”slfkjlsdfj”);
PetDog yourpet=(PetDog)mypet.clone()………………..
System
此类用来处理与系统层次有关的信息。常用到的系统调用有,标准输入输出、取得系统性质或取得现在时刻等 。这个类的 API与所在的操作系统是独立分开的,这样的好处是不用每到一个新的系统环境下，就需重新改写系统调用程序代码 。
至于与系统有关的 API,则另外放在 Runtime类中。不过只有较少的机会会用到此类 。
公有最终类,此类与 Runtime一起可以访问许多有用的系统功能。
有一些方法在两个类中都出现。 exit(),gc(),load()和 loadLibrary()可以通过调用在 Runtime中的同名方法来响应。特别有用的类变量
err,in,out，它们可以访问基本控制台 I/O。 System类完全由类域组成。
这些类域可以通过,System.变量名”和,System.方法名 ()”的方式进行访问。 此类不能被实例化实例变量,public static PrintStream err;
public static InputStream in;
public static PrintStream out;
每个变量对整个程序而言都是唯一的对象变量。这些对象可以访问到系统的输入、输出和错误输出
public class SystemTest_1 {
public static void main(String[] args) {
String name = System.getProperty("user.name");//用户姓名
String password = System.getProperty("user.password");//用户密码
String javaversion = System.getProperty("java.version");//Java版本
String javavendor = System.getProperty("java.vendor");//Java制造商
long time=System.currentTimeMillis();//毫秒数
System.out.println("用户姓名,"+name);
System.out.println("用户密码,"+password);
System.out.println("Java版本,"+javaversion);
System.out.println("Java制造商,"+javavendor);
System.out.println("现在时间 <毫秒 >:"+time);
System.exit(0);
}
}
范例数组类型数组 (array)是一种数据结构 （ data structure）,可提供存储同一类型的一群变量 。 而这些变量可用同一名称被参考到 。 数组被视为一种对象,其名称所代表的是一个参考 。
一维数组数组的声明,可用两种方式,
数据类型 [ ] 数组名；
或 数据类型 数组名 [ ]；
例如 String [] args;
或 String args[] ；
数组声明完后,可藉 new 运算符来产生真正的内存空间配置 。 但数组大小声明后不能再被改变 。
数组名＝ new 数据类型 [数组大小 ]
一维数组如 float[] tax=new float[5];
数组被声明后，其数组大小值会被放在所分配内存区的第一个地址，并以 length作此地址的参考。所以我们可用
tax.length来取得此数组的大小值 。
数组被设置数值的方法如下,
tax[0]＝ 6786.5
tax[1]＝ 8763.79
t ax
len g th (=5 )
tax [0 ]
tax [ 1 ]
tax [ 2 ]
tax [ 3 ]
tax [ 4 ]
多维数组数组也可以用,数组的数组,方式来产生多维数组 。
例如：
int number[][]=new int[3][3]；
number[0][0]=1;
number[0][1]=2;
number[0][2]=3;
number[0][0]=4;
number[0][1]=5;
number[0][2]=6;
number[0][0]=7;
number[0][1]=8;
number[0][2]=9;
若要简化上面的设置,可用一组嵌套式大括号来完成 。
int number={{1,2,3},{4,5,6},{7,8,9}};
对于多维数组，它的每一维可以具有不同的长度
int array[][]=new int[2][]
array[0]=new int[3]
array[1]=new int[7]
向量类比较适合于在如下情况下使用：
（ 1）需要处理的对象数目不定，序列中的元素都是对象或可以表示为对象。
（ 2）需要将不同类的对象组合成一个数据序列。
（ 3）需要做频繁的对象序列中元素的插入和删除。
（ 4）经常需要定位序列中的对象或其他的查找操作。
（ 5）在不同的类之间传递大量的数据也可以使用 Vector对象一 创建向量类的对象：
Vector类有三个构造函数：
public Vector( )
public Vector(int initCapacity)
public Vector(int initCapacity,int capacityIncrement )
你可以随意指定初始容量以及每次超出容量时增长的容量数例,Vector MyVector=new Vector(100,50);
二 向向量序列中添加元素
addElement( )：将新元素添加在向量序列的尾部。
insertElement(Object obj,int index ):将新元素插入在序列的指定位置
addElement(Object obj)
inserElement(Object obj,int index);
例,Vector MyVector=new Vector( );
for(int I=1;I<=10;I++)
{ String name=“部门” +Integer.toString(I);
MyVector.addElement(new Department(I,name));}
MyVector.insertElement(new ManagerEmployee(0,”总经理
“,1000,?f?,new Date( ),new Date)),0);
向量序列中的元素可以不是相同类型的对象三 修改和删除向量序列中的元素：
void setElementAt(Object obj,int index);
将向量序列 index位置处的元素设置成 obj,如这个位置原来有元素则被覆盖。
void removeElement(Object obj);
删除向量序列中第一个与指定的 obj对象相同的元素，同时将后面元素前提补上空位。
void removeElement(int index);
删除指定位置处的元素，同时将后面的元素前提。
void removeAllElement( )
删除向量序列中的所有元素。
例,Vector MyVector=new Vector(100)
for(int I=0;I<10;I++)
{ MyVector.addElement(“Welecom”);
MyVector.addElement(“to”);
MyVector.addElement(“Beijing”);
}
while(MyVector.removeElement(“to”));
四 查找向量序列中的元素
Object elementAt(int index)
在使用之前通常需要进行强制类型转换将返回的对象引用转换成 Object类的某个具体子类的对象。
String str=(Sting)MyVector.elementAt(0);
boolean contains(Object obj);
int indesOf(Object obj,int start_index) (返回找到元素的下标）
int lastIndexOf(Object obj,int start_index);
例 int I=0;
while((I=MyVector.indexOf(“Welcom”,I))!=-1)
System.out.println(I);
字符串分两类：
1 创建之后不会再做修改和变动的字符串常量 。用 String类表示
2创建之后允许做修改和变动的字符串变量。用 StringBuffer表示。
对于字符串变量，由于程序中经常需要对它做添加，插入，修改之类的操作，所以一般都存放在 StringBuffer类的对象中一 字符串常量与 String类对于 Java中的字符串常量，通常是作为 String类的对象存在着，
对于所有用双引号括起的字符串常量，系统都会缺省地为它创建一个无名的 String类的对象。
1 创建字符串常量 String对象在一般情况下，一个 String对象一经创建，无论长度和内容都不能再更改。
String类的构造函数：
public String( );
public String( Sting value);
public String( StringBuffer buffer);
public String(char valeu[] );
创建 Sring类的对象分两步：声明和创建
String s;
s=new String(“agah”);
二字符串常量的操作：
public int length( )
Sting s=“hello”;
System.out.println(s.length( ));
三 判断字符串的前缀和后缀：
public boolean startsWith(String prefix);
public boolean endsWith(String suffix);
String s=User.getPhone( );
if(s.startsWith(“48”)
假如是某位居民的身份证号码：
If(s.endsWith(“0”)||s.endsWith(“2”)||s.endsWith(“4”)||s.endsWith(“6”)||
s.endsWith(“8”))
{System.out.println(“此人是女性” );}
四 字符串的中单个字符的查找
public int indexOf(int ch)
public int indexOf(int ch,int fromIndex);
五 字符子串的查找
public int indexOf(String str);
public int indexOf(String str,int fromIndex);
public int lastIndexOf(String str);
public int lasIndexOf(String str,int fromIndex);
六 字符串的比较：
public int compareTo(String anotherString);
public boolean equal(Object anObject);
public boolean equalsIgnoreCase(String anotherString);
七 连接字符子串
public String concat(String str);
字符串变量与 StringBuffer类
StringBuffer类的每个对象都是可以扩充和修改的字符串变量
1 创建字符串变量 -------StringBuffer对象构造函数
public StringBuffer( )
public StringBuffer( int length)
public StringBuffer(String str )
说明：若希望将 StringBuffer在屏幕上显示出来，必须首先调用
toString方法把它变成字符串常量，因为 println()方法不接受
StringBuffer类型的参数。
StringBuffer MyStrBuff=new StringBuffer();
MyStrBuff.append(“hello,Guys”);
System.out.println(MyStrBuffer.toString());
Java Application 的命令行参数命令行参数是 Java Application 传入数据的常用而有效的手段
public class CommandLineParam
{ public static void main(String args[])
{ int a1,a2,a3;
if(args.length<2)
{System.out.println(“Not Enough command line parameters is prided”);
System.exit(0);}
a1=Integer.parseInt(args[0]);
a2=Ingeger.parseInt(args[1]);
a3=a1+a2;
System.out.println(a3);}}
执行时的命令行格式为
java CommandLineParam 12 34
总结：
字符串变量 (复合类型 )
java.lang包中有两种字符串类,
String类 只支持只读字符串
StringBuffer类 支持可修改字符串以 String类字符串为例,来了解字符串变量的实质。
一个字符串变量就是一个 String 对象变量。对象变量是一个 类的实例 的存储变量,即是对对象 (类的一个实例 )的引用,
声明对象变量 与 生成对象本身 是两个分离的步骤,
String s1;声明一 String类的对象变量,此时 s1值为 null.
s1=new String("right");new运算符 为对象分配内存空间,
即生成一 String类的实例 ----对象,返回对该对象的一个 引用 (即该对象的中间数据结构所在的内存地址 ).
对象的引用 是指向一中间数据结构,它存储有关数据类型的信息及当前对象所在的内存地址,而对象所在的实际内存地址是不可见不可操作的,这就保证了安全性,
此时 s1中即为该对象的中间数据结构的内存地址,
所以,对象变量只可能有两个可能的值,null或某对象引用,
同时,执行构造方法,进行初始化,
所以,对象的生成包括,
l 对象变量的声明
l 实例化
l 初始化上例也可合并为,String s1=new String("right");
String类在 JAVA中是一个特殊的类,JAVA编译器遇到带双引号的字符串时，即自动生成 String类的一个实例，因此,String类对象初始化的最简单方式可表示如下：
String s1="right";
二、数组变量（复合型变量）
数组变量也是一个对象变量，下面我们以数组对象为例，分析对象的内存模型。
程序内存的动态改变部分可以分成两个区：内存堆栈区
（ stack）和内存堆区（ hesp）,
堆栈内存区 用于存放方法或程序块中声明的局部变量。
内存堆区 是用于对象的存储内存（即对象的数据区）。用 new生成新对象时，即在堆内存区分配对象的数据存储单元。
下面我们在一段程序执行过程中，分析内存模型的变化情况。
Point类 可放置一个二维图形点的 x和 y坐标。
Point类原型：
public class java.awt.Point
extends java.lang.Object
{
public int x;
public int y;
public Point(int x,int y);
public boolean equals(Object obj);
public int hashCode();
public void move(int x,int y);
public String toString();
public void translate(int dx,int dy);
}
void m1()
{int a1=1;
Point p1; //checkpoint #1
p1=new Point(2,3); //checkpoint #2
m2(a1,p1);
a1=8; //checkpoint #5
}
void m2(int a2,Point p2)
{int a3=4;
Point p3; //checkpoint #3
p3=new Point(5,6);
a2=7; //checkpoint #4
}
到达 checkpoint #1时的内存模型：
到达 checkpoint #2时的内存模型：
到达 checkpoint #3时的内存模型：
*方法的参数类型可以是简单数据类型，也可以是引用数据类型（数组类型、类或接口）。
对于简单数据类型,JAVA实现的是值传送。
对于引用数据类型，传送的是数据在内存的地址。
到达 checkpoint #4时的内存模型：
到达 checkpoint #5时的内存模型：
*一个方法退出时，局部变量和形参变量的内存弹出堆栈区。
这使原先分配给局部变量的 对象内存 在堆中空闲（即没有向这块内存单元的引用），这个闲置对象内存由 内存单元收集程序 管理。
生成数组对象时的内存模型：
数组是一组相同类型变量的集合，变量类型既可以是基本型，也可以是对象型。数组是对象，是通过引用来操作的。将数组传递到方法中时，只传递数组对象的内存地址（准确说是中间数据结构地址）。而不是整个数组的元素。
定义数组对象变量,type ArrayName[ ]或 type[] ArrayName.
type可以是简单类型也可以是复杂类型。
第二种方式的声明更能表明数组是一个对象，是一串某种数据类型实例的引用。如,int[] day;
Point[] points;Point是一放置二维图形点的类声明 Point[] points;后的内存模型：
为数据元素分配内存空间 points=new Point[2]后的内存模型：
*每个数组对象都有一公共变量 length,用于放置数组的长度,
如,可用 points.length访问数组的长度 (元素个数 ).
初始化第一个元素 points[0]=new Point(1,2);后的内存模型,
也可以用 数组初始化程序 生成具有初始值的数组,在定义的同时初始化数组，如：
int[] values = {100,200,300,400,500}；
*数组初始化程序只能用于 数组声明 时,不能用于普通赋值语句的右边,
书写程序片段完成下面的功能
1 声明并创建一个含有 10个数据的整型数组
2 声明并创建一个含有 10个整型数据的数组，且每个数组元素的初值等于其数组下标
3 声明并创建一个数组包含 1,3,5,7四个元素
4 把数组 array的第二个元素的数值设置为 0
5 声明并创建一个 3行 4列的二维数组
6 把如下的二维数组的所有元素的值显示在屏幕上
int TwoDimArray[][]={1,2,3},{4},{5,6}}
7把二维数组 TwoDimArray的每一行的第一个元素设置为 0
8把二维数组的最后一行的所有元素的值设置为 0
9创建一个 Vector对象 myv，初始包含 10个元素
10判断 myv中是否包含 obj，否则将它添加在 myv的最后一个对象的后面
11 将 myv中所有等于 obj的元素删除
合称类库。
1,Java的类库结构：
（ 1） Java的几个版本并非完全地向下兼容
（ 2）根据功能的不同,Java的类库被划分成若干不同的包，每个包中都有若干个具有特定功能和相互关系的类和接口
（ 3）要想在程序中使用 Java的类库，只需用 import语句将相关的包加载到程序中基本类 图形接口类 数据库类 网络程序设计类 其他
java.lang
java.io
java.math
java.util
java.text
java.awt
javax.swing
java.applet
java.sql java.net
java.security
java.servlet
java.rmi
java.beans
java.corba
常使用的包：
（ 1） Java.lang包
Java.lang包为 Java基本数据类型提供了 字符串、线程和包装类 。
注意,你可以使用此包中的类和接口，而不用限定它们的名称或者使用 import语句
java.lang.Clonealbe接口 实现了此类的定义意味着可以使用 Object.clone()方法
java.lang.Comparable接口 声明比较对象的方法
java.lang.Runnable 接口 声明 run方法，实现此接口可以定义一个线程的行为
Boolean,Byte,Character,Double,Float,Integer,Long,Short－处理基本数据类型的类，而这些均继承 Number这个抽象（ abstract）类 。
另外在 java.math中的两个子类,BigDecimal,BigInteger也继承
Number类 。
String,StringBuffer：处理字符串，字符串缓冲。 String为固定长度的字符串。 StringBuffer为可弹性增减长度的字符串 。
Math与 StrictMath：提供基本数学运算，像指数、对数、平方根、
三角函数等，但因版本不同而有所差异 。
Throwable-所有 Java 语言中的错误（ error）与异常（ exception）的顶层类。包含了 Error及 Exception两个次类 。
（ 2） Java.io包
Java.io包主要与文件和控制台输入 /输出有关。（ java.awt包处理 GUI的输入和输出，而 java.net处理网络的输入 /输出） File类封装了文件路径、文件名称和文件与目录的属性。要读写文件，
可以使用 FileInputStream和 FileOutputStream,然后 把该对象转换成更灵活的类型，例如 DataInputStream。 DataInputStream类也可以用来读取键盘输入。 java.io类相对较大，因为它支持许多基本的文件输入 /输出的变化
Java.io.DataInput接口 声明读取 java基本数据类型的方法
Java.io.DataOutput接口 声明写入 java基本数据类型的方法
Java.io.FilenameFilter接口 声明接受或拒绝文件名的方法，一般用于对话框中过滤输出的文件名
try{
FileInputStream fis=new FileInputStream(“stuff.dat”);
DataInputStream dis=new DataInputStream(fis)
}catch(IOException e){System.out.println(e);}
（ 3） java.util包
java.util包具有一些在程序设计中经常使用的支持类。如 Date类
Vector类,Stack类
（ 4） java.awt包
java.awt包实现了 Java抽象窗口工具包（ AWT).java.awt包含了创建一个基本用户接口所需的所用类和接口。尽管在其他包中的类也能够影响屏幕的显示，但是 java.awt包是最直接参与用户接口的问题的，
该包包括了所有的组件和窗口类，以及重要的 Event类,Graphics类
Image类
（ 5） java.applet包
Java.applet包含有一个类 (Applet)和三个支持创建 applet的接口。
Applet代码通常会使用到类 Applet。两个相关的接口 ——
AppletContext和 AppletSub——是较低级的，并且不常使用；它们必须由加载和启动 applet的应用程序（例如浏览器）实现。
Java.applet.AudioClip接口 定义声音的播放方法
Java.applet.AppletContext接口
2、语言基础类库
（ 1） Object类是唯一一个没有超类的 java公共类，作为所有 java类的根类。 Object
类定义了被所有其他类继承的通用方法。注意,Object类没有继承任何类或实现任何接口。
其中 clone(),equals(),finalize()和 toString()等几个方法通常需要被子类重载。 getCalss(),notify(),notifyAll()和 wait()在你自己的类定义中是不能取代的，它们在 Object类的定义中已经使用过关键字 final”固定
“下来了,
构造函数
Object()
方法
protected Object clone()制造和返回此对象的复制
boolean equals(Object obj)意指其他对象是否与此对象,相等,
protected void finalize()当资源回收测知对此对象无任何的参考时，由资源回收器调用此方法
Class getClass()返回对象的执行时间（ runtime）类
int hashCode()返回对象的散列码
void notify()唤醒正等待于此对象 manitor上的单一线程
void notifyAll()唤醒所有等待于此对象 manitor上的线程
String toString()返回代表此对象的字符串
void wait()使目前线程等待，直到被其他线程调用
void wait(long timeout) 使目前线程等待，直到被其他线程调用，或一定时间timeout（豪秒）过去后 。
void wait(long timeout,int nanos)使目前线程等待，直到被其他线程调用或中断，
或一定时间 nanos（秒）过去后 。
public class ObjectTest_1 {
public static void main(String[] args) {
String objname_1,objname_2;
int hashcode_1,hashcode_2;
Object obj_1= new Object();
Object obj_2= new Object();
objname_1=obj_1.toString();
objname_2=obj_2.toString();
hashcode_1=obj_1.hashCode();
hashcode_2=obj_2.hashCode();
System.out.println("对象一的名称,"+objname_1);
System.out.println("对象一的散列码,"+hashcode_1);
System.out.println("对象二的名称,"+objname_2);
System.out.println("对象二的散列码,"+hashcode_2);
System.exit(0);
}
}
范例
执行结果,
对象一的名称,
java.lang.Object@273d3c
对象一的散列码,
2571580
对象二的名称,
java.lang.Object@256a7c
对象二的散列码,
2452092
例如：确定一个对象的类型
getClass()方法 在所有类中都是由 Object类继承的，它会返回一个类型为 class的对象，识别出定义一个对象的类。假设有一个类型为 Animal的 pet变量，它可能会引用一个 Dog,Cat,Duck等类型的对象，为了找出实际是什么类型，可以编写下列语句
class objecttype=pet.getClass();
System.out.println(objecttype.getName());
对象的复制：
protected Object clone() 用来生成当前对象的一个拷贝，
并返回这个复制对象,注：只有当要复制的对象的类指出允许克隆的时候才可以进行这种操作。当该类实现了
Cloneable 接口时才能被复制。所以让一个类实现的复制所需的就是在该类定义的第一行中声明这个接口
class PetDog implements Cloneable
{
…………………..
}
Public class Test
{ public static void main(String[] args)
{ PetDog mypet=new PetDog(“fang”,”slfkjlsdfj”);
PetDog yourpet=(PetDog)mypet.clone()………………..
System
此类用来处理与系统层次有关的信息。常用到的系统调用有,标准输入输出、取得系统性质或取得现在时刻等 。这个类的 API与所在的操作系统是独立分开的,这样的好处是不用每到一个新的系统环境下，就需重新改写系统调用程序代码 。
至于与系统有关的 API,则另外放在 Runtime类中。不过只有较少的机会会用到此类 。
公有最终类,此类与 Runtime一起可以访问许多有用的系统功能。
有一些方法在两个类中都出现。 exit(),gc(),load()和 loadLibrary()可以通过调用在 Runtime中的同名方法来响应。特别有用的类变量
err,in,out，它们可以访问基本控制台 I/O。 System类完全由类域组成。
这些类域可以通过,System.变量名”和,System.方法名 ()”的方式进行访问。 此类不能被实例化实例变量,public static PrintStream err;
public static InputStream in;
public static PrintStream out;
每个变量对整个程序而言都是唯一的对象变量。这些对象可以访问到系统的输入、输出和错误输出
public class SystemTest_1 {
public static void main(String[] args) {
String name = System.getProperty("user.name");//用户姓名
String password = System.getProperty("user.password");//用户密码
String javaversion = System.getProperty("java.version");//Java版本
String javavendor = System.getProperty("java.vendor");//Java制造商
long time=System.currentTimeMillis();//毫秒数
System.out.println("用户姓名,"+name);
System.out.println("用户密码,"+password);
System.out.println("Java版本,"+javaversion);
System.out.println("Java制造商,"+javavendor);
System.out.println("现在时间 <毫秒 >:"+time);
System.exit(0);
}
}
范例数组类型数组 (array)是一种数据结构 （ data structure）,可提供存储同一类型的一群变量 。 而这些变量可用同一名称被参考到 。 数组被视为一种对象,其名称所代表的是一个参考 。
一维数组数组的声明,可用两种方式,
数据类型 [ ] 数组名；
或 数据类型 数组名 [ ]；
例如 String [] args;
或 String args[] ；
数组声明完后,可藉 new 运算符来产生真正的内存空间配置 。 但数组大小声明后不能再被改变 。
数组名＝ new 数据类型 [数组大小 ]
一维数组如 float[] tax=new float[5];
数组被声明后，其数组大小值会被放在所分配内存区的第一个地址，并以 length作此地址的参考。所以我们可用
tax.length来取得此数组的大小值 。
数组被设置数值的方法如下,
tax[0]＝ 6786.5
tax[1]＝ 8763.79
t ax
len g th (=5 )
tax [0 ]
tax [ 1 ]
tax [ 2 ]
tax [ 3 ]
tax [ 4 ]
多维数组数组也可以用,数组的数组,方式来产生多维数组 。
例如：
int number[][]=new int[3][3]；
number[0][0]=1;
number[0][1]=2;
number[0][2]=3;
number[0][0]=4;
number[0][1]=5;
number[0][2]=6;
number[0][0]=7;
number[0][1]=8;
number[0][2]=9;
若要简化上面的设置,可用一组嵌套式大括号来完成 。
int number={{1,2,3},{4,5,6},{7,8,9}};
对于多维数组，它的每一维可以具有不同的长度
int array[][]=new int[2][]
array[0]=new int[3]
array[1]=new int[7]
向量类比较适合于在如下情况下使用：
（ 1）需要处理的对象数目不定，序列中的元素都是对象或可以表示为对象。
（ 2）需要将不同类的对象组合成一个数据序列。
（ 3）需要做频繁的对象序列中元素的插入和删除。
（ 4）经常需要定位序列中的对象或其他的查找操作。
（ 5）在不同的类之间传递大量的数据也可以使用 Vector对象一 创建向量类的对象：
Vector类有三个构造函数：
public Vector( )
public Vector(int initCapacity)
public Vector(int initCapacity,int capacityIncrement )
你可以随意指定初始容量以及每次超出容量时增长的容量数例,Vector MyVector=new Vector(100,50);
二 向向量序列中添加元素
addElement( )：将新元素添加在向量序列的尾部。
insertElement(Object obj,int index ):将新元素插入在序列的指定位置
addElement(Object obj)
inserElement(Object obj,int index);
例,Vector MyVector=new Vector( );
for(int I=1;I<=10;I++)
{ String name=“部门” +Integer.toString(I);
MyVector.addElement(new Department(I,name));}
MyVector.insertElement(new ManagerEmployee(0,”总经理
“,1000,?f?,new Date( ),new Date)),0);
向量序列中的元素可以不是相同类型的对象三 修改和删除向量序列中的元素：
void setElementAt(Object obj,int index);
将向量序列 index位置处的元素设置成 obj,如这个位置原来有元素则被覆盖。
void removeElement(Object obj);
删除向量序列中第一个与指定的 obj对象相同的元素，同时将后面元素前提补上空位。
void removeElement(int index);
删除指定位置处的元素，同时将后面的元素前提。
void removeAllElement( )
删除向量序列中的所有元素。
例,Vector MyVector=new Vector(100)
for(int I=0;I<10;I++)
{ MyVector.addElement(“Welecom”);
MyVector.addElement(“to”);
MyVector.addElement(“Beijing”);
}
while(MyVector.removeElement(“to”));
四 查找向量序列中的元素
Object elementAt(int index)
在使用之前通常需要进行强制类型转换将返回的对象引用转换成 Object类的某个具体子类的对象。
String str=(Sting)MyVector.elementAt(0);
boolean contains(Object obj);
int indesOf(Object obj,int start_index) (返回找到元素的下标）
int lastIndexOf(Object obj,int start_index);
例 int I=0;
while((I=MyVector.indexOf(“Welcom”,I))!=-1)
System.out.println(I);
字符串分两类：
1 创建之后不会再做修改和变动的字符串常量 。用 String类表示
2创建之后允许做修改和变动的字符串变量。用 StringBuffer表示。
对于字符串变量，由于程序中经常需要对它做添加，插入，修改之类的操作，所以一般都存放在 StringBuffer类的对象中一 字符串常量与 String类对于 Java中的字符串常量，通常是作为 String类的对象存在着，
对于所有用双引号括起的字符串常量，系统都会缺省地为它创建一个无名的 String类的对象。
1 创建字符串常量 String对象在一般情况下，一个 String对象一经创建，无论长度和内容都不能再更改。
String类的构造函数：
public String( );
public String( Sting value);
public String( StringBuffer buffer);
public String(char valeu[] );
创建 Sring类的对象分两步：声明和创建
String s;
s=new String(“agah”);
二字符串常量的操作：
public int length( )
Sting s=“hello”;
System.out.println(s.length( ));
三 判断字符串的前缀和后缀：
public boolean startsWith(String prefix);
public boolean endsWith(String suffix);
String s=User.getPhone( );
if(s.startsWith(“48”)
假如是某位居民的身份证号码：
If(s.endsWith(“0”)||s.endsWith(“2”)||s.endsWith(“4”)||s.endsWith(“6”)||
s.endsWith(“8”))
{System.out.println(“此人是女性” );}
四 字符串的中单个字符的查找
public int indexOf(int ch)
public int indexOf(int ch,int fromIndex);
五 字符子串的查找
public int indexOf(String str);
public int indexOf(String str,int fromIndex);
public int lastIndexOf(String str);
public int lasIndexOf(String str,int fromIndex);
六 字符串的比较：
public int compareTo(String anotherString);
public boolean equal(Object anObject);
public boolean equalsIgnoreCase(String anotherString);
七 连接字符子串
public String concat(String str);
字符串变量与 StringBuffer类
StringBuffer类的每个对象都是可以扩充和修改的字符串变量
1 创建字符串变量 -------StringBuffer对象构造函数
public StringBuffer( )
public StringBuffer( int length)
public StringBuffer(String str )
说明：若希望将 StringBuffer在屏幕上显示出来，必须首先调用
toString方法把它变成字符串常量，因为 println()方法不接受
StringBuffer类型的参数。
StringBuffer MyStrBuff=new StringBuffer();
MyStrBuff.append(“hello,Guys”);
System.out.println(MyStrBuffer.toString());
Java Application 的命令行参数命令行参数是 Java Application 传入数据的常用而有效的手段
public class CommandLineParam
{ public static void main(String args[])
{ int a1,a2,a3;
if(args.length<2)
{System.out.println(“Not Enough command line parameters is prided”);
System.exit(0);}
a1=Integer.parseInt(args[0]);
a2=Ingeger.parseInt(args[1]);
a3=a1+a2;
System.out.println(a3);}}
执行时的命令行格式为
java CommandLineParam 12 34
总结：
字符串变量 (复合类型 )
java.lang包中有两种字符串类,
String类 只支持只读字符串
StringBuffer类 支持可修改字符串以 String类字符串为例,来了解字符串变量的实质。
一个字符串变量就是一个 String 对象变量。对象变量是一个 类的实例 的存储变量,即是对对象 (类的一个实例 )的引用,
声明对象变量 与 生成对象本身 是两个分离的步骤,
String s1;声明一 String类的对象变量,此时 s1值为 null.
s1=new String("right");new运算符 为对象分配内存空间,
即生成一 String类的实例 ----对象,返回对该对象的一个 引用 (即该对象的中间数据结构所在的内存地址 ).
对象的引用 是指向一中间数据结构,它存储有关数据类型的信息及当前对象所在的内存地址,而对象所在的实际内存地址是不可见不可操作的,这就保证了安全性,
此时 s1中即为该对象的中间数据结构的内存地址,
所以,对象变量只可能有两个可能的值,null或某对象引用,
同时,执行构造方法,进行初始化,
所以,对象的生成包括,
l 对象变量的声明
l 实例化
l 初始化上例也可合并为,String s1=new String("right");
String类在 JAVA中是一个特殊的类,JAVA编译器遇到带双引号的字符串时，即自动生成 String类的一个实例，因此,String类对象初始化的最简单方式可表示如下：
String s1="right";
二、数组变量（复合型变量）
数组变量也是一个对象变量，下面我们以数组对象为例，分析对象的内存模型。
程序内存的动态改变部分可以分成两个区：内存堆栈区
（ stack）和内存堆区（ hesp）,
堆栈内存区 用于存放方法或程序块中声明的局部变量。
内存堆区 是用于对象的存储内存（即对象的数据区）。用 new生成新对象时，即在堆内存区分配对象的数据存储单元。
下面我们在一段程序执行过程中，分析内存模型的变化情况。
Point类 可放置一个二维图形点的 x和 y坐标。
Point类原型：
public class java.awt.Point
extends java.lang.Object
{
public int x;
public int y;
public Point(int x,int y);
public boolean equals(Object obj);
public int hashCode();
public void move(int x,int y);
public String toString();
public void translate(int dx,int dy);
}
void m1()
{int a1=1;
Point p1; //checkpoint #1
p1=new Point(2,3); //checkpoint #2
m2(a1,p1);
a1=8; //checkpoint #5
}
void m2(int a2,Point p2)
{int a3=4;
Point p3; //checkpoint #3
p3=new Point(5,6);
a2=7; //checkpoint #4
}
到达 checkpoint #1时的内存模型：
到达 checkpoint #2时的内存模型：
到达 checkpoint #3时的内存模型：
*方法的参数类型可以是简单数据类型，也可以是引用数据类型（数组类型、类或接口）。
对于简单数据类型,JAVA实现的是值传送。
对于引用数据类型，传送的是数据在内存的地址。
到达 checkpoint #4时的内存模型：
到达 checkpoint #5时的内存模型：
*一个方法退出时，局部变量和形参变量的内存弹出堆栈区。
这使原先分配给局部变量的 对象内存 在堆中空闲（即没有向这块内存单元的引用），这个闲置对象内存由 内存单元收集程序 管理。
生成数组对象时的内存模型：
数组是一组相同类型变量的集合，变量类型既可以是基本型，也可以是对象型。数组是对象，是通过引用来操作的。将数组传递到方法中时，只传递数组对象的内存地址（准确说是中间数据结构地址）。而不是整个数组的元素。
定义数组对象变量,type ArrayName[ ]或 type[] ArrayName.
type可以是简单类型也可以是复杂类型。
第二种方式的声明更能表明数组是一个对象，是一串某种数据类型实例的引用。如,int[] day;
Point[] points;Point是一放置二维图形点的类声明 Point[] points;后的内存模型：
为数据元素分配内存空间 points=new Point[2]后的内存模型：
*每个数组对象都有一公共变量 length,用于放置数组的长度,
如,可用 points.length访问数组的长度 (元素个数 ).
初始化第一个元素 points[0]=new Point(1,2);后的内存模型,
也可以用 数组初始化程序 生成具有初始值的数组,在定义的同时初始化数组，如：
int[] values = {100,200,300,400,500}；
*数组初始化程序只能用于 数组声明 时,不能用于普通赋值语句的右边,
书写程序片段完成下面的功能
1 声明并创建一个含有 10个数据的整型数组
2 声明并创建一个含有 10个整型数据的数组，且每个数组元素的初值等于其数组下标
3 声明并创建一个数组包含 1,3,5,7四个元素
4 把数组 array的第二个元素的数值设置为 0
5 声明并创建一个 3行 4列的二维数组
6 把如下的二维数组的所有元素的值显示在屏幕上
int TwoDimArray[][]={1,2,3},{4},{5,6}}
7把二维数组 TwoDimArray的每一行的第一个元素设置为 0
8把二维数组的最后一行的所有元素的值设置为 0
9创建一个 Vector对象 myv，初始包含 10个元素
10判断 myv中是否包含 obj，否则将它添加在 myv的最后一个对象的后面
11 将 myv中所有等于 obj的元素删除
