j2se笔记-面试知识点

其他比较好的面试资料：

125条常见的java面试笔试题大汇总：   http://www.bitscn.com/java/base/200709/110116.html
你能过关吗?J2EE面试题集锦(附答案)： http://www.hackhome.com/InfoView/Article_118910.html

 

☆☆☆☆☆☆☆☆☆☆☆ 数据类型 表达式 循环 数组 ☆☆☆☆☆☆☆☆☆☆☆☆

●java中布尔值只能用true false来赋值，c语言可用0表示false，非0表示true
 boolean flag=true;
 flag = 0; //java编译错误
●字符型：char 一般使用单引号
 char c ='e';
 ☆因为java使用的是16进制编码，故可用16进制表示字符：char c2 = '/u0066';
 ☆还可使用转义字符将其后的字符转变成其他含义：
  char c3 = '/n';  //表示换行
  char c4 = '/t';  //制表符，按一下tab键一样
  char c4 = '/'';  //打印单引号
  char c4 = '/"';  //打印双引号
  char c4 = '//';  //输出/
●java中各变量默认值是多少？？？
●java运算符：主要注意以下：
 ☆布尔逻辑运算符：&(逻辑与),|(逻辑或),^(逻辑异或) 还有中功能就是位运算符：按位与，按位或，按位异或。
     当然提到位运算，还有个运算符是~，它表示按位取反。
     然后有三个位移运算符：
    左移：<<           向左移动，低位补0。
    带符号右移：>>     向右移动，正数高位补0，负数高位补1。
    无符号右移：>>>    向右移动，位补0。

     &&(短路与),||(短路或),!(逻辑非)  ; eg:boolean b=!true;b为false。

  注意二者区别：&(逻辑与),|(逻辑或),^(逻辑异或)是一组类型的，他们还可以操作数值型
    此处注意&&，||短路运算以及&，|的非短路运算
  
 ☆位运算符：(一般不用管)
 ☆int i=10; int j=20; int k=i/j;           //此时k等于0
   int i=10; int j=20; float k=i/j;         //此时k等于0.0
   int i=10; int j=20; flaot k=(float)i/j;  //此时k等于0.5

 ☆short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
   s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1)
   short s1 = 1; s1 += 1正确。
 ☆赋值运算时，如果=号两边数据类型不一致，则要进行数据类型转换;
 byte,char,short>int>int>long
 int>float
 long>double
 float>double
 ☆特例：可以将整型常量直接赋值给byte，char，等类型变量，只要不超出其范围
  byte b =26；合法 byte b2= 2590；不合法，超出范围
 ☆当整型等和字符串+号连接时，整型将自动转换为字符串再和字符串连接
  System.out.println("i+j"+13+26);    结果为i+j1326
  System.out.println("i+j"+(13+26));  结果为i+j39
●switch(expr)语句需要注意的地方;
 ☆其中的expre表达式类型必须是如下类型：byte，short，char，int之一。就是long都不行。
 ☆case子句值必须是常量。
●循环语句注意区分break 和continue：
 break是跳出当前循环体
 continue是跳出当前循环，然后进行下一轮的循环
●数组定义时注意：
 ☆因为数组是引用类型，所以在给数组赋值或者使用数组前一定要先是用new 开辟空间
   也就是凡是引用类型变量使用它之前都要先new开辟空间。
   int i[] ;int i[0]=11;这时就发生错误，int i[] ;i=new int[10];System.out.println(i[0]);输出0
 ☆数组的大小不能在声明时定义，因为数组变量是在栈内存中声明的，而为数组开辟空间时是在堆内存中。
   同样，给数组赋值操作也肯定是在堆内存中完成的
 ☆引用传递，传递的就是内存地址的使用权
 ☆我自己一般就是数组声明，开辟空间和赋值分开操作，这样自己很明白，别人也很清楚，
 ☆当然，数组还有种静态初始化方法：就是3个步骤一步完成int i[] ={12,25,36,59,6};
 这里提到了属性初始化，顺便说一下java个基本数据类型默认值是：
 基本类型            默认值
 boolean             false
 char                /u0000’ (null)
 byte                (byte)0
 short               (short)0
 int                 0
 long                0L
 float               0.0f
 double              0.0d

●方法有重写和重载
 ☆重载是方法名相同，参数个数或者参数类型不同。这也是java多态的一种：同一个方法名方法完成不同功能
 ☆有方法就有参数传递。基本类型参数传递的方式都是值传递
 ☆System.arraycopy()方法提供了数组元素复制功能

☆☆☆☆☆☆☆☆☆☆☆ 数据类型 表达式 循环 数组 ☆☆☆☆☆☆☆☆☆☆☆☆

☆☆☆☆☆☆☆☆☆☆☆☆  面 向 对 象  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

●
 ☆==和equals()，前者比较的是内存地址是否相同，后者比较的单纯就是值。
 ☆String str1 ="sex";//就创建了一个对象，该对象位于java常量池中
   String str2 =new String(sex);//创建了两个对象，还有一个是位于堆内存中
   但是一定注意：当作为参数传值时，如果是str1则是值传递，如果传递的是str2则是引用传递，
   可以把"sex"看着常量，因为String对象一旦被创建了就不会被改变了
 ☆this关键字主要用于访问本类对象中的方法，属性等，当访问构造函数时，一定要放在方法内部第一行
   因为构造方法本身必须在第一行被调用:this()//调用本类的无餐构造函数
 ☆数组一般使用较少，因为数组个数固定（缺点）
 ☆栈内存保存的是对象名称，堆内存保存的是对象的具体内容（属性）
●代码块
 ☆普通代码块   一般直接写在方法中的代码块，用{ }直接围住即可，定义的变量也只在该{}中有效
 ☆构造代码块   而写在类中的{ }代码块就是构造块了，会比构造方法先执行的。执行多次
 ☆静态块       也是写在类中的，但是通过static{ }声明，而且优先执行权比构造块和构造函数都高，它作用主要就是
         如果内中有静态的属性，就使用静态块初始化。不管类实例化几次，静态块中代码只执行一次
 ☆同步代码块   （多线程使用）
● System.exit(1);表示程序退出，不再执行
●子类的无参构造方法会默认产生一个调用父类的构造方法：super();
●子类在重写父类方法时，不能拥有比父类更为严格的访问权限
 ☆默认情况下是默认权限default：public>default>private
 
 类的访问说明符：
 public   如果你想让其他包中的类访问你当前的类，那么就必须给类加上public
   当然，当你访问其他包中的类时别忘了用import导入哦。
 default 默认情况下，类是只能在当前包中被访问。
 类的其他修饰符
 final    此关键字表示当前类不能被继承，她是一个最终类。如果你不想类被继承修改，
 就用final吧。例如 String 就是一个最终类。
 abstract 抽象类

 方法说明符：
 方法的访问说明符：
 (1) Public    不同包中的任何类都可以相互访问
 (2) protected  如果一个子类的父类是不同包中的类，但因为父类方法使用了protected
  关键字，那么不同包中的子类就可以访问父类的该方法咯。
 (3) default    只能在同一包中被访问。例如一个子类的父类是不同包中的类，那么这
  个子类都无法访问父类中的默认方法。因为子类和父类分属于不同包中。
 (4) private    只能在同一个类中访问，就是子类继承了父类，父类中的私有方法都不
  能被继承到子类，所以就是子类也无法访问到父类的私有方法。

●注意重写和重载：前者是发生在子类中，后者是发生在同一个类中.重载可以改变返回类型。
●final:被final标记的类不能被继承，方法也不能被子类重写，final标记的变量即是常量
●在抽象类中抽象类和类中抽象方法都必须使用abstract关键字定义，但是在接口中好像就不一样。
●接口可以同时继承多个接口和实现多个接口
●instanceof关键字：A instanceof B   //对象A是否是类B的一个实例，这个一般是在子类重写equeals()方法时使用，
 判断传入的参数是否是当前对象的子类，如果为否，说明两个比较的类没有继承关系，就不能比较，如果这种情况下也经行了比较则抛出Classcastexception异常。如何正确重写该方法呢？？例如现在有个Person类：
public boolean equals(Object obj)
{
 //首先判断是否具有继承关系（有继承关系的类才能比较）例如Person.equals("sex"):抛出Classcastexception异常
 if(!(obj instanceof Person))
 {
  return false;
 }
 Person per1 = this;
 Person per2 = (Person)obj;
 boolean flag = false;
  //然后再看看两个对象是否引用的同一内存地址，是的话也就不用比较了，直接返回true
 if(per1==per2)
 {
  flag=true;
 }
 //最后才是判断对象的属性值是否相等
 else
 {
  if(per1.name.equals(per2.name)&&per1.age.equals(per2.age))
  {
   flag = true;
  }
 }
 return flag;
}
●关于异常：
 error：表示错误，jvm出错，程序无法继续运行。
 Exception：程序运行时出现的错误，可以处理
 finally：当try{}块中有一个return语句时，finally块会执行吗？？如果会，那么什么时候执行？在return前执行。
☆☆☆☆☆☆☆☆☆☆☆☆  面 向 对 象  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

☆☆☆☆☆☆☆☆☆☆☆☆  多 线 程  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
  线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。
●进程和线程区别：
 ☆进程:同时只能做一件事，
 ☆线程：同时可以做多件事，但是一个cpu，同一个时间点只能有一个程序在运行
  线程是"进程"中某个单一顺序的控制流。也被称为轻量进程
   所以多线程需要多线程系统支持才行，但是java程序员只需要关系程序多线程是怎样实现的就可以了
 ☆实现多线程有两种方式，但是注意两种方式的区别。主要是通过Runnable接口实现可以实现多个线程之间资源共享
 ☆注意线程的状态转换
 ☆线程比较重要的方法：
 获得当前线程对象或名称：Thread.currentThread()(因为这是一个静态方法),Thread.currentThread().getName()
 线程休眠：Thread.sleep();  因为sleep()这个方法也是静态的，调用sleep不会释放对象锁。
 线程强制运行：线程对象.join();
 线程中断：线程对象.interrupt()；
 ☆线程共享资源解决方案：同步：synchronized。实现同步两种方式：同步方法和使用synchronized(this){}代码块
   注意使用代码块同步时，一般需要加上（this），this表示对当前操作的线程进行同步，即是为this进行同步
 ☆同步处理不当，会产生不当：死锁
 ☆线程同步经典问题：生产者和消费者
 ☆线程等待和唤醒：wait(),notify()有序.notifyAll()无序
   wait, notify, notifyAll都是在 theObjBeLocked上被调用的。。。。都是在theObjBeLocked上被调用的
 终止线程的方法有哪些呢？？
     1) 线程执行完其run()方法后，会自然终止。
　　     2) 通过调用线程的实例方法stop()来终止线程（不安全）。
可以通过Thread 中的isAlive() 方法来获取线程是否处于活动状态；线程由start() 方法启动后，直到其被终止之间的任何时刻，都处于'Alive'状态。所以一般线程有启动，可运行状态。运行状态和死亡状态三种。
 
 进程和线程的具体区别：

 进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。
 进程（Process）和线程（Thread）的区别在于：

    线程的划分尺度小于进程，使得多线程程序的并发性高。
    线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

    进程是指在系统中正在运行的一个应用程序；线程是系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元。对于操作系统而言其调度单元是线程。一个进程至少包括一个线程，通常将该线程称为主线程。一个进程从主线程的执行开始进而创建一个或多个附加线程，就是所谓基于多线程的多任务

   进程与线程的重要区别在于线程不能够单独执行，它必须运行在处于活动状态的应用程序进程中
●
●☆

☆☆☆☆☆☆☆☆☆☆☆☆  多 线 程  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

☆☆☆☆☆☆☆☆☆☆☆☆  IO 操 作  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

●☆字符流和字节流
●☆管道流：处理线程之间的通信就使用管道流，不太常用
●☆打印流：PrintStream/PrintWriter:提供了各种打印功能
●☆System.in和System.out
●☆InputStreamReader和OutputStreamWriter
●☆BufferedReader
●☆对象序列化以及反序列化
☆☆☆☆☆☆☆☆☆☆☆☆  IO 操 作  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

☆☆☆☆☆☆☆☆☆☆☆☆  集 合 操 作  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
为什么使用集合？因为数组大小不可变，使用不方便。
★┠List  ▲允许重复元素▲◆■●☆
    ┝ArrayList(动态数组，插入数据慢，查询快)
    ┝Vector(动态数组,但该类是同步的，过时)
 ┝Stack栈类，先进后出，后进先出
    ┝LinkedList(List 接口的链接列表实现,插入数据快，查询慢.因为它要向前向后遍历)
  List集合的输出顺序为添加的顺序。

★┠Set   ▲不允许重复元素，添加重复的，则原来的被替换
    ┝SortedSet没有重复的元素切排序
        ┝TreeSet(默认升序，依靠Comparable接口)。因为有续，所以输出时按照一定顺序输出。此类保证排序后的 set 按照升序排列元素，根据使用的构造方法不同，可能会按照元素的自然顺序 进行排序（参见 Comparable），或按照在创建 set 时所提供的比较器进行排序。
    ┝HashSet(散列存放，无序)，因为她是散列存放，即哪里有空位置就存放在哪里，所以输出时顺序是不固定的。

★┠Map   ▲通过键值映射散列表原理实现的集合 不能重复
    ┝HashMap(允许null值)
    ┝HashTable(与HashMap相似，但是同步，不允许null值)
 ┝Properties(HashTable的子类)
    ┝SortedMap(可以排序的Map，好像不允许null值)
 ┝TreeMap 按照键的升序排列的映射。插入有序映射的所有键都必须实现 Comparable 接口（或者被指定的比较器所接受）。另外，所有这些键都必须是可互相比较的

有关对象比较请看后面。

●☆如何只让集合加入一种特定对象：
 List<java.lang.String> list = new ArrayList<java.lang.String>();
 如果是Map则写两个：Map<java.lang.String,java.lang.String> map = new HashMap<java.lang.String,java.lang.String>().
●☆一般map对象用着查找，而不用着输出，如果一定要输出Map对象的值，这只能按如下方法输出:(例如有一个map对象m)
当然，你不要告诉我Connection 集合怎么输入哈。
Set all = m.entrySet();
Iterator iter = all.iterator();
while(iter.hasNext())
{
 Map.Entry me = (Map.Entry)iter.next();
 System.out.println(me.getKey()+"----"+me.getvalue());
}
●☆Vector是在java1.2之前实现的动态数组，因为Vector是同步的，性能比较低，所以现在比较常使用ArrayList
 要输出Vector中的元素，使用Enumeration：但是它也可以使用Iterator输出。
 Vector vec = new Vector();
 vec.add("fefa");vec.add("a5ag");
 Enumeration en = vec.elements();
 while(en.hasMoreElements())
 {
  System.out.println(en.nextElement());
 }
●☆Stact是Vector的子类，也是较早之前才使用的，后进先出。
●☆HashTable同样是供较早之前使用，也是同步的，与现在的HashMap对应。
●☆Propertys是HashTable的子类，后者主要保存对象之用，而Protectys主要保存字符串。
●☆注意Collection 和 Collections的区别：前者是集合接口，后者是针对集合的帮助类。
☆☆☆☆☆☆☆☆☆☆☆☆  集 合 操 作  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

☆☆☆☆☆☆☆☆☆☆☆☆  其 他  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
●☆哈希码：复写hashcode（）方法时必须同时复写Equals（）方法
●☆对象克隆：克隆对象必须满足如下2条件：
 1.实现Cloneable接口；就像io序列化Serianazibale接口一样是个标示型接口
 2.复写clone()方法：public object clone(){return super.clone()}
●☆比较器Comparable：专门用于比较对象。更多请看最后面示例。
 Arrays类包含用来操作数组（比如排序和搜索）的各种方法，可以对任意数据类型排序，包括数组对象。
 但是这时数组对象必须实现Comparable接口，即是指明该对象按什么规则进行排序。
  ☆当然，也需你会想到使用TreeSet，因为他是排序的，但是如果TreeSet中的元素是对象的话，又因为TreeSet本身要
 求必须排序，所以这时TreeSet中的对象就必须实现Comparable接口了，并复写Public int Comparable(Object obj)方法。
●☆理解对象产生的4种方法：
1.直接使用new产生，比较直观，但是程序出现耦合度
2.程序出现了接口，如果一个接口的子类通过new实例化会产生耦合度，采用工厂进行解耦合操作。
3.对象克隆，将对象拷贝一份，但是此方法需要在子类中复写clone方法。
4.Class类，通过传给它一个字符串来实例化一个对象。(只需要掌握如何实例化对象即可)
 Fruit f = null ;
 f = (Fruit)Class.forName(type).newInstance() ;
●☆工厂设计
●☆网络编程

●☆final、finally和finalize的区别:
 final:     用于修饰变量，方法和类时的特征。
 finally:   用于try catch异常捕获
 finalize： finalize()方法是在GC清理它所从属的对象时被调用的，如果执行它的过程中抛出了无法捕获的异常（uncaught exception），GC将终止对改对象的清理，并且该异常会被忽略；直到下一次GC开始清理这个对象时，它的finalize()会被再次调用。
public final class FinallyTest {  
    // 重写finalize()方法  
    protected void finalize() throws Throwable {  
        System.out.println("执行了finalize()方法");  
    }  
 
    public static void main(String[] args) {  
        FinallyTest ft = new FinallyTest();  
        ft = null;  
        System.gc();  
    }  
} 
调用System.gc()等同于调用下面这行代码：
Runtime.getRuntime().gc(); 
更多有关java基础知识点详解可参见JAVA面试题解惑系列：
http://zangweiren.javaeye.com/blog/212592和
http://zangweiren.javaeye.com/category/34977

☆☆☆☆☆☆☆☆☆☆☆☆  其 他  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

●48、编程题: 写一个Singleton出来。 Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
      一般Singleton模式通常有几种种形式:
  ☆java单例模式代码 singleton 饿汉式
  public   class   Singleton   {    
  　　private   Singleton(){}    
  　　  
  　　private   static   final   Singleton   instance   =   new   Singleton();    
  　　  
  　　public   static   Singleton   getInstance()   {    
  　　　　return   instance;  
  　　}    
  } 
 ☆java单例模式代码 singleton 懒汉式
public class Singleton {
 //和上面有什么不同？
 private static Singleton instance = null;
 //设置为私有的构造函数
 private Singleton(){
    }　
 //静态工厂方法
 public static synchronized Singleton getInstance() {
 //这个方法比上面有所改进
　　       if (instance==null)
              instance＝new Singleton();
　　       return instance; 　　
 }
}

常见异常：
IndexOutOfBoundsException
NullPointerException
ClassCaseException
InterruptedException 调用线程方法sleep()时必须处理的方法

●面向对象的特征有哪些方面
 ★1.抽象： 抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
 ★2.继承： 继 承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继 承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增 加新的方法使之更适合特殊的需要。
 ★3.封装： 封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
 ★4. 多态性： 多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

●下面这个有错吗?
public class Something {
 void doSomething () {
  private String s = ""; int l = s.length();
 }
} 
答案: 错。方法局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量

public class Something {
 public static void main(String[] args) {
 Other o = new Other(); new Something().addOne(o);
 }
 public void addOne(final Other o) {
 o.i++;
 }
}
 class Other { public int i; }
 和上面的很相似，都是关于final的问题，这有错吗? 答案: 正确,因为并没修改到o的引用值。

注意申明为final的变量不会有默认值，所以声明时必须赋值，而接口中声明的变量都为静态最终变量，所以接口中的变量值不可更改。

●局部内部类是否可以访问非final变量？
答案：不能访问局部的，可以访问成员变量（全局的）。
class Out
{
 private String name = "out.name";
 void print()
 {
  final String work = "out.local.work";//若不是final的则不能被Animal 使用.
  int age=10;
  class Animal
  //定义一个局部内部类.只能在print()方法中使用.
  //局部类中不能使用外部的非final的局部变量.全局的可以.
  {
   public void eat()
   {
    System.out.println(work);//ok
    //age=20;error not final
    System.out.println(name);//ok.
   }
  }
  Animal local = new Animal();
  local.eat();
 }
}

●7．在try-catch-final块中的退出语句。
public class Test
{
 public static void main(String[] args)
 {
  int a=1;
  try
  {
   a=a/0;
  }catch(Exception e)
  {
   System.out.println("catch");
   return;//当return时，finally中的语句会先执行。
   //System.exit(0);//若用上这句，finally中的语句不会执行。直接退出程序。
  }
  finally //当没有System.exit(0);时，无论是否发生异常它都会执行。
  {
   System.out.println("finally");
  }
 }
}
注：   try-catch-finally块的顺序不能调换。

8． 下面都是正确的main方法签名。
public static void main(String[] args)
public static final void main(String[] args)
static public void main(String[] args)
static public synchronized void main(String[] args)
static public abstract void main(String[] args)//错误
9． if(-0.0 == 0.0)是相等还是不等？
答案：相等。

所有关于 NaN(Not a Number) 和 non-NaN 的比较，都返回false. 这条很重要。
  ==会产生编译错误，如果两边类型不匹配的话。
  equals() 返回 false 如果对象类型不同，但不产生 编译错误。
integer和long 操作 /和% 的话， 可能会抛出ArithmeticException，比如除0。但是 float与
double不会，即使是除以0。
 double a=0;a=a/0;则a等于NaN。

JAVA类实现序列化的方法？在collection中，实现比较要实现什么样的接口？
 答案：java类实现序列化需要实现java.io.Serializable接口。
 在collection中实现比较要实现java.lang.Comparable接口或java.util.Comparator接口

关于值传递和引用传递例题：
public class Foo {
 public static void main (String [] args) {
 StringBuffer a = new StringBuffer ("a");
 StringBuffer b = new StringBuffer ("b");
 operate (a,b);
 System.out.println(a + "," +b);
 }
 static void operate (StringBuffer x, StringBuffer y) {
  y.append(x);
  y = x;
 }
}
输出结果为：a,ba。

关于switch没有break跳出语句时：
int i=1, j=0;
   switch(5) {
   default:
    j +=2;
   case 2:
   j+=6;
   case 4:
   j+=1;
   case 0:
    j +=4;
   }
   System.out.println("i:"+i+", j:"+j);
输出结果为：i:1, j:13，不关是default也好还是其他某个case语句，只要没有使用break，然后只要条件满足，后面的一律都要执行。

什么时候使用断言Assert？
Java2在1.4中新增了一个关键字：assert。在程序开发过程中使用它创建一个断言(assertion)，它的
语法形式有如下所示的两种形式：
1、assert condition; 这里condition是一个必须为真(true)的表达式。如果表达式的结果为true，那么断言为真，并且无任何行动
如果表达式为false，则断言失败，则会抛出一个AssertionError对象
2、asser condition:expr;这里condition是和上面一样的，冒号后跟的是一个表达式，通常用于断言失败后的提示信息.
public class TestAssert{
     public static void main(String[] args){
         String name = "abner chai";
         //String name = null;
         assert (name!=null):"变量name为空null";
         System.out.println(name);
     }
}

11、EJB是基于哪些技术实现的？并说出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别。
    EJB是java语言实现的服务器端组件，主要使用在分布式应用系统开发中，减轻了分布式应用开发开发量和难度。
    EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现。
 
 会话Bean用来封装业务中的一些规则，流程及控制过程等，它描述的是业务中的行为。
 实体Bean表示持久数据的对象视图，它描述的是业务中的数据。
 消息Bean用于异步通信。
　
　Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean ，这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体。Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候，EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method。换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行。从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态。
      EJB是企业级的JavaBean，它提供了构建企业级业务逻辑的一种组件模型。
EJB分为三种：Session Bean Entity Bean Message-Driven Bean 三种，其中Session Bean分为有状态和无状态Session Bean两种Entity Bean分为容器管理的Entity Bean ( CMP ) 和 Bean管理的 Entity Bean ( BMP )。每一个EJB由一个远程接口、一个本地接口和一个EJB容器实现组成，远程接口声明了提供给EJB客户调用的各种应用方法，本地接口声明了创建新的 EJB实例的create方法、寻找EJB实例的查找(finder)方法以及€€除EJB实例的remove方法。EJB容器提供了EJB的运行环境和生命周期的管理。

11、编译运行以下程序后，关于输出结果的说明正确的是 （C    ）：
       public  class   Conditional{
              public  static  void  main(String  args[  ]){
                     int  x=4;
                     System.out.println(“value  is  “+ ((x>4) ? 99.9 :9));
}
}
A、    输出结果为：value  is  99.99
B、    输出结果为：value  is  9
C、    输出结果为：value  is  9.0
D、    编译错误

12.下列程序如何运行？
class Cat
{
  void mi( ) throws Exception  {
   //void mi( ) throws NullPointerException
    System.out.println( "Cat mi mi .. " );
  }
}
public class SmallCat extends Cat
{int i=8;
  void mi( ) throws NullPointerException
  //void mi( ) throws Exception
  {
    System.out.println( "SmallCat mi mi .. " );
  }
  public static void main( String[] a ) throws Exception
  {
    Cat cat = new SmallCat();
    cat.mi();
  }
}
正常运行，如果同时替换注释中的语句将编译出错。
13.如下程序将输出什么？
class MyThread extends Thread{
public void run(){
 System.out.println("MyThread: run()");
}
//public void start(){
// System.out.println("MyThread: start()");
//    }
}
class MyRunnable implements Runnable{
 public void run(){
   System.out.println("MyRunnable: run()");
    }
 public void start(){
  System.out.println("MyRunnable: start()");
   }
}
public class MyTest {
 public static void main(String args[]){
   MyThread myThread  =  new MyThread();
   MyRunnable myRunnable = new MyRunnable();
   Thread thread  =  new Thread(myRunnable);
   myThread.start();
   thread.start();
}
}
输出结果为：
MyThread: run()
MyRunnable: run()

但是如果把程序中的注释去掉，将输出：
MyThread: start()
MyRunnable: run()

常用排序方法？
常见数据结构有哪些？

XML文档解析器有几种形式？？
答：2种。一种是进行验证的解析器，一种是不进行验证的解析器。

XML文档有哪几种解析方式(或者xml解析器使用的基本API有哪些？)，他们有什么区别？
 1.DOM  一种基于树结构的API
 2.SAX  一种基于事件驱动的API
  DOM是基于对象的，它与语言和平台无关。但是她的一个显著特点就是必须把整个文档放在内存中解析和存储，
然后就能随即访问这些对象了。如果文档比较大，容易造成内存紧张。

  而SAX采用的是回调机制来通知客户端应用程序，不会把整个文档都加载到内存中。当事件发生时，解析器会通知到应用程序。
如下情况适用于SAX：
 1.在解析大型文档时，不必将整个文档加载到内存中，占用的内存比DOM少
 2.在只需要一个信息子集时，SAX能够忽略不需要的数据，而DOM做不到。
最常用的SAX解析器是JAXP。
  SAX缺点：
    1.必须按到达顺序处理数据，不能够随机访问
    2.SAX被设为只读取XML文档，而不是写入他们，所以使用SAX无法写操作。
    3.文档只能遍历一次。

web容器和web服务器有什么区别？？
  WEB服务器也称为WWW(WORLD WIDE WEB)服务器，主要功能是提供网上信息浏览服务。
  而web容器给处于其中的web组件（例如jsp，Servlet等）提供了一个运行和服务环境。使其应用程序不必关注其他系统问题。
正因为这样，所有组件都必须在容器中才能运行。例如，EJB需要在EJB容器中运行，jsp等需要在web容器中运行。
  常用的web容器有：tomca，WebLogic，WebSphere等。
tomcat既是一个jsp/serv容器，也是一个http服务器，能与其他主流服务器（iis，apache）一起工作。
而WebLogic Server是开发和部署基于java的web应用程序的事实上的工业标准。

*****************************************************************************
关于排序：Comparable Arrays等：
*****************************************************************************

首先是Arrays类：
1.对数组排序：
import java.util.Arrays;
public class Test
{
 public static void main(String[] args)
 {
  int[] i = new int[]{2,5,8,6,9,3};

  for(int x=0;x<i.length;x++)
  {
   Arrays.sort(i);
   System.out.println(i[x]);
  }
 }
}
这时输出的顺序是从小到大排列输出的。

2.对数组中的对象进行排序：先写个Person类，包括姓名，年龄和分数，然后对她进行排序：
要对一个类进行排序，就必须指明排序规则，要实现排序规则就必须实现Comparable接口，
同时实现该接口中的CompareTo()方法，排序规则就在该方法中实现。如果要按照Person中的成绩排序，
就在该方法中对成绩进行比较。但注意该方法只返回-1，0或者1。分别表示大于，等于和小于。详情如下：
import java.util.* ;
class Person implements Comparable
{
 private String name ;
 private int age ;
 private float score ;
 public Person(String name,int age,float score)
 {
  this.name = name ;
  this.age = age ;
  this.score = score ;
 }
 public String toString()
 {
  return "姓名："+this.name+"，年龄："+this.age+"，成绩："+this.score ;
 }
 // 覆写compareTo方法就是排序规则
 public int compareTo(Object obj)
 {
  Person p = (Person)obj ;
  if(p.score>this.score)
  {
   return 1 ;
  }
  else if(p.score<this.score)
  {
   return -1 ;
  }
  else
  {
   // 如果成绩相等则判断年龄
   if(p.age>this.age)
   {
    return 1 ;
   }
   else if(p.age<this.age)
   {
    return -1 ;
   }
   else
   {
    return 0 ;
   }
  }
 }
public class AdvDemo05
{
 public static void main(String args[])
 {
  Person p[] = new Person[5] ;
  p[0] = new Person("张三",20,96) ;
  p[1] = new Person("李四",19,96) ;
  p[2] = new Person("王五",19,97) ;
  p[3] = new Person("赵六",21,78) ;
  p[4] = new Person("孙七",20,80) ;

  Arrays.sort(p) ; //要对Person类进行排序就必须让Person类implements Comparable接口。
  for(int i=0;i<p.length;i++)
  {
   System.out.println(p[i]) ;
  }
 }
}
当然，也需你会想到使用TreeSet，因为他本身要求就是排序的，但是如果TreeSet中的元素是对象的话，该怎么办呢，
同样，这时TreeSet中的对象还是必须实现Comparable接口，并复写Public int Comparable(Object obj)方法。
如上的Person类，如果放在TreeSet集合中就像下面这样，就不会再去使用sort()方法了：
public static void main(String args[])
 {
  Set s = new TreeSet() ;
  s.add(new Person("张三",20,96)) ;
  s.add(new Person("李四",19,96)) ;
  s.add(new Person("王五",19,97)) ;
  s.add(new Person("赵六",21,78)) ;
  s.add(new Person("孙七",20,80)) ;
  Iterator iter = s.iterator() ;
  while(iter.hasNext())
  {
   System.out.println(iter.next()) ;
  }
 }