java基础题

时间  2019-12-13
标签 java 基础 栏目 Java 繁體版
原文   原文链接

1. finally什么时候执行？html

答：
  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引发一个异常 java

‍●‍‍调用申明抛出异常
●‍throw语句强制抛出异常

 

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

 

 

3. java中子类的初始化程序员

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

 

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

加载

在加载阶段（能够参考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方法转化成C\C++头文件。 JNI可参考java核心技术卷二第12章
 
8. java中关于子类继承父类的构造方法一说是错误的：
在java中，子类构造器会默认调用super()(不管构造器中是否写有super（）),用于初始化父类成员，同时当父类中存在有参构造器时，必须提供无参构造器，子类构造器中并不会自动继承有参构造器，仍然默认调用super()，使用无参构造器。所以，一个类想要被继承必须提供无参构造器。
PS：方法没有继承一说，只有重载和重写
 
9. 访问说明符

若是一个类声明为protected，它的子类是能够访问它的，若是它和子类不在一个包中，子类仍然能够访问该类

 
10.  自动拆箱装
(自动拆装箱JDK需在1.5上）
一、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，所以Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
二、两个Integer类型进行“==”比较，若是其值在-128至127，那么返回true，不然返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。
三、两个基本型的封装型进行equals()比较，首先equals()会比较类型，若是类型相同，则继续比较值，若是值也相同，返回true
四、基本型封装类型调用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的接口
  • 纯虚函数和虚函数的区别在于前者不包含定义，然后者能够包含函数体。
  • 一、一个子类只能继承一个抽象类（虚类），但能实现多个接口； 二、一个抽象类能够有构造方法，接口没有构造方法； 三、一个抽象类中的方法不必定是抽象方法，即其中的方法能够有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有声明； 四、一个抽象类能够是public、private、protected、default, 接口只有public; 五、一个抽象类中的方法能够是public、private、protected、default， 接口中的方法只能是public和default
  • 六、接口中全部的方法均为抽象方法，即它和纯虚类意思相同。
  • 七、含有虚函数（抽象方法）的类即为抽象类；

　　

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. 

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程