java基础题

1. finally何时执行？

答：

1. 不管有木有出现异常，finally块中代码都会执行；
2. 当try和catch中有return时，finally仍然会执行；
3. finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值），所以函数返回值是在finally执行前确定的；
4. finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
5. 假设利用 return 语句从 try 语句块中退出。在方法返回前，finally子句的内容将被执行。如果 finally 子句中也有一个 return 语句，这个返回值将会覆盖原始的返回值。

1.try和catch语句 
●将要处理的代码放入try块中，然后创建相应的catch块的列表。如果生成都异常与catch中提到的相匹配，那么catch条件中的块语句就被执行。try块后可能有许多catch块，每个都处理不同的异常。每个catch中的参数都是Exception的子类。 
2.finally语句 
●finally语句定义一个总是执行的代码，而不考虑异常是否被捕获。 
3.throw引起一个异常 

‍●‍‍调用申明抛出异常

●‍throw语句强制抛出异常

2. java中有两种传递方式。值传递和引用传递， 基本类型和以String str="aa"这种方式创建的字符串都是值传递，对象，数组等是引用传递。

3. java中子类的初始化

• 初始化过程： 
• 1. 初始化父类中的静态成员变量和静态代码块 ； （  java虚拟机加载类时，就会执行该块代码，故只执行一次）
• 2. 初始化子类中的静态成员变量和静态代码块 ； （  java虚拟机加载类时，就会执行该块代码，故只执行一次）
• 3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；（每次new,每次执行 ）
• 4.初始化子类的普通成员变量和代码块，再执行子类的构造方法； （每次new,每次执行 ）

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)和卸载(Unloading)7个阶段。其中准备、验证、解析3个部分统称为连接（Linking）。如图所示。
 
加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。以下陈述的内容都已HotSpot为基准。

加载

在加载阶段（可以参考java.lang.ClassLoader的loadClass()方法），虚拟机需要完成以下3件事情：

1. 通过一个类的全限定名来获取定义此类的二进制字节流（并没有指明要从一个Class文件中获取，可以从其他渠道，譬如：网络、动态生成、数据库等）；
2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构；
3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口；

加载阶段和连接阶段（Linking）的部分内容（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始，但这些夹在加载阶段之中进行的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持着固定的先后顺序。

验证

验证是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
验证阶段大致会完成4个阶段的检验动作：

1. 文件格式验证：验证字节流是否符合Class文件格式的规范；例如：是否以魔术0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
2. 元数据验证：对字节码描述的信息进行语义分析（注意：对比javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了java.lang.Object之外。
3. 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
4. 符号引用验证：确保解析动作能正确执行。

验证阶段是非常重要的，但不是必须的，它对程序运行期没有影响，如果所引用的类经过反复验证，那么可以考虑采用-Xverifynone参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。这时候进行内存分配的仅包括类变量（被static修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在堆中。其次，这里所说的初始值“通常情况”下是数据类型的零值，假设一个类变量的定义为：

1	publicstaticintvalue=123;

那变量value在准备阶段过后的初始值为0而不是123.因为这时候尚未开始执行任何java方法，而把value赋值为123的putstatic指令是程序被编译后，存放于类构造器()方法之中，所以把value赋值为123的动作将在初始化阶段才会执行。
至于“特殊情况”是指：public static final int value=123，即当类字段的字段属性是ConstantValue时，会在准备阶段初始化为指定的值，所以标注为final之后，value的值在准备阶段初始化为123而非0.

解析

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。

初始化

类初始化阶段是类加载过程的最后一步，到了初始化阶段，才真正开始执行类中定义的java程序代码。在准备极端，变量已经付过一次系统要求的初始值，而在初始化阶段，则根据程序猿通过程序制定的主管计划去初始化类变量和其他资源，或者说：初始化阶段是执行类构造器<clinit>()方法的过程.

<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块static{}中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问

原文链接  http://www.importnew.com/18548.html

 

 

4. equal和==的区别

答：

• equal:是用来比较两个对象内部的内容是否相等的。
• ==：是用来判断两个对象的地址是否相同，即是否是指相同一个对象。
• 没有重写equals时，是直接用==判断的，而String中重写了equals方法。

equals只是进行值判断不对类是不是同一个引用不进行判断，而==判断包括值和类引用.通过String a = "1234"这种产生的字面字符串,如果内存中存在字符串“1234”则会直接引用,如果没有则分配内存，因此a==b的结果为true。而String c = new String("1234")，则会分配内存控件存储字符串,不考虑之前是否存在。因此a==c的结果false.由于a和c的值都是"1234"因此a.equals(c)的结果为true.同时Integer中也是类似的原理,因此使用Integer a = 12;时会在某种情况下提高程序的性能。

5. java中类型转换：

两个数值进行二元操作时，会有如下的转换操作：

• 如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
• 否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
• 否则，如果其中一个操作数是long类型，另一个会转换为long类型。
• 否则，两个操作数都转换为int类型。
• 数值型变量在默认情况下为Int型，byte和short型在计算时会自动转换为int型计算，结果也是int 型。所以a1*a2的结果是int 型的。

6. 关于TLS（线程局部存储）

概念：线程局部存储（Thread Local Storage，TLS）用来将数据与一个正在执行的指定线程关联起来。

进程中的全局变量与函数内定义的静态(static)变量，是各个线程都可以访问的共享变量。在一个线程修改的内存内容，对所有线程都生效。这是一个优点也是一个缺点。说它是优点，线程的数据交换变得非常快捷。说它是缺点，一个线程死掉了，其它线程也性命不保; 多个线程访问共享数据，需要昂贵的同步开销，也容易造成同步相关的BUG。

　　如果需要在一个线程内部的各个函数调用都能访问、但其它线程不能访问的变量（被称为static memory local to a thread 线程局部静态变量），就需要新的机制来实现。这就是TLS。

　　线程局部存储在不同的平台有不同的实现，可移植性不太好。幸好要实现线程局部存储并不难，最简单的办法就是建立一个全局表，通过当前线程ID去查询相应的数据，因为各个线程的ID不同，查到的数据自然也不同了。大多数平台都提供了线程局部存储的方法，无需要我们自己去实现：

功能：它主要是为了避免多个线程同时访存同一全局变量或者静态变量时所导致的冲突，尤其是多个线程同时需要修改这一变量时。为了解决这个问题，我们可以通过TLS机制，为每一个使用该全局变量的线程都提供一个变量值的副本，每一个线程均可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。而从全局变量的角度上来看，就好像一个全局变量被克隆成了多份副本，而每一份副本都可以被一个线程独立地改变。

分类：动态TLS和静态TLS。

用途：动态TLS和静态TLS这两项技术在创建DLL的时候更加有用，这是因为DLL通常并不知道它们被链接到的应用程序的结构是什么样的。

1．              如果应用程序高度依赖全局变量或静态变量，那么TLS可以成为我们的救生符。因而最好在开发中最大限度地减少对此类变量的使用，更多的依赖于自动变量（栈上的变量）和通过函数参数传入的数据，因为栈上的变量始终都是与某个特定的线程相关联的。如果不使用此类变量，那么就可以避免使用TLS。

2．              但是在编写应用程序时，我们一般都知道自己要创建多少线程，自己会如何使用这些线程，然后我们就可以设计一些替代方案来为每个线程关联数据，或者设计得好一点的话，可以使用基于栈的方法（局部变量）来为每个线程关联数据。

所以：关于TLS，说法正确的是（ABD）

A 解决多线程中的对同一变量的访问冲突的一种技术

B TLS会为每一个线程维护一个和该线程绑定的变量的副本

C 每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了

D Java平台的java.lang.ThreadLocal是TLS技术的一种实现

对于C ： 如果是静态变量是共享的话，那必须同步，否则尽管有副本，还是会出错，故C错

7. 

jar         将许多文件组合成一个jar文件

javac    编译

javadoc 它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。

javah 把java代码声明的JNI方法转化成CC++头文件。 JNI可参考java核心技术卷二第12章

 

8. java中关于子类继承父类的构造方法一说是错误的：

在java中，子类构造器会默认调用super()(无论构造器中是否写有super（）),用于初始化父类成员，同时当父类中存在有参构造器时，必须提供无参构造器，子类构造器中并不会自动继承有参构造器，仍然默认调用super()，使用无参构造器。因此，一个类想要被继承必须提供无参构造器。

PS：方法没有继承一说，只有重载和重写

 

9. 访问说明符

如果一个类声明为protected，它的子类是可以访问它的，如果它和子类不在一个包中，子类仍然可以访问该类

 

10.  自动拆箱装

(自动拆装箱JDK需在1.5上）
1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
2、两个Integer类型进行“==”比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

 

11. 容器集合类

 集合中线程安全的类有：vector，stack，hashtable，enumeration，除此之外均是非线程安全的类与接口

 

12. java中异常类：

 

• 1.Exception（异常） :是程序本身可以处理的异常。 
• 2.Error（错误）: 是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。
• 3.检查异常（编译器要求必须处置的异常） ：  除了Error，RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
• 4.非检查异常(编译器不要求处置的异常): 包括运行时异常（RuntimeException与其子类）和错误（Error）。

13. Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段：

Servlet的生命周期一般可以用三个方法来表示：

1. init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
2. service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
3. destory()：在停止并且卸载Servlet时执行，负责释放资源

初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。

Servlet（Server Applet），全称Java Servlet，未有中文译文。是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。 Servlet运行于支持Java的应用服务器中。从原理上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。 这个过程为： 1) 客户端发送请求至服务器端； 2) 服务器将请求信息发送至 Servlet； 3) Servlet 生成响应内容并将其传给服务器。响应内容动态生成，通常取决于客户端的请求； 4) 服务器将响应返回给客户端。

14. 关键字

• synchronized 关键字 : 用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。
• volatile：用来确保将变量的跟新操作通知到其他线程，当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。然而，在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比 synchronized关键字更轻量级的同步机制。
• serialize：Java 对象序列化为二进制文件。
• static关键字： static关键字可以修饰变量，方法，静态代码块。
  •  静态变量:
    • 由static修饰的变量称为静态变量
    • 静态变量属于类，而不属于某个对象
    • 静态变量它的副本只有一个(静态变量在类中只加载一)
  • 静态方法：
    • 在静态方法中只能调用静态变量和静态方法
    • 在非静态方法中，可以调用静态方法或者变量。
    • 在静态方法中不能使用this和super关键字。
  • 静态代码块
    • 作用:用来给静态成员变量初始化

　

15. 关于C++中的虚类和Java接口

答：

• c++虚类相当与java里面的抽象类
• c++中没有接口的概念，与之对应的是纯虚类，对应的是java的接口
• 纯虚函数和虚函数的区别在于前者不包含定义，而后者可以包含函数体。
• 1、一个子类只能继承一个抽象类（虚类），但能实现多个接口； 2、一个抽象类可以有构造方法，接口没有构造方法； 3、一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有声明； 4、一个抽象类可以是public、private、protected、default, 接口只有public; 5、一个抽象类中的方法可以是public、private、protected、default， 接口中的方法只能是public和default
• 6、接口中所有的方法均为抽象方法，即它和纯虚类意思相同。
• 7、含有虚函数（抽象方法）的类即为抽象类；

　　

16. 虚类和接口的区别

• 抽象类可以有构造方法，接口中不能有构造方法
• 抽象类中可以有普通成员变量，接口中没有普通成员变量
• 抽象类中可以包含静态方法，接口中不能包含静态方法
• 一个类可以实现多个接口，但只能继承一个抽象类。
• 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。  
• 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。 
• 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
• 含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。  
  接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。  
• 接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，  
  
  例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码

　　　　

17. 在运行时，由java解释器自动引入，而不用import语句引入的包是：java.lang

答：

java.lang包是java语言的核心包，lang是language的缩写

java.lang包定义了一些基本的类型，包括Integer,String之类的，是java程序必备的包，有解释器自动引入，无需手动导入

 

18. 关于HashMap和HashTable

• 源码：

  • //HashMap的源码
    public class HashMap<K,V>
        extends AbstractMap<K,V>
        implements Map<K,V>, Cloneable, Serializable
    -----------------------------------
    //Hashtable的源码
    public class Hashtable<K,V>
        extends Dictionary<K,V>
        implements Map<K,V>, Cloneable, java.io.Serializable

• 都实现了Map接口
• HashMap的put方法没有同步。HashMap非线程安全，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供额外同步。

• public V put(K key, V value) //HashMap的put方法，没有同步
   
  public synchronized V put(K key, V value) //Hashtable的put方法
  //当然，Hashtable的其他方法，如get，size，remove等方法，
  //都加了synchronized关键词同步操作 

• HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

• //Hashtable的put方法有以下语句块，大伙看了都知道
  // Make sure the value is not null
  if (value == null) {
      throw new NullPointerException();
  }
   
  //那么，我们再来看下HashMap的put方法中，有如下语句
  //调用某个方法直接把key为null，值为value的键值对插入进去。
  if (key == null)
      return putForNullKey(value);

• 通过contains方法可以判断一个对象是否存在于HashMap或者Hashtable中(错)。 HashMap无contains方法

• //以下是Hashtable的方法
  public synchronized boolean contains(Object value)
  public synchronized boolean containsKey(Object key)
  public boolean containsValue(Object value)
   
  //以下是HashMap中的方法，注意，没有contains方法，所以，D错误
  public boolean containsKey(Object key)
  public boolean containsValue(Object value)

• 由所有HashMap类的“collection 视图方法”所返回的迭代器都是快速失败的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出ConcurrentModificationException。Hashtable和HashMap的区别主要是前者是同步的，后者是快速失败机制保证 

19. 关于java实例变量，局部变量，类变量和final变量

• 定义在类中的变量是类的成员变量，可以不进行初始化，Java会自动进行初始化，如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
• 局部变量是定义在方法中的变量，必须要进行初始化，否则不同通过编译。局部变量运行时被分配在栈中，量大，生命周期短，如果虚拟机给每个局部变量都初始化一下，是一笔很大的开销，但变量不初始化为默认值就使用是不安全的。出于速度和安全性两个方面的综合考虑，解决方案就是虚拟机不初始化，但要求编写者一定要在使用前给变量赋值。
• 被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量
• 被final修饰的变量是常量

20. 关于java threadlocal

• ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递
• 线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收
• 在Thread类中有一个Map，用于存储每一个线程的变量的副本。
• 对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式
• ThreadLocal类用于创建一个线程本地变量
  在Thread中有一个成员变量ThreadLocals，该变量的类型是ThreadLocalMap,也就是一个Map，它的键是threadLocal，值为就是变量的副本。通过ThreadLocal的get()方法可以获取该线程变量的本地副本，在get方法之前要先set,否则就要重写initialValue()方法。
  ThreadLocal的使用场景：
          数据库连接：在多线程中，如果使用懒汉式的单例模式创建Connection对象，由于该对象是共享的，那么必须要使用同步方法保证线程安全，这样当一个线程在连接数据库时，那么另外一个线程只能等待。这样就造成性能降低。如果改为哪里要连接数据库就来进行连接，那么就会频繁的对数据库进行连接，性能还是不高。这时使用ThreadLocal就可以既可以保证线程安全又可以让性能不会太低。但是ThreadLocal的缺点时占用了较多的空间。

21. 有关JVM内存

• 运行时数据区包括：虚拟机栈区，堆区，方法区，本地方法栈，程序计数器
• 虚拟机栈区 ：也就是我们常说的栈区，线程私有，存放基本类型，对象的引用和 returnAddress ，在编译期间完成分配。
• 堆区 ， JAVA 堆，也称 GC 堆，所有线程共享，存放对象的实例和数组， JAVA 堆是垃圾收集器管理的主要区域。
• 方法区 ：所有线程共享，存储已被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据。这个区域的内存回收目标主要是针对常量池的对象的回收和对类型的卸载。
• 程序计数器 ：线程私有，每个线程都有自己独立的程序计数器，用来指示下一条指令的地址。

22. 创建线程对象两种方式：

创建线程对象两种方式：

• 1.继承Thread类，重载run方法；
• 2.实现Runnable接口，实现run方法 

23. 方法的重写（override）两同两小一大原则：

• 方法名相同，参数类型相同
• 子类返回类型小于等于父类方法返回类型，
• 子类抛出异常小于等于父类方法抛出异常，
• 子类访问权限大于等于父类方法访问权限。

24. J2EE中常用名词解释

1.web容器：给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使JSP,SERVLET直接和容器中的环境变量接接口互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。

2.Web container：实现J2EE体系结构中Web组件协议的容器。这个协议规定了一个Web组件运行时的环境，包括安全，一致性，生命周期管理，事务，配置和其它的服务。一个提供和JSP和J2EE平台APIs界面相同服务的容器。一个Web container 由Web服务器或者J2EE服务器提供。

3.EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。一个实现了J2EE体系结构中EJB组件规范的容器。 这个规范指定了一个Enterprise bean的运行时环境，包括安全，一致性，生命周期，事务， 配置，和其他的服务。

4.JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。

5.JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。

6.JTA：（Java Transaction API）JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。

7.JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。

8.RMI/IIOP:（Remote Method Invocation /internet对象请求中介协议）他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。RMI-IIOP出现以前，只有RMI和CORBA两种选择来进行分布式程序设计。RMI-IIOP综合了RMI和CORBA的优点，克服了他们的缺点，使得程序员能更方便的编写分布式程序设计，实现分布式计算。首先，RMI-IIOP综合了RMI的简单性和CORBA的多语言性（兼容性），其次RMI-IIOP克服了RMI只能用于Java的缺点和CORBA的复杂性（可以不用掌握IDL）。

25. final，finally和finalize：

final

• 修饰符（关键字）
• 如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。
• 将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。
• final修饰的方法不能被覆盖
  final修饰的字段为常量
  final修饰的类不能被继承

finally

• 异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。一般异常处理块需要。

finalize

• 方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。 
• Java中所有类都从Object类中继承finalize()方法。
• 当垃圾回收器(garbage colector)决定回收某对象时，就会运行该对象的finalize()方法。

26. JSP内置对象和属性列举如下：

1.request对象
     客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。
2.response对象
     response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。
3.session对象
     session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.
4.out对象
     out对象是JspWriter类的实例,是向客户端输出内容常用的对象
5.page对象
     page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例
6.application对象
     application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。
7.exception对象
   exception对象是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象
8.pageContext对象
pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的SESSION，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本 类名也叫pageContext。
9.config对象
config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）

27. 关于super和this

• 1）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
• 2）super()和this()类似,区别是，super从子类中调用父类的构造方法，this()在同一类内调用其它方法。
• 3）super()和this()均需放在构造方法内第一行。
• 4）尽管可以用this调用一个构造器，但却不能调用两个。
• 5）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
• 6）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
• 7）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

28. 内部类声明

public class Enclosingone {
    //非静态内部类
    public class InsideOne {}
    //静态内部类
    public static class InsideTwo{}
}
 
class Mytest02{
    public static void main(String args []){
        Enclosingone.InsideOne obj1 = new Enclosingone().new InsideOne();//非静态内部类对象
        Enclosingone.InsideTwo obj2 = new Enclosingone.InsideTwo();//静态内部类对象
    }
}

29. 接口 默认修饰符

接口中的变量默认是public static final 的，方法默认是public abstract 的

30.