一个File类的对象，表示了磁盘上的文件或目录。
 File类提供了与平台无关的方法来对磁盘上的文件或目录进行操作。

import java.io.*;
class FileTest
{
 public static void main(String[] args) throws Exception
 {
  //File f = new File("1.txt");
  //f.createNewFile();   创建文件
  //f.mkdir(); 创建文件夹
  //File f = new File("F:\\Java Develop\\1.txt");//使用绝对路径
  //f.createNewFile();
  /*
  *WINDOWS平台下有盘符，LINUX下是没有的
  *考虑到JAVA语言的平台性，所有用分隔符seperator/seperatorChar
  */
  /*
  File fDir = new File(File.separator);//创建了当前的根目录
  String strFile = "Java Develop"+File.separator+"1.txt";
  File f = new File(fDir,strFile);
  f.createNewFile();
  //f.delete();
  f.deleteOnExit();
  Thread.sleep(3000);
  */
  /*
  for(int i=0;i<5;i++)
  {
   File.createTempFile("linshi",".tmp");
   f.deleteOnExit();
  }
  Thread.sleep(3000);
  */
 
  File fDir = new File(File.separator);
  String strFile ="Java Develop"+File.separator;
  File f = new File(fDir,strFile);
  //文件过滤器
  String[] names = f.list(new FilenameFilter()
  {
   public boolean accept(File dir,String name)
   {
    return name.indexOf(".java")!=-1;
   }
  });
  for(int i=0;i<names.length;i++)
  {
   System.out.println(names[i]);
  }
 }
}

            流式I/0

 流(Stream)是字节的源或目的。
 两种基本的流是: 输入流(Input Stream)和输出流(Output Stream)。从从中读出一系列字节的
 对象称为输入流。而能向其中写入一系列字节的对象称为输出流。

           流的分类
 
 节点流: 从特定的地方读写的流类，例如：磁盘或一块内存区域。
 过滤流: 使用节点作为输入或输出。过滤流使用的是一个已经存在的输入流或输出流连接创建的。
 (如下图)

 InputStream(一个抽象的基类)
 .三个基本的读写方法
  abstract int read(): 读取一个字节数据，并返回到数据，如果返回-1，表示读到了输入流的
                       末尾。
  int read(byte[] b):  将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，
                       表示读到了输入流的末尾。
  int read(byte[] b,int off,int len): 将数据读入一个字节数组，同时返回是实际读取的字
                       节数。如果返回-1，表示读到了输入流的末尾。off指定在数组b中存放
                       数据的起始偏移位置；len指定读取的最大字节数。
 其他的方法
  long-skip(long n): 在输入流中跳过n个字节，并返回实际跳过的字节数。
  int available():   返回在不发生阻塞的情况下，可读取的字节数。
  void close():      关闭输入流，释放和这个流相关的系统资源。
  void mark(int reqdlimit): 在输入流的当前位置放置一个标记，如果读取的字节数多余
                     readlimit设置的值，则流忽略这个标记。
  void reset():      返回到上一个标记。
  boolean markSupported(): 测试当前是否支持mark和reset方法。如果支持返回true，反之false。

         java.io包中的InputStream的类层次 (下图)

OutputStream

 三个基本的写方法
 abstract void write(int b): 往输出流中写入一个字节
 void write(byte[] b):       往输出流中写入数组b中的所有字节
 void writte(byte[] b,int off,int len): 往输出流中写入数组b中从偏移量off开始的len个
                             字节的数据
 其它方法
 void flush(): 刷新输出流，强制缓冲区中的输出字节被写出
 void close(): 关闭输出流，释放和这个流相关的系统资源

        java.io包中OutputStream的类层次(如下图)

基本的流类

 FileInputStream和FileOutputStream
 节点流，用于从文件中读取或往文件中写入字节流。如果在构造FileOutputStream时，文件已经
 存在，则覆盖这个文件。
 
 BufferedInputStream和BufferedOutputStream
 过滤流，需要使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率。

 DataInputStream和DataOutputStream
 过滤流，需要使用已经存在的节点流来构造,提供了读写Java中的基本数据类型的功能。

 PipedInputStream和PipedOutputStream
 管道流，用于线程间的通信。一个线程的PipedInputStream对象从另一个线程的PipedOutputStream
 对象读取输入。要使管道流有用，必须同时构造管道输入流和管道输出流。

code:
import java.io.*;
class StreamTest
{
 public static void main(String[] args)throws Exception
 {
  /*
  int data;
  while((data=System.in.read())!=-1)  //从标准设备读取数据
  {
   System.out.write(data);//从标准设备输出数据
  }
  */
  //输出流写数据,只需要关闭尾端的流就可以了，因为fos连接到了bos
  FileOutputStream fos = new FileOutputStream("1.txt");
  //fos.write("http://www.google.cn".getBytes());
  //fos.close();
  BufferedOutputStream bos = new BufferedOutputStream(fos);
  //bos.write("http//www.baidu.com".getBytes());
  //bos.flush();
  //bos.close();
  DataOutputStream dos=new DataOutputStream(bos); //连接到了bos和fis
  byte b=3;
  int i=78;
  char ch='a';
  float f=4.5f;
  dos.writeByte(b);
  dos.writeInt(i);
  dos.writeChar(ch);
  dos.writeFloat(f);
  dos.close(); //必须调用flush()或者close()不然不会写入硬盘
 
  //输入流读数据
  FileInputStream fis=new FileInputStream("1.txt");
  BufferedInputStream bis = new BufferedInputStream(fis);
  //byte[] buf=new byte[100];
  //int len=fis.read(buf);
  //int len=bis.read(buf);
  //System.out.println(new String(buf,0,len));
  //fis.close();
  //bis.close();
  //注意读取的顺序要和写的顺序一样
  DataInputStream dis = new DataInputStream(bis);
  System.out.println(dis.readByte());
  System.out.println(dis.readInt());
  System.out.println(dis.readChar());
  System.out.println(dis.readFloat());
  dis.close(); 
 
 }
}

管道输入/输出流 code:
import java.io.*;
class PipedStreamTest
{
 public static void main(String[] args)
 {
  PipedOutputStream pos=new PipedOutputStream();
  PipedInputStream pis=new PipedInputStream();
  //连接
  try
  {
   pos.connect(pis);
   new Producer(pos).start();
   new Consumer(pis).start();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 }
}

class Producer extends Thread
{
 private PipedOutputStream pos;
 public Producer(PipedOutputStream pos)
 {
  this.pos=pos;
 }
 public void run()
 {
  try
  {
   pos.write("hello,welcome!".getBytes());
   pos.close();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 }
}

class Consumer extends Thread
{
 private PipedInputStream pis;
 Consumer(PipedInputStream pis)
 {
  this.pis=pis;
 }
 public void run()
 {
  try
  {
   byte[] buf=new byte[100];
   int len=pis.read(buf);
   System.out.println(new String(buf,0,len));
   pis.close();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 }
}

=================================================================================
              Java I/O库的设计原则

 Java的I/O库提供了一个称做链接的机制，可以将一个流与另一个流首尾相接，形成一个流管道的链接。
 这种机制实际上是一种被称做为Decorator(装饰)的设计模式的应用。
 
 通过流的链接，可以动态的增加流的功能，而这些功能的增加是通过组合一些流的基本功能而动
 态获取的。

 我们要获取一个I/O对象，往往需要产生多个I/O对象，这也是Java I/O库不大容易掌握的原因，
 但在I/O库中的Decorator模式的运用，给我们提供了实现上的灵活性。

 I/O流的链接图(如下)

  Reader和Writer

 Java程序语言使用Unicode来表示字符串和字符。
 Reader和Writer这两个抽象类主要用来读写字符流。

 java.io包中Reader的类层次(如下图)

 java.io包中Writer的类层次(如下图)


 code:
import java.io.*;
class StreamTest
{
 public static void main(String[] args)throws Exception
 {
  /*
  FileOutputStream fos = new FileOutputStream("1.txt");
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  BufferedWriter bw = new BufferedWriter(osw);
 
  bw.write("http://www.yahoo.com.cn");
  bw.close();
 
  FileInputStream fis = new FileInputStream("1.txt");
  InputStreamReader isr = new InputStreamReader(fis);
  BufferedReader br = new BufferedReader(isr);
  System.out.println(br.readLine());
  br.close();
  */
  //InputStreamReader/OutputStreamWriter是一个中间过度类,连接字符和字符串
  InputStreamReader isr = new InputStreamReader(System.in);
  BufferedReader br = new BufferedReader(isr);
  String strLine;
  while((strLine=br.readLine())!=null)
  {
   System.out.println(strLine);
  }
  br.close();
 }
}

            字符集的编码

 ASCII(American Standard Code for Information Interchange,美国信息互换标准代码),是基
 于常用的英文字符的一套电脑编码系统。我们知道英文中经常使用的字符，数字符号被计算机
 处理时都是以二进制编码的形式出现(bit)二进制数对应。其最高位是0，相应的十进制数是0-127
 如，数字1，有一些制表符和其他符号组成。ASCII是现金最通用的单字节编码系统。

 GB2312： GB2312码是中华人民共和国国家汉字信息交换用编码，全称《信息交换用汉字编码字
 符集-基本集》。主要用于给每一个中文字符指定相应的数字，也就是进行编码。一个中文字符
 用两个字节的数字来表示，为了和ASCII码有所区别，将中文字符每一个字节的最高位置都用1
 来表示。

 GBK：为了对更多的字符进行编码，国家又发布了新的编码系统GBK（GBK的K是“扩展”的汉语
 拼音的第一个字母）。在新的编码系统里，除了完全兼容GB2312外，还对繁体中文，一些不常用
 的汉字和许多符号进行了编码。

 ISO-8859-1：是西方国家所使用的字符编码集，是一种单字节的字符集，而英文实际上只用了其
 中数字小于128的部分。

 Unicode: 这是一种通用的字符集，对所有语言的文字进行统一编码，对每一个字符都采用2个字节
 来表示，对于英文字符采取前面加“0”字节的策略实现等长兼容。如"a"的ASCII码为0x61,
 UNICODE就为0x00,0x61。

 UTF-8: Elight-bit UCS Transformation Format,(UCS,Universal Character Set,通用字符集,
 UCS是所有其他字符集标准的一个超集)。一个7位的ASCII码值，对应的UTF码是一个字节，如果
 字符是0x0000，或在0x0080与0x007f之间，对应的UTF码是两个字节，如果字符在0x0800与0xffff
 之间，对应的UTF码是三个字节。
 编码：将一个Unicode码转换为本地字符表示的过程为编码。
  解码：将一个字节转换为一个字符（用Unicode表示），这个过程叫解码。
        [简单的说去获取一个Unicode码就是解码]
 code:

import java.util.*;
import java.nio.charset.*;
class CharsetTest
{
 public static void main(String[] args)throws Exception
 {
  /*
  Map m=Charset.availableCharsets();
  Set names=m.keySet();
  Iterator it =names.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  Properties pps=System.getProperties();
  //pps.list(System.out);
  pps.put("file.encoding","ISO-8859-1");
  int data;
  byte[] buf=new byte[100];
  int i=0;
  while((data=System.in.read())!='q')
  {
   buf[i]=(byte)data;
   i++;
  }
  String str=new String(buf,0,i);
  //String strGBK=new String(str.getBytes("ISO-8859-1"),"GBK");
  //System.out.println(strGBK);
  System.out.println(str);
 }
}

     RandomAccessFile

  RandomAccessFile类同时实现了DataInput和DataOutput接口，提供了对文件随机存取的功能，
  利用这个类可以在文件的任何位置读取或写入数据。
  RandomAccessFile类提供了一个文件指针，用来标志要进行读写操作的下一位数据的位置。

 
 code:
import java.io.*;
class RandomFileTest
{
 public static void main(String[] args)throws Exception
 {
  Student s1 = new Student(1,"zhangsan",98.5);
  Student s2 = new Student(2,"lisi",90.5);
  Student s3 = new Student(3,"wangwu",78.5);
 
  RandomAccessFile rsf=new RandomAccessFile("student.txt","rw");  //存取模式rw
  s1.WriteStudent(rsf);
  s2.WriteStudent(rsf);
  s3.WriteStudent(rsf);
 
  Student s =new Student();
  rsf.seek(0); //把文件指针移到文件首
  for(long i=0;i<rsf.length();i=rsf.getFilePointer())
  {
   s.ReadStudent(rsf);
   System.out.println(s.num+":"+s.name+":"+s.score);
  }
  rsf.close();
 }
}

class Student
{
 int num;
 String name;
 double score;
 Student()
 {
 
 }
 Student(int num,String name,double score)
 {
  this.num=num;
  this.name=name;
  this.score=score;
 }
 public void WriteStudent(RandomAccessFile raf)throws Exception
 {
  raf.writeInt(num);
  raf.writeUTF(name);
  raf.writeDouble(score);
 }
 public void ReadStudent(RandomAccessFile raf)throws Exception
 {
  raf.readInt();
  raf.readUTF();
  raf.readDouble(); 
 }
}

           对象序列化

 .将对象转换为字节流保存起来，并在日后还原这个对象，这种机制叫做对象序列化。
 .将一个对象保存到永久存储设备上称为持续性。
 .一个对象要想能够实现序列化，必须实现Serializable接口或Externalizable接口。
 .当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员变量和静态的
  成员变量。
 .如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
 .如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，
  并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient,那么对象
  仍然可以序列化。

 code:
import java.io.*;
class ObjectSerialTest
{
 public static void main(String[] args)throws Exception
 {
  Employee e1 = new Employee("zhangsan",20,2800.50);
  Employee e2 = new Employee("lisi",22,25000.50);
  Employee e3 = new Employee("wangwu",23,12800.50);
  Employee e4 = new Employee("blovesaga",22,3800.50);
 
  FileOutputStream fos=new FileOutputStream("employee.txt");
  ObjectOutputStream oos=new ObjectOutputStream(fos);
  oos.writeObject(e1);
  oos.writeObject(e2);
  oos.writeObject(e3);
  oos.writeObject(e4);
  oos.close();
 
  FileInputStream fis = new FileInputStream("employee.txt");
  ObjectInputStream ois =new ObjectInputStream(fis);
  Employee e;
  for(int i=0;i<4;i++)
  {
   e=(Employee)ois.readObject();
   System.out.println(e.name+":"+e.age+":"+e.salary);
  }
  ois.close();
 }
}

class Employee implements Serializable
{
 String name;
 int age;
 double salary;
 transient Thread t1 =new Thread();
 Employee(String name,int age,double salary)
 {
  this.name=name;
  this.age=age;
  this.salary=salary;
 }
 //可以写private void readObject()方法来控制我们自己想要实现的
 private void writeObject(java.io.ObjectOutputStream oos)throws Exception
 {
  //例如我们自己写想要显示的顺序和那些需要显示
  oos.writeInt(age);
  oos.writeUTF(name);
  System.out.println("Write Object");
 }
 private void readObject(java.io.ObjectInputStream ois)throws Exception
 {
  //按照写入的顺序来读取
  age=ois.readInt();
  name=ois.readUTF();
  System.out.println("Read Object");
 }
}

所谓框架就是一个类库的集合。集合框架就是一个用来表示和操作集合的统一框架，包含了实现
集合的接口和类。
 
 集合框架中的接口

 .Collection: 集合层次中的根接口，JDK没有提供这个接口直接的实现类。
 .Set: 不能包含重复的元素。SortedSet是一个按照升序排列元素的Set。
 .List: 是一个有序的集合，可以包含重复的元素。提供了按照索引访问的方式。
 .Map: 包含了key-value对。Map不能包含重复的key。SortedMap是一个按照升序排列key的Map。
 
 集合框架中的实现类
 
 实线表示继承类，虚线表示实现类。
 (图如下)

.ArrayList: 我们可以将其看做是能够自动增长容量的数组。
 .利用ArrayList的toArray()返回一个数组。
 .Arrays.asList()返回一个列表。
 .迭代器(Iterator)给我们提供了一种通用的方式来访问集合中的元素。

 注意: 从集合类中获取一个数组 toArray(),从数组获取列表利用Arrays.asList()
 例子:
import java.util.*;
class ArrayListTest
{
 public static void printElement(Collection c)
 {
  Iterator it = c.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
 }
 public static void main(String[] args)
 {
  ArrayList a = new ArrayList();
  /*
  a.add("abc");
  a.add("def");
  a.add("hjk");
  */
 
  a.add(new Point(1,1));
  a.add(new Point(2,2));
  a.add(new Point(3,3));
  /*
  Object[] o;
  o=a.toArray();  //将集合类转换为数组
  for(int i=0;i<o.length;i++)
  {
   System.out.println(o[i]);
  }
 
  List b = new ArrayList();
  b=Arrays.asList(o);
  System.out.println(b);
 
  for(int i=0;i<a.size();i++)
  {
   System.out.println(a.get(i));
  }
 
  System.out.println(a);
  System.out.println(a);
  */
 
  /*
  Iterator it = a.iterator();
   如果要删除元素，必须先调用next方法
  it.next();
  it.remove();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  //迭代器的作用: 提供一组通用的访问方式
  printElement(a);
 }
}

class Point
{
 int x, y;
 Point(int x, int y)
 {
  this.x=x;
  this.y=y;
 }
 public String toString()
 {
  return "x="+x+","+"y="+y;
 }
}

 Collections类

 .排序: Collections.sort(); [区别与Arrays.sort()]
  (1) 自然排序(natural ordering);
  (2) 实现比较器(Comparator)接口。
 .取最大和最小的元素: Collections.max(),Collections.min();
 .在已排序的List中搜索指定的元素: Collections.binarySearch()。

 代码示例:
import java.util.*;
class ArrayListTest
{
 public static void printElement(Collection c)
 {
  Iterator it = c.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
 }
 public static void main(String[] args)
 {
  /*
  ArrayList a = new ArrayList();
 
  a.add("abc");
  a.add("def");
  a.add("hjk");
 
 
  a.add(new Point(1,1));
  a.add(new Point(2,2));
  a.add(new Point(3,3));
 
  Object[] o;
  o=a.toArray();  //将集合类转换为数组
  for(int i=0;i<o.length;i++)
  {
   System.out.println(o[i]);
  }
 
  List b = new ArrayList();
  b=Arrays.asList(o);
  System.out.println(b);
 
  for(int i=0;i<a.size();i++)
  {
   System.out.println(a.get(i));
  }
 
  System.out.println(a);
  System.out.println(a);
  */
 
  /*
  Iterator it = a.iterator();
   如果要删除元素，必须先调用next方法
  it.next();
  it.remove();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  //迭代器的作用: 提供一组通用的访问方式
  //printElement(a);
 
  Student s1 = new Student(1,"zhangsan");
  Student s2 = new Student(2,"lisi");
  Student s3 = new Student(3,"wangwu");
  Student s4 = new Student(3,"blovesaga");
 
  ArrayList a = new ArrayList();
  a.add(s1);
  a.add(s2);
  a.add(s3);
  a.add(s4);
 
  //Collections.sort(a);
  Collections.sort(a,new Student.StudentComparator());
  printElement(a);
 }
}

class Point
{
 int x, y;
 Point(int x, int y)
 {
  this.x=x;
  this.y=y;
 }
 public String toString()
 {
  return "x="+x+","+"y="+y;
 }
}

class Student implements Comparable
{
 int num;
 String name;
 //实现比较器，它总是和我们的一个类相关,用内部类
 static class StudentComparator implements Comparator  //为了调用方便声明为静态的
 {
  public int compare(Object o1,Object o2)
  {
   Student s1 = (Student)o1;
   Student s2 = (Student)o2;
   int result=s1.num > s2.num ? 1: (s1.num==s2.num ? 0 : -1);
   if(result==0)
   {
    return s1.name.compareTo(s2.name);
   }
   return result;
  }
 }
 Student(int num,String name)
 {
  this.num=num;
  this.name=name;
 }
 public int compareTo(Object o)
 {
  Student s=(Student)o;
  return num > s.num ? 1 :( (num==s.num) ? 0 : -1);
 }
 
 public String toString()
 {
  return +num+":"+name;
 }
}

------------->>设计模式<<-------------
1> 在我们进行程序设计时,逐渐形成了一些典型问题和问题解决方案,这就是软件模式。
2> 每一个模式描述了一个在我们程序设计中经常发生的问题,以及该问题的解决方案。
3> 当我们碰到模式所描述的问题，就可以直接用相应的解决方法去解决这个问题,这就是设计模式。
<$>单例(Singleton)模式
1> 一个类只有一个实例，而且自行实例化并像整个系统提供这个实例，这个类称为单例类。
2> 单例类的一个重要特点就是类的构造方法是私有的,从而避免了外部用利用构造方法直接创建多个实例。
   如:Runtime类。

单例类的实现:(code)
class Singleton
{
 private static final Singleton st=new Singleton();
 private Singleton()
 {
 
 }
 public static Singleton getInstance()
 {
  return st;
 }
}

class Test
{
 public static void main(String[] args)
 {
  int i=3;
  Integer in=new Integer(i);
  int j=in.intValue();
  System.out.println(j);
  String str=in.toString();  //把Integer对象转换为String类型
  System.out.println("str="+str);
 
  String str1="123";
  System.out.println(Integer.valueOf(str1));  //把String类型转换为Integer类型
 
  boolean b1=false;
  Boolean b=new Boolean(b1);
  String s1=b.toString();
  System.out.println(s1);
 
  String s2="NO";
  System.out.println(Boolean.valueOf(s2));
 }
}

*****************Class*********************
1> 在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后,在生成
   的.class文件中,就会产生一个Class对象，用于表示这个类的类型信息。
2> 获取Class实例的方法有三种:
   <1>利用对象调用getClass()方法获得该对象的Class实例。
   <2>使用Class类的静态方法forName(),用类的名字获取一个Class的是实例。
   <3>运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以用.TYPE来获取相应的
      基本数据类型的Class实例。
   <4>在运行期间，如果我们要产生某个类的对象，JAVA虚拟机(JVM)会检查该类型的Class对象是否被
      加载，如果没有加载,JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已
      经被加载到内存，就可以用它来产生该类型所有的对象。
   <5>newInstance()调用类中缺省的构造方法。(好处是我们在不知道类的名字的情况下去创造一个实例）
import java.lang.reflect.*;       //子包必须手动导入
class ClassTest
{
 public static void main(String[] args)//throws Exception
 {
  /*
  Point pt=new Point();             
  Class c1=pt.getClass();//利用对象调用getClass()方法获得该对象的Class实例
  System.out.println(c1.getName());
 
  Class c2=Class.forName("Point");//使用Class类的静态方法forName(),用类的名字获取一个Class的是实例
  System.out.println(c2.getName());
 
  Class c3=Point.class;//运用.class的方式来获取Class实例
  System.out.println(c3.getName());
 
  Class c4=Integer.TYPE;//封装类用.TYPE来获取相应的基本数据类型的Class实例。
  System.out.println(c4.getName());
  */
  /*
  System.out.println("before new Point()");
  new Point();
  System.out.println("after new Point()");
  Class.forName("Line");
  */
  /*
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Point pt=(Point)c.newInstance();
   pt.output();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  */
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Constructor[] cons=c.getDeclaredConstructors();
   /*
   for(int i=0;i<cons.length;i++)
   {
    System.out.println(cons[i]);
   }
   Method[] ms=c.getDeclaredMethods();
   for(int i=0;i<ms.length;i++)
   {
    System.out.println(ms[i]);
   }*/
   Class[] params=cons[0].getParameterTypes();
   Object[] paramValues=new Object[params.length];
   for(int i=0;i<params.length;i++)
   {
    if(params[i].isPrimitive())
    {
     paramValues[i]=new Integer(i+3);
    }
   }
   Object o=cons[0].newInstance(paramValues);
   Method[] ms=c.getDeclaredMethods();
   ms[0].invoke(o,null);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 
 }
}

class Point
{
 static
 {
  System.out.println("Loading Point");
 }
 int x,y;
 void output()
 {
  System.out.println("x="+x+","+"y="+y);
 }
 Point(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
}

class Line
{
 static
 {
  System.out.println("Loading Line");
 }
}

class Student implements Cloneable
{
 Professor p;
 String name;
 int age;
 Student(String name, int age,Professor p)
 {
  this.name=name;
  this.age=age;
  this.p=p;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}
改变学生s2的教授信息，打印s1教授信息,结果为:name=feifei,age=30.产生这个结果是因为String是一个常量类型.
 
深克隆
code:
class DeeplyClone
{
 public static void main(String[] args)
 {
   Professor p=new Professor("feiyang",23);
   Student s1=new Student("zhangshan",18,p);
   Student s2=(Student)s1.clone();
   s2.p.name="Bill.Gates";
   s2.p.age=30;
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
 }
}
class Professor implements Cloneable
{
 String name;
 int age;
 Professor(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}

class Student implements Cloneable
{
 Professor p;
 String name;
 int age;
 Student(String name, int age,Professor p)
 {
  this.name=name;
  this.age=age;
  this.p=p;
 }
 public Object clone()
 {
  //Object o=null;
  Student o=null;
  try
  {
   o=(Student)super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  o.p=(Professor)p.clone();
  return o;
 }
}
打印结果为:name=Bill.Gates,age=30,这就是深克隆.

1> 在Java中所有的数组都有一个缺省的属性length，用于获取数组元素的个数。
2> 数组的复制: System.arraycopy()。
3> 数组的排序: Arrays.sort()。
4> 在已排序的数组中查找某个元素：Arrays.binarySearch()。
具体的看看下面的2个例子:
code1:
class ArrayTest
{
 public static void main(String[] args)
 {
  /*数组的copy
  int[] num1=new int[]{1,2,3};
  int[] num2=new int[3];
  System.arraycopy(num1,0,num2,0,num1.length);
  for(int i=0;i<num2.length;i++)
  {
   System.out.println(num2[i]);
  }
  */
  //引用类型的数组copy
  Point[] pts1=new Point[]{new Point(1,1),new Point(2,2),new Point(3,3)};
  Point[] pts2=new Point[3];
  System.arraycopy(pts1,0,pts2,0,pts1.length);
  for(int i=0;i<pts2.length;i++)
  {
   System.out.println("x="+pts2[i].x+","+"y="+pts2[i].y);
  }
  /*
  *因为引用类型传递的是引用的拷贝，所以我们修改pts2数组的第二个点的坐标，
  *当我们打印pts1数组的第一个点的坐标时，它的坐标点已经被修改为(5,5)了
  pts2[1].x=5;
  pts2[1].y=5;
  System.out.println("x="+pts1[1].x+","+"y="+pts1[1].y);
  */
 }
}

class Point
{
 int x, y;
 Point(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
}

code2:
import java.util.*;
class TestArray
{
 public static void main(String[] args)
 {
  /*
  int[] num=new int[]{3,2,1};
  Arrays.sort(num);
  for(int i=0;i<num.length;i++)
  {
   System.out.println(num[i]);
  }
  int index=Arrays.binarySearch(num,3);
  System.out.println("index="+index);
  System.out.println("Element="+num[index]);
  */
  Student[] ss=new Student[]{new Student("zhangshan",1),
                            new Student("lisi",2),
                            new Student("wangwu",3),
                            new Student("mybole",3)};
   Arrays.sort(ss);
   for(int i=0;i<ss.length;i++)
   {
    System.out.println(ss[i]);
   }
   int index=Arrays.binarySearch(ss,new Student("lisi",2));
   System.out.println("name="+ss[index].name+","+"index="+index);
 }
}

class Student implements Comparable
{
 String name;
 int num;
 Student(String name,int num)
 {
  this.name=name;
  this.num=num;
 }
 public String toString()
 {
  return "name="+name+","+"number="+num;
 }
 public int compareTo(Object o)  //对于Object[]排序要求实现Comparable接口
 {
  Student s=(Student)o;
  //return num>s.num ? 1 :(num==s.num ? 0 : -1);
  int result=num>s.num ? 1 :(num==s.num ? 0 : -1);//按名字排序
  if(0==result)
  {
   result=name.compareTo(s.name);
  }
  return result;
 }
}

F:\Java Develop>java DoMain
Animal breathe!
Animal breathe!
(这说明派生类继承了父类的所有方法和成员变量.)

方法的覆盖(override)
在子类中定义一个与父类同名,返回类型,参数类型均相同的一个方法,称为方法的覆盖,方法的覆盖发生在子类与父类之间.
code:
class Animal
{
 int height,weight;
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}
class Fish extends Animal
{
 int weight,height;   //隐藏了父类的weight,height;
 void breathe()  //override method breathe()
 {
  super.breathe();  //用super调用父类的构造方法
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 public static void main(String[] args)
 {
 // Animal an=new Animal();
  Fish fn=new Fish();
 
  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
 }
}
输出结果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Fish bubble

特殊变量super
* 使用特殊变量super提供对父类的访问
* 可以使用super访问父类被子类隐藏的变量或覆盖的方法
* 每个子类构造方法的第一条语句都是隐含的调用super,如果父类没有这种形式的构造函数就会报错.
code:
class Animal
{
 int height,weight;
 Animal()
 {
  System.out.println("Animal construct");
 }
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}

class Fish extends Animal
{
 Fish()
 {
  System.out.println("Fish construct");
 }
 void breathe()  //override method breathe()
 {
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 public static void main(String[] args)
 {
  //Animal an=new Animal();
  Fish fn=new Fish();
 
  //an.breathe();
  //fn.breathe();
  //fn.height=30;
  //fn.weight=20;
 }
}
输出结果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal construct
Fish construct



 通过覆盖父类的方法来实现,在运行时根据传递对象的引用,来调用相应的方法.
code:
class Animal
{
 int height,weight;
 Animal()
 {
  System.out.println("Animal construct");
 }
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}

class Fish extends Animal
{
 Fish()
 {
  System.out.println("Fish construct");
 }
 void breathe()  //override method breathe()
 {
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 static void fn(Animal an)
 {
  an.breathe();
 }
 public static void main(String[] args)
 {
  //Animal an=new Animal();
  Fish fh=new Fish();
  Animal an;
  an=fh;
  DoMain.fn(an);
 }
}

第一，谈谈 final ， finally ， finalize 的区别？

Final ：修饰符（关键字）如果一个类被声明为 final ，意味着它不能再派生出新的子类,不能作为父类被继承。因此一个类不能既被声明为 abstract 的，又被声明为 final 的。将变 量或方法声明为 final ，可以保证它们在使用中不被改变。被声明为 final 的变量必须在声 明时给定初值，而在以后的引用中只能读取，不可修改。被声明为 final 的方法也同样只能 使用，不能重载 finally ？再异常处理时提供 finally{} 块来执行任何清除操作。如果抛出一个异常，那么 相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。 finalize ：方法名。 Java 技术允许使用 finalize （）方法在垃圾收集器将对象从内存中
清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时 对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 fi nalize （）方法以整理系统资源或者执行其他清理工作。 finalize （） 方法是在垃圾收集 器删除对象之前对这个对象调用的。
 

第二， Anonymous Inner Class （匿名内部类） 是否可以 extends （继承）其它类，是否 可以 implements （实现） interface （接口）？

匿名的内部类是没有名字的内部类。不能 extends （继承） 其它类，但一个内部类可以作 为一个接口，由另一个内部类实现。

第三， Static Nested Class 和 Inner Class 的不同，说得越多越好（面试题有的很笼统）？
 
Nested Class （一般是 C++ 的说法）， Inner Class （一般是 JAVA 的说法）。 Java 内部类
与 C++ 嵌套类最大的不同就在于是否有指向外部的引用上。
具体可见 http ： //www.frontfree.net/articles/services/view.asp ?id=704&page=1  注:静态内部类（ Inner Class ）意味着 1 创建一个 static 内部类的对象，不需要一个外部类对象,2 不能从一个 static 内部类的一个对象访问一个外部类对象。

第四， & 和 && 的区别？
 
& 是位运算符。 && 是布尔逻辑运算符。

第五， HashMap 和 Hashtable 的区别？
 
都属于 Map 接口的类，实现了将惟一键映射到特定的值上。 HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。 Hashtable 类似于 HashMap ，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为 它是同步的。

第六， Collection 和 Collections 的区别？

Collections 是个 java.util 下的类，它包含有各种有关集合操作的静态方法.Collection 是个 java.util 下的接口，它是各种集合结构的父接口。

第七，什么时候用 assert ？

断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true 。如果表达式 计算为false ，那么系统会报告一个 AssertionError 。它用于调试目的:assert(a > 0); // throws an AssertionError if a <= 0 ： 断言可以有两种形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 Str ing 消息.断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：
javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用 断言.可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言 ，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用 断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

第八， GC 是什么 ? 为什么要有 GC? ( 基础 ) ？

GC 是垃圾收集器。 Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：
System.gc() 
 Runtime.getRuntime().gc()

第九， String s = new String("xyz"); 创建了几个 String Object?
两个对象，一个是 “xyx”, 一个是指向 “xyx” 的引用对象 s 。

第十， Math.round(11.5) 等於多少 ? Math.round(-11.5) 等於多少 ?
Math.round(11.5) 返回（ long ） 12 ， Math.round(-11.5) 返回（ long ） -11;

第十一， short s1 = 1; s1 = s1 + 1; 有什么错 ? short s1 = 1; s1 += 1; 有什么错 ?

short s1 = 1; s1 = s1 + 1; 有错， s1 是 short 型， s1+1 是 int 型 , 不能显式转化为 short 型.可修改为
s1 =(short)(s1 + 1) 。 short s1 = 1; s1 += 1 正确。

第十二， sleep() 和 wait() 有什么区别 ?
搞线程的最爱 sleep() 方法是使线程停止一段时间的方法。在 sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非 (a)“ 醒来 ” 的线程具有更高的优先级， (b) 正在运行的线程因为其它原因 而阻塞。wait() 是线程交互时，如果线程对一个同步对象 x 发出一个 wait() 调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

第十三， Java 有没有 goto?
Goto?java 中的保留字，现在没有在 java 中使用。

第十四，数组有没有 length() 这个方法 ? String 有没有 length() 这个方法？
数组没有 length() 这个方法，有 length 的属性。
String 有有 length() 这个方法。

第十五， Overload 和 Override 的区别。 Overloaded 的方法是否可以改变返回值的类型 ?

方法的重写 Overriding 和重载 Overloading 是 Java 多态性的不同表现。重写 Overriding 是父类与子类之间多态性的一种表现，重载 Overloading 是一个类中多态性的一种表现。如果在 子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding) 。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被 “ 屏蔽” 了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数 类型，则称为方法的重载 (Overloading) 。 Overloaded 的方法是可以改变返回值的类型。

第十六， Set 里的元素是不能重复的，那么用什么方法来区分重复与否呢 ? 是用 == 还是 equ
als()? 它们有何区别 ?
Set 里的元素是不能重复的，那么用 iterator() 方法来区分重复与否。 equals() 是判读两个Set 是否相等。
equals() 和 == 方法决定引用值是否指向同一对象 equals() 在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

第十七，给我一个你最常见到的 runtime exception ？
ArithmeticException, ArrayStoreException, BufferOverflowException,
BufferUnderflowException, CannotRedoException,
CannotUndoException, ClassCastException, CMMException,
ConcurrentModificationException,
DOMException, EmptyStackException, IllegalArgumentException,
IllegalMonitorStateException,
IllegalPathStateException, IllegalStateException,
ImagingOpException,
IndexOutOfBoundsException, MissingResourceException,
NegativeArraySizeException, NoSuchElementException,
NullPointerException, ProfileDataException, ProviderException,
RasterFormatException, SecurityException, SystemException,
UndeclaredThrowableException,
UnmodifiableSetException, UnsupportedOperationException

第十八， error 和 exception 有什么区别 ?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况exception 表示一种设计或实现问题。也就是说,它表示如果程序运行正常,从不会发生的情况.

第十九， List, Set, Map 是否继承自 Collection 接口 ?
List ， Set 是.Map 不是

第二十， abstract class 和 interface 有什么区别 ?

声明方法的存在而不去实现它的类被叫做抽象类（ abstract class ），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。 Abstract 类的子类为它们父类中的所 有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其 行为的其它类可以在类中实现这些方法。
接口（ interface ）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实 现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定 义 static final 成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承 行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换， instanceof 运算符可以用来决定某对象的类是否实现了接口。

第二十一， abstract 的 method 是否可同时是 static, 是否可同时是 native ，是否可同时是 s
ynchronized?
都不能

第二十二,接口是否可继承接口?抽象类是否可实现 (implements) 接口?抽象类是否可继承实体类 (concrete class)?

接口可以继承接口。抽象类可以实现 (implements) 接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

第二十三，启动一个线程是用 run() 还是 start()?
启动一个线程是调用 start() 方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由 JVM 调度并执行。这并不意味着线程就会立即运行。 run() 方法可以产生必须退出 的标志来停止一个线程。

第二十四，构造器 Constructor 是否可被 override?
构造器 Constructor 不能被继承，因此不能重写 Overriding ，但可以被重载 Overloading 。

第二十五，是否可以继承 String 类 ?
String 类是 final 类故不可以继承。

第二十六，当一个线程进入一个对象的一个synchronized 方法后,其它线程是否可进入此对象的其它方法?
不能，一个对象的一个 synchronized 方法只能由一个线程访问。

第二十七，try {} 里有一个 return 语句，那么紧跟在这个 try 后的 finally {} 里的 code 会不会被执行,什么时候被执行，在 return 前还是后 ?
会执行，在 return 前执行。

第二十八，编程题 : 用最有效率的方法算出 2 乘以 8 等於几 ?
有 C 背景的程序员特别喜欢问这种问题。
2 << 3

第二十九，两个对象值相同 (x.equals(y) == true) ，但却可有不同的 hash code ，这句话
对不对 ?
不对，有相同的 hash code 。

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递 ? 是值传递。 Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

第三十一， swtich 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上 ?

switch （ expr1 ）中， expr1 是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int 、 short 、 char 或者 byte 。 long,string 都不能作用于 swtich 。

第三十二，编程题 : 写一个 Singleton 出来？
Singleton 模式主要作用是保证在 Java 应用程序中，一个类 Class 只有一个实例存在。

一般 Singleton 模式通常有几种种形式 :
第一种形式 : 定义一个类，它的构造函数为 private 的，它有一个 static 的 private 的该类变量，在类初始化时实例话，通过一个 public 的 getInstance 方法获取对它的引用 , 继而调用其中的方法。
public class Singleton {
private Singleton(){}
// 在自己内部定义自己一个实例，是不是很奇怪？
// 注意这是 private 只供内部调用
private static Singleton instance = new Singleton();
// 这里提供了一个供外部访问本 class 的静态方法，可以直接访问
public static Singleton getInstance() {
　　 return instance; 　　
}
}

第二种形式 :

public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
// 这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
// 使用时生成实例，提高了效率！
if (instance==null)
　　 instance ＝ new Singleton();
return instance; 　　 }
}

其他形式 :
定义一个类，它的构造函数为 private 的，所有方法为 static 的。
一般认为第一种形式要更加安全些

第三十三 Hashtable 和 HashMap ？
Hashtable 继承自 Dictionary 类，而 HashMap 是 Java1.2 引进的 Map interface 的一个实现

HashMap 允许将 null 作为一个 entry 的 key 或者 value ，而 Hashtable 不允许还有就是， HashMap 把 Hashtable 的 contains 方法去掉了,改成 containsvalue 和 containsKey.因为contains 方法容易让人引起误解。

最大的不同是,Hashtable 的方法是Synchronize 的,而HashMap 不是，在多个线程访问 Hashtable 时，不需要自己为它的方法实现同步，而 HashMap 就必须为之提供外同步.Hashtable 和 HashMap 采用的 hash/rehash 算法都大概一样，所以性能不会有很大的差异。

       blovesage写下这段代码我们期望得到应该找回的零钞0.90,但是当运行后他发现数据不兑，运行结果为:0.8999999999999999,与预期的0.90不一样。为什么呢?搞了半天原因在于1.1这个数不能被精确的表示为一个double,因此被表示为最接近它的double值.该程序从2中减去这个值得.遗憾的是,这个结果打印出来并不是接近0.9的double值.这说明: 并不是所有的小数都可以用二进制浮点数精确表示.二进制浮点对于货币计算是非常不适合的.
      要解决这个问题有两个办法:一是使用某种整数类型,例如int或long,并且分单位来计算.如下:
System.out.println((200-110)+"fen");
结果为90分.二是使用执行小数运算的BigDecimal.它还可以通过JDBC与SQL DECIMAL类型进行互操作.这里需要注意的是: 一定要用BigDecimal(String)构造器,而千万不要用BigDecimal(double).后一个构造器将用它的参数值来创建一个实例.例如new BigDecimal(.1),它将返回一个BigDecimal,也即0.10000000000000000555111512312578270211815834041015625.正确使用我们就可以得到期望的结果0.90:
code:
import java.math.BigDecimal;
class Change
{
 public static void main(String[] args)
 {
  System.out.println(new BigDecimal("2.00").
                     subtract(new BigDecimal("1.10")));
 }
}
Print:
F:\Java Develop>java Change
0.90

F:\Java Develop>java Multicast
65535
啊,这么会是65535?
oh,my god!有条规则: 如果最初的数值类型是有符号的,那么就执行符号扩展;如果他是char,那么不管它将要被转换成什么类型,都执行另扩展.
   用这条规则来44看.因为byte是有符号的,所以在将byte数值-1转换成char时.会发生符号扩展.作为结果的char数值16位就都被置位了,因此它等于2^16-1(2的16次方减1),就是65535.从char到int的转型也是一个扩展,
用规则来说它将执行另扩展,而不是符号扩展.作为int的结果数值就是65535和打印的一样.
   从这个例子我们得到一个教训:如果通过观察不能确定程序将要做什么,那么它做的就很有可能不是你想要的.

class Indecisive
{
 public static void main(String[] args)
 {
  System.out.println(decisive());
 }
 static boolean decisive()
 {
  try
  {
   return true;
  }
  finally
  {
   return false;
  }
 }
}
   你可能认为这个程序不合法。毕竟，decisive方法不能同时返回true和false。如果你尝试一下，就会发现它
编译时没有任何错误，并且它打印的是false。为什么呢?
    原因在于就是在：在一个try-finally语句中，finally语句块总是在控制权离开try语句块时执行。无论try
语句块是正常结束的，还是意外结束，情况都是如此。在一条语句或一个语句块抛出一个异常，或者对某个封闭类型语句执行了一个break或continue，或是像这个程序一样执行了一个return时，将发生意外结束。之所以称为意外结束，是因为它们阻止程序按顺序执行下面的语句。
    当try语句块和finally语句块都意外结束时，在try语句块中引发意外结束的原因将被丢弃，而整个try-finally
语句意外结束的原因将与finally语句块意外结束的原因相同。在这个程序中，在try语句块中的return语句所
引发的意外结束将被丢弃，而try-finally语句意外结束是由finally语句块中的return造成的。简单的讲，程序
尝试着(try)返回(return)true,但是它最终(finally)返回(return)的是false。
    总之，每一个finally语句块都应该正常结束，除非抛出不受检查的异常。千万不要用return,break,continue或throw来退出finally语句块，并且千万不要允许让受检查的异常传播到finally语句块之外。