1.1.1.1 String类和StringBuffer类
位于java.lang包中,这个包中的类使用时不用导入
String类一旦初始化就不可以改变,而stringbuffer则可以。它用于封装内容可变的字符串。它可以使用tostring()转换成string字符串。
Stringx=”a”+4+”c”编译时等效于String x=newStringBuffer().append(“a”).append(4).append(“c”).toString();
字符串常量是一种特殊的匿名对象,String s1=”hello”;String s2=”hello”;则s1==s2;因为他们指向同一个匿名对象。
如果String s1=new String(“hello”);String s2=new String(“hello”);则s1!=s2;
/*逐行读取键盘输入,直到输入为“bye”时,结束程序
注:对于回车换行,在windows下面,有'\r'和'\n'两个,而unix下面只有'\n',但是写程序的时候都要把他区分开*/
public class readline
{
public static void main(String args[])
{
String strInfo=null;
int pos=0;
byte[] buf=new byte[1024];//定义一个数组,存放换行前的各个字符
int ch=0; //存放读入的字符
system.out.println(“Please input a string:”);
while(true)
{
try
{
ch=System.in.read(); //该方法每次读入一个字节的内容到ch变量中。
}
catch(Exception e)
{
}
switch(ch)
{
case '\r': //回车时,不进行处理
break;
case '\n': //换行时,将数组总的内容放进字符串中
strInfo=new String(buf,0,pos); //该方法将数组中从第0个开始,到第pos个结束存入字符串。
if(strInfo.equals("bye")) //如果该字符串内容为bye,则退出程序。
{
return;
}
else //如果不为bye,则输出,并且竟pos置为0,准备下次存入。
{
System.out.println(strInfo);
pos=0;
break;
}
default:
buf[pos++]=(byte)ch; //如果不是回车,换行,则将读取的数据存入数组中。
}
}
}
}
String类的常用成员方法
1、 构造方法:
String(byte[] byte,int offset,int length);这个在上面已经用到。
2、 equalsIgnoreCase:忽略大小写的比较,上例中如果您输入的是BYE,则不会退出,因为大小写不同,但是如果使用这个方法,则会退出。
3、 indexOf(intch);返回字符ch在字符串中首次出现的位置
4、 substring(intbenginIndex);
5、 substring(intbeginIndex,int endIndex);
返回字符串的子字符串,4返回从benginindex位置开始到结束的子字符串,5返回beginindex和endindex-1之间的子字符串。
基本数据类型包装类的作用是:将基本的数据类型包装成对象。因为有些方法不可以直接处理基本数据类型,只能处理对象,例如vector的add方法,参数就只能是对象。这时就需要使用他们的包装类将他们包装成对象。
例:在屏幕上打印出一个*组成的矩形,矩形的宽度和高度通过启动程序时传递给main()方法的参数指定。
public class testInteger
{
public static void main(String[] args)
//main()的参数是string类型的数组,用来做为长,宽时,要转换成整型。
{
int w=new Integer(args[0]).intValue();
inth=Integer.parseInt(args[1]);
//int h=Integer.valueOf(args[1]).intValue();
//以上为三种将字符串转换成整形的方法。
for(int i=0;i<h;i++)
{
StringBuffer sb=new StringBuffer(); //使用stringbuffer,是因为它是可追加的。
for(int j=0;j<w;j++)
{
sb.append('*');
}
System.out.println(sb.toString()); //在打印之前,要将stringbuffer转化为string类型。
}
}
}
比较下面两段代码的执行效率:
(1)Stringsb=new String();
For(int j=0;j<w;j++)
{
Sb=sb+’*’;
}
(2) StringBuffer sb=new StringBuffer();
For(int j=0;j<w;j++)
{
Sb.append(‘*’);
}
(1) 和(2)在运行结果上相同,但效率相差很多。
(1) 在每一次循环中,都要先将string类型转换为stringbuffer类型,然后将‘*’追加进去,然后再调用tostring()方法,转换为string类型,效率很低。
(2) 在没次循环中,都只是调用原来的那个stringbuffer对象,没有创建新的对象,所以效率比较高。
1.1.1.2 System类与Runtime类
由于java不支持全局函数和全局变量,所以java设计者将一些与系统相关的重要函数和变量放在system类中。
我们不能直接创建runtime的实例,只能通过runtime.getruntime()静态方法来获得。
编程实例:在java程序中启动一个windows记事本程序的运行实例,并在该运行实例中打开该运行程序的源文件,启动的记事本程序5秒后关闭。
public class Property
{
public static void main(String[] args)
{
Process p=null; //java虚拟机启动的进程。
try
{
p=Runtime.getRuntime().exec("notepad.exeProperty.java"); //启动记事本并且打开源文件。
Thread.sleep(5000); //持续5秒
p.destroy(); //关闭该进程
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
}
1.1.1.3 Java语言中两种异常的差别
Java提供了两类主要的异常:runtime exception和checked exception。所有的checked exception是从java.lang.Exception类衍生出来的,而runtime exception则是从java.lang.RuntimeException或java.lang.Error类衍生出来的。
它们的不同之处表现在两方面:机制上和逻辑上。
一、机制上
它们在机制上的不同表现在两点:1.如何定义方法;2. 如何处理抛出的异常。请看下面CheckedException的定义:
public class CheckedException extends Exception
{
public CheckedException() {}
public CheckedException( String message )
{
super( message );
}
}
以及一个使用exception的例子:
public class ExceptionalClass
{
public void method1()
throws CheckedException
{
// ... throw new CheckedException( “...出错了“ );
}
public void method2( String arg )
{
if( arg == null )
{
throw new NullPointerException( “method2的参数arg是null!” );
}
}
public void method3() throws CheckedException
{
method1();
}
}
你可能已经注意到了,两个方法method1()和method2()都会抛出exception,可是只有method1()做了声明。另外,method3()本身并不会抛出exception,可是它却声明会抛出CheckedException。在向你解释之前,让我们先来看看这个类的main()方法:
public static void main( String[] args )
{
ExceptionalClass example = new ExceptionalClass();
try
{
example.method1();
example.method3();
}
catch( CheckedException ex ) { } example.method2( null );
}
在main()方法中,如果要调用method1(),你必须把这个调用放在try/catch程序块当中,因为它会抛出Checked exception。
相比之下,当你调用method2()时,则不需要把它放在try/catch程序块当中,因为它会抛出的exception不是checked exception,而是runtime exception。会抛出runtime exception的方法在定义时不必声明它会抛出exception。
现在,让我们再来看看method3()。它调用了method1()却没有把这个调用放在try/catch程序块当中。它是通过声明它会抛出method1()会抛出的exception来避免这样做的。它没有捕获这个exception,而是把它传递下去。实际上main()方法也可以这样做,通过声明它会抛出Checked exception来避免使用try/catch程序块(当然我们反对这种做法)。
小结一下:
* Runtime exceptions:
在定义方法时不需要声明会抛出runtime exception;
在调用这个方法时不需要捕获这个runtime exception;
runtime exception是从java.lang.RuntimeException或java.lang.Error类衍生出来的。
* Checked exceptions:
定义方法时必须声明所有可能会抛出的checked exception;
在调用这个方法时,必须捕获它的checked exception,不然就得把它的exception传递下去;
checked exception是从java.lang.Exception类衍生出来的。
二、逻辑上
从逻辑的角度来说,checked exceptions和runtime exception是有不同的使用目的的。checked exception用来指示一种调用方能够直接处理的异常情况。而runtime exception则用来指示一种调用方本身无法处理或恢复的程序错误。
checked exception迫使你捕获它并处理这种异常情况。以java.net.URL类的构建器(constructor)为例,它的每一个构建器都会抛出MalformedURLException。MalformedURLException就是一种checked exception。设想一下,你有一个简单的程序,用来提示用户输入一个URL,然后通过这个URL去下载一个网页。如果用户输入的URL有错误,构建器就会抛出一个exception。既然这个exception是checked exception,你的程序就可以捕获它并正确处理:比如说提示用户重新输入。
再看下面这个例子:
public void method()
{
int [] numbers = { 1, 2, 3 };
int sum = numbers[0] numbers[3];
}
在运行方法method()时会遇到ArrayIndexOutOfBoundsException(因为数组numbers的成员是从0到2)。对于这个异常,调用方无法处理/纠正。这个方法method()和上面的method2()一样,都是runtime exception的情形。上面我已经提到,runtime exception用来指示一种调用方本身无法处理/恢复的程序错误。而程序错误通常是无法在运行过程中处理的,必须改正程序代码。
总而言之,在程序的运行过程中一个checked exception被抛出的时候,只有能够适当处理这个异常的调用方才应该用try/catch来捕获它。而对于runtime exception,则不应当在程序中捕获它。如果你要捕获它的话,你就会冒这样一个风险:程序代码的错误(bug)被掩盖在运行当中无法被察觉。因为在程序测试过程中,系统打印出来的调用堆栈路径(StackTrace)往往使你更快找到并修改代码中的错误。有些程序员建议捕获runtime exception并纪录在log中,我反对这样做。这样做的坏处是你必须通过浏览log来找出问题,而用来测试程序的测试系统(比如Unit Test)却无法直接捕获问题并报告出来。
在程序中捕获runtime exception还会带来更多的问题:要捕获哪些runtime exception?什么时候捕获?runtime exception是不需要声明的,你怎样知道有没有runtime exception要捕获?你想看到在程序中每一次调用方法时,都使用try/catch程序块吗?
1.1.1.4 类加载器(ClassLoader)
1.1.1.4.1 基础知识
静态库、动态连接库
程序编制一般需经编辑、编译、连接、加载和运行几个步骤。在我们的应用中,有一些公共代码是需要反复使用,就把这些代码编译为“库”文件;在连接步骤中,连接器将从库文件取得所需的代码,复制到生成的可执行文件中。这种库称为静态库,其特点是可执行文件中包含了库代码的一份完整拷贝;缺点就是被多次使用就会有多份冗余拷贝。
为了克服这个缺点可以采用动态连接库。这个时候连接器仅仅是在可执行文件中打上标志,说明需要使用哪些动态连接库;当运行程序时,加载器根据这些标志把所需的动态连接库加载到内存。
另外在当前的编程环境中,一般都提供方法让程序在运行的时候把某个特定的动态连接库加载并运行,也可以将其卸载(例如Win32的LoadLibrary()&FreeLibrary()和Posix的dlopen()&dlclose())。这个功能被广泛地用于在程序运行时刻更新某些功能模块或者是程序外观。
What is ClassLoader?
与普通程序不同的是,Java程序(class文件)并不是本地的可执行程序。当运行Java程序时,首先运行JVM(Java虚拟机),然后再把Java class加载到JVM里头运行,负责加载Java class的这部分就叫做Class Loader。
JVM本身包含了一个ClassLoader称为Bootstrap ClassLoader,和JVM一样,Bootstrap ClassLoader是用本地代码实现的,它负责加载核心Java Class(即所有java.*开头的类)。另外JVM还会提供两个ClassLoader,它们都是用Java语言编写的,由Bootstrap ClassLoader加载;其中Extension ClassLoader负责加载扩展的Java class(例如所有javax.*开头的类和存放在JRE的ext目录下的类),Application ClassLoader负责加载应用程序自身的类。
When to load the class?
什么时候JVM会使用ClassLoader加载一个类呢?当你使用java去执行一个类,JVM使用Application ClassLoader加载这个类;然后如果类A引用了类B,不管是直接引用还是用Class.forName()引用,JVM就会找到加载类A的ClassLoader,并用这个ClassLoader来加载类B。
Why use your own ClassLoader?
似乎JVM自身的ClassLoader已经足够了,为什么我们还需要创建自己的ClassLoader呢?
因为JVM自带的ClassLoader只是懂得从本地文件系统加载标准的java class文件,如果编写你自己的ClassLoader,你可以做到:
1)在执行非置信代码之前,自动验证数字签名
2)动态地创建符合用户特定需要的定制化构建类
3)从特定的场所取得java class,例如数据库中
4) 等等
事实上当使用Applet的时候,就用到了特定的ClassLoader,因为这时需要从网络上加载java class,并且要检查相关的安全信息。
目前的应用服务器大都使用了ClassLoader技术,即使你不需要创建自己的ClassLoader,了解其原理也有助于更好地部署自己的应用。
ClassLoader Tree & Delegation Model
当你决定创建你自己的ClassLoader时,需要继承java.lang.ClassLoader或者它的子类。在实例化每个ClassLoader对象时,需要指定一个父对象;如果没有指定的话,系统自动指定ClassLoader.getSystemClassLoader()为父对象。如下图:
在Java 1.2后,java class的加载采用所谓的委托模式(Delegation Modle),当调用一个ClassLoader.loadClass()加载一个类的时候,将遵循以下的步骤:
1)检查这个类是否已经被加载进来了?
2)如果还没有加载,调用父对象加载该类
3)如果父对象无法加载,调用本对象的findClass()取得这个类。
所以当创建自己的Class Loader时,只需要重载findClass()这个方法。
Unloading? Reloading?
当一个java class被加载到JVM之后,它有没有可能被卸载呢?我们知道Win32有FreeLibrary()函数,Posix有dlclose()函数可以被调用来卸载指定的动态连接库,但是Java并没有提供一个UnloadClass()的方法来卸载指定的类。
在Java中,java class的卸载仅仅是一种对系统的优化,有助于减少应用对内存的占用。既然是一种优化方法,那么就完全是JVM自行决定如何实现,对Java开发人员来说是完全透明的。
在什么时候一个java class/interface会被卸载呢?Sun公司的原话是这么说的:"class or interface may beunloaded if and only if its class loader is unreachable. Classes loaded by thebootstrap loader may not be unloaded."
事实上我们关心的不是如何卸载类的,我们关心的是如何更新已经被加载了的类从而更新应用的功能。JSP则是一个非常典型的例子,如果一个JSP文件被更改了,应用服务器则需要把更改后的JSP重新编译,然后加载新生成的类来响应后继的请求。
其实一个已经加载的类是无法被更新的,如果你试图用同一个ClassLoader再次加载同一个类,就会得到异常(java.lang.LinkageError: duplicate class definition),我们只能够重新创建一个新的ClassLoader实例来再次加载新类。至于原来已经加载的类,开发人员不必去管它,因为它可能还有实例正在被使用,只要相关的实例都被内存回收了,那么JVM就会在适当的时候把不会再使用的类卸载。
1.1.1.4.2 类加载的表现形式
java中的类是动态加载的,我们先看一下我们常用的类加载方式,先有一个感性的认识,才能进一步
深入讨论,类加载无非就是下面三种方式。
class A{}
class B{}
class C{}
public class Loader{
public static void main(String[] args) throws Exception{
Class aa=A.class;
Class bb=Class.forName("B");
Class cc=ClassLoader.getSystemClassLoader().loadClass("C");
}
}
我们先看.class字面量方式,很多人可能不知道这种方式,因为这种用法不是一般java语法。
通过javap我们可以发现,这种方式的大致等价于定义了一个静态成员变量
static Class class$0;(后面的编号是增长的)
你可以试图再定义一个 static Class class$0,应该会收到一个编译错误(重复定义)。
Class aa=A.class;
就相当于
if(class$0==null){
try{
Class.forName("A");
}
cacth(ClassNotFoundException e){
throw new NoClassDefFoundError(e);
}
}
Class aa=class$0;
可以很清楚的看到,这种类的字面量定义其实不是加载类的方式,而是被编译器处理了,实质
上是使用了Class.forName方法,但是使用这种方式有一个很大的好处就是不用处理异常,因为
编译器处理的时候如果找不到类会抛出一个NoClassDefFoundError。也许你觉得需要处理
ClassNotFoundException这种异常,事实上99%的情况下我们可以把这种异常认为是一个错误。
所以大部分情况我们使用这种方式会更简洁。
最常用的方式就是Class.forName方式了,这也是一个通用的上层调用。这个方法有两个重载,
可能很多人都忽略了第二个方法。
public static Class forName(String name) throws ClassNotFoundException
public static Class forName(String name, boolean initialize,ClassLoader loader) throws ClassNotFoundException
第二个方法后面多了两个参数,第二个参数表示是否初始化,第三个参数为指定的类加载器。
在上面的例子中:
Class bb=Class.forName("B");等价于
Class bb=Class.forName("B",true,Loader.class.getClassLoader());
这里要详细说一下这个类的初始化这个参数,如果这个参数为false的话,
类中的static成员不会被初始化,static语句块也不会被执行。
也就是类虽然被加载了,但是没有被初始化,不过在第一次使用时仍然会初始化。
所以我们有时候会看到Class.forName("XXX").newInstance()这样的语句,为什么这里要创建一个
不用的实例呢?不过是为了保证类被初始化(兼容以前的系统)。
其实第二个方法是比较难用的,需要指定类加载器,如果不指定而且又没有安装安全管理器的化,
是无法加载类的,只要看一下具体的实现就明白了。
最本质的方式当然是直接使用ClassLoader加载了,所有的类最终都是通过ClassLoader加载的,
Class cc=ClassLoader.getSystemClassLoader().loadClass("C");
这里通过使用系统类加载器来加载某个类,很直接的方式,但是很遗憾的是通过这种方式加载类,
类是没有被初始化的(也就是初始化被延迟到真正使用的时候).不过我们也可以借鉴上面的经验,加载
后实例化一个对象Class cc=ClassLoader.getSystemClassLoader().loadClass("C").newInstance()。
这里使用了系统类加载器,也是最常用的类加载器,从classpath中寻找要加载的类。
java中默认有三种类加载器:引导类加载器,扩展类加载器,系统类加载器。
java中的类加载有着规范的层次结构,如果我们要了解类加载的过程,需要明确知道哪个类被谁
加载,某个类加载器加载了哪些类等等,就需要深入理解ClassLoader的本质。
以上只是类加载的表面的东西,我们还将讨论深层次的东西。