笔试经验之318

刺骨的言语ヽ痛彻心扉 2022-07-29 06:25 80阅读 0赞

SAP

2hour

4简答+20填空

范围：linux,ssh三大框架，数据结构，java,c++,js,html,css选择器优先级，网络协议http

1.不可变类

2.类加载器，classload原理，tomcat每个web使用classload的原因。

3.java内存泄漏的原因，GC

4.JAVA的异常如何使用

5.css优先级（p以及class）

6.angular js框架，控制，特性

7.js捕获对象属性

8http协议有无状态？简介

9.spring游离态

10.struts控制器主键

11.设计模式继承缺点

解答：

1.   不可变类

jdk的可变类和不可变类   
primitive变量: boolean,byte, char, double ,float, integer,long, short   
jdk的不可变类：jdk的java.lang包中 Boolean, Byte, Character, Double, Float,Integer, Long, Short, String.   
相应的  
  StringBuffer 可变类   
  java.util.Date 可变类

1.  可变类和不可变类(Mutable and Immutable Objects)的初步定义：   
     **可变类：**当你获得这个类的一个实例引用时，你可以改变这个实例的内容。   
      **不可变类：**当你获得这个类的一个实例引用时，你不可以改变这个实例的内容。不可变类的实例一但创建，其内在成员变量的值就不能被修改。

2. 如何创建一个自己的不可变类：   
**     .所有成员都是private   
      .不提供对成员的改变方法，例如：setXXXX   
      .确保所有的方法不会被重载。手段有两种：使用final Class(强不可变类)，或者将所有类方法加上final(弱不可变类)。 **  
      .如果某一个类成员不是原始变量(primitive)或者不可变类，必须通过在成员初始化(in)或者get方法(out)时通过深度clone方法，来确保类的不可变。

注：这一系列问题：（老帖）

对于这个系列里的问题，每个学Java的人都应该搞懂。当然，如果只是学Java玩玩就无所谓了。如果你认为自己已经超越初学者了，却不很懂这些问题，请将你自己重归初学者行列。内容均来自于CSDN的经典老贴。 
 
**问题一：**我声明了什么！ 
 
String s = "Hello world!"; 
 
许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。 
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句： 
 
String string = s; 
 
我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。 
 
**问题二：**"=="和equals方法究竟有什么区别？ 
 
==操作符专门用来比较变量的值是否相等。比较好理解的一点是： 
int a=10; 
int b=10; 
则a==b将是true。 
但不好理解的地方是： 
String a=new String("foo"); 
String b=new String("foo"); 
则a==b将返回false。 
 
根据前一帖说过，对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身。a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，既然是“两个”，它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，所以使用"=="操作符，结果会是false。诚然，a和b所指的对象，它们的内容都是"foo"，应该是“相等”，但是==操作符并不涉及到对象内容的比较。 
对象内容的比较，正是equals方法做的事。 
 
看一下Object对象的equals方法是如何实现的： 
boolean equals(Object o)\{ 
 
return this==o; 
 
\} 
Object对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类使用equals和使用==会得到同样的结果。同样也可以看出，Object的equals方法没有达到equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，所以Object把这个任务留给了类的创建者。 
 
看一下一个极端的类： 
Class Monster\{ 
private String content; 
... 
boolean equals(Object another)\{ return true;\} 
 
\} 
我覆盖了equals方法。这个实现会导致无论Monster实例内容如何，它们之间的比较永远返回true。 
 
所以当你是用equals方法判断对象的内容是否相等，请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合（HashSet,HashMap,HashTable），请察看一下java doc以确认这个类的equals逻辑是如何实现的。 
 
**问题三：**String到底变了没有？ 
 
没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。请看下列代码： 
 
String s = "Hello"; 
s = s + " world!"; 
 
s所指向的对象是否改变了呢？从本系列第一篇的结论很容易导出这个结论。我们来看看发生了什么事情。在这段代码中，s原先指向一个String对象，内容是"Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为"Helloworld!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。 
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。 
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做： 
public class Demo \{ 
  private String s; 
  ... 
  public Demo \{ 
    s = "InitialValue"; 
  \} 
  ... 
\} 
而非 
s = new String("Initial Value"); 
后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。 
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。 
至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即StringBuffer。 
 
**问题四：**final关键字到底修饰了什么？ 
 
final使得被修饰的变量"不变"，但是由于对象型变量的本质是“引用”，使得“不变”也有了两种含义：引用本身的不变，和引用指向的对象不变。 
 
引用本身的不变： 
final StringBuffer a=newStringBuffer("immutable"); 
final StringBuffer b=new StringBuffer("notimmutable"); 
a=b;//编译期错误 
 
引用指向的对象不变： 
final StringBuffer a=newStringBuffer("immutable"); 
a.append(" broken!"); //编译通过 
 
可见，final只对引用的“值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的“值”相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。 
 
理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它“永远不变”。其实那是徒劳的。 
 
**问题五：**到底要怎么样初始化！ 
 
本问题讨论变量的初始化，所以先来看一下Java中有哪些种类的变量。 
1. 类的属性，或者叫值域 
2. 方法里的局部变量 
3. 方法的参数 
 
对于第一种变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。 
 
int类型变量默认初始值为0 
float类型变量默认初始值为0.0f 
double类型变量默认初始值为0.0 
boolean类型变量默认初始值为false 
char类型变量默认初始值为0(ASCII码) 
long类型变量默认初始值为0 
所有对象引用类型变量默认初始值为null，即不指向任何对象。注意数组本身也是对象，所以没有初始化的数组引用在自动初始化后其值也是null。 
 
对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。这个问题会在以后的系列中进行详细讨论。 
 
对于第二种变量，必须明确地进行初始化。如果再没有初始化之前就试图使用它，编译器会抗议。如果初始化的语句在try块中或if块中，也必须要让它在第一次使用前一定能够得到赋值。也就是说，把初始化语句放在只有if块的条件判断语句中编译器也会抗议，因为执行的时候可能不符合if后面的判断条件，如此一来初始化语句就不会被执行了，这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句，就可以通过编译，因为无论如何，总有至少一条初始化语句会被执行，不会发生使用前未被初始化的事情。对于try-catch也是一样，如果只有在try块里才有初始化语句，编译部通过。如果在catch或finally里也有，则可以通过编译。总之，要保证局部变量在使用之前一定被初始化了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要出事化成什么值好，就用上面的默认值吧！ 
 
其实第三种变量和第二种本质上是一样的，都是方法中的局部变量。只不过作为参数，肯定是被初始化过的，传入的值就是初始值，所以不需要初始化。 
 
**问题六：**instanceof是什么东东？ 
 
instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子： 
 
String s = "I AM an Object!"; 
boolean isObject = s instanceof Object; 
 
我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。 
instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类： 
 
public class Bill \{//省略细节\} 
public class PhoneBill extends Bill \{//省略细节\} 
public class GasBill extends Bill \{//省略细节\} 
 
在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断： 
 
public double calculate(Bill bill) \{ 
  if (bill instanceof PhoneBill) \{ 
    //计算电话账单 
  \} 
  if (bill instanceof GasBill) \{ 
    //计算燃气账单 
  \} 
  ... 
\} 
这样就可以用一个方法处理两种子类。 
 
然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了： 
 
public double calculate(PhoneBill bill) \{ 
  //计算电话账单 
\} 
 
public double calculate(GasBill bill) \{ 
  //计算燃气账单 
\} 
 
所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态

2.   类加载器，classload原理，tomcat每个web使用classload的原因。

** java文件在解释成class文件之后，需要对里面的类进行初始化， 初始化的过程包括加载、连接、装入三个过程，在加载的过程中会对类里面的静态变量进行一个初始化。下面详细介绍下ClassLoader：**

1、类的加载、连接和初始化

类初始化通常包括加载、连接、初始化三个步骤。

（1）进程的结束

每当运行一个java程序时，将会启动一个java虚拟机进程，不管程序多么复杂，有多少线程，都在这个java虚拟机进程里。以下四种情况会使得该进程被终止——

·程序运行到最后正常结束；

·程序里遭遇了System.exit(),或者是Runtime.getRunTime().exit()代码；

·程序执行中遇到了未捕获的异常或者错误；

·java所在平台强制结束了JVM进程；

当该进程结束，那么该进程在内存中的状态将会丢失，包括静态变量的值。

（2）类的加载

**类的加载是指将类的class文件读入内存，并为之创建一个java.lang.class对象。**

** **

（3）类的连接

类的连接负责把类的二进制数据合并到JRE中，分为三个阶段——

·验证：检验被加载的类是否有正确的内部结构；

·准备：负责为类的静态Field分配内存，并设置默认初始值；

·解析：将类的二进制数据中的符号应用替换成直接引用。

（4）类的初始化

类的初始化，主要就是对静态Field进行初始化。

2、类加载器

（1）类加载器简介

类加载器负责加载所有的类，系统为所有载入内存里的类都会生成一个java.lang.class对象；

同一个类只会被加载一次，在JVM中每一个不同的类都会有一个不同的类加载器负责。

类加载器在不包括用户自定义的加载器的情况下包括三层：

·Bootstrap Classloader根加载器；

·ExtensionClassloader扩展类加载器；

·System ClassLoader系统类加载器；

①根加载器，又称为引导或者原始加载器，负责加载java的核心类；

②扩展类加载器，负责加载JRE的扩展目录中JAR包的类；

③系统类加载器，又称为应用加载器，负责JVM启动时加载来自java命令的\-classpath或者CLASSPATH环境变量所指定的JAR包和类路径。一般是程序运行的当前路径。所以其称为应用类加载器。

三个类加载器的顺序是：

bootstrapclassloader

extensionclassloader

systemclassloader

如果有用户自定义的类加载器，那么在系统加载器后，将会执行用户类加载器。

（2）自定义类加载器

如果我们需要在启动类加载时作一些特定需求的行为，那么就需要自定义类加载器了。

自定义ClassLoader需要继承ClassLoader抽象类，重写findClass方法，这个方法定义了ClassLoader查找class的方式。

主要可以扩展的方法有：

findClass定义查找Class的方式

defineClass将类文件字节码加载为jvm中的class

findResource定义查找资源的方式

（3）类加载机制

JVM的类加载机制有以下三种：

·全盘负责：

所谓全盘负责，即是当一个classloader加载一个Class的时候，这个Class所依赖的和引用的所有Class也由这个classloader负责载入，除非是显式的使用另外一个classloader载入。

·父类委托：

所谓父类委托，就是先让父类加载器先尝试加载该Class，当父类无法加载的时候，才是尝试从自己的类路径中去加载。JVM的ClassLoader采用的是树形结构，除了BootstrapClassLoader以外，每个ClassLoader都会有一个parentClassLoader，即父类加载器，用户自定义的ClassLoader默认的parendClassLoader是SystemClassLoader，当然你可以自己指定需要用哪一个ClassLoader的实例

·缓存机制：

所谓缓存机制就是保证所有加载过的类都会被缓存，当程序中需要某个类时，会先从缓存区中搜查该类，当缓存区不存在该类对象时，系统才会读取该类的二进制文件。

4、一些重要的方法

（1）loadClass方法

ClassLoader.loadClass()是ClassLoader的入口点。该方法的定义如下：

ClassloadClass(String name,boolean resolve);

name是加载的类的名称，resolve是告诉方法是不中需要解析类PS:并不是所有的类都需要解析，如果JVM只想知道这个类是否存在或找出该类的超类，那么就不需要解析该类

（2）defineClass方法

defineClass方法接受由原始字节组成的数组，并把它转换成Class的对象。原始数组包含如从文件系统或网络装入的数据。defineClass管理JVM的许多复杂的实现层面——它把字节码分析成运行时数据结构、校验有效性等，因为defineClass方法被标记成final的，所以不能覆盖它。

（3）findSytemClass方法

findSystemClass方法就是查找本的类Class文件，然后装入

（4）resolveClass方法

我们在调用编写自己的loadClass方法的时候可以调用resolveClass方法来获得resolve参数

（5）findLoadedClass方法

在调用loadClass方法之前可以调用改方法来查看地ClassLoader是否已经装入了这个类，这样可以避免重新装入这个类

（6）findClass方法

在loadClass默认实现调用这个新方法。findClass的用途包含classLoader的所有特殊代码，而无须复制其他代码

（7）getSystemClassLoader方法

在如果覆盖findClass或loadClass,getSystemClassLoader能以实际的ClassLoader对象访问系统ClassLoader(而不是固定地从findSystemClass调用它)。为了将类请求委托给父类ClassLoader,这个新方法允许ClassLoader获取它的父类ClassLoader.当使用特殊方法，定制的ClassLoader不能找到类时，可以使用这种方法。

父类ClassLoader被定义成创建该ClassLoader所包含代码的对象的ClassLoader.

(8）forName方法

在Class类中有一个静态方法forName,这个方法和ClassLoader中的loaderClass方法的目的是一样的，都是用来加载Class的，但是两者在作用上却有所区别：

loadClass加载实际上就是加载的时候并不对该类进行解释，因此不会初始化该类。而Class类的forName方法则相反，使用forName加载的时候就会将Class进行解释和初始化

3.   java内存泄漏的原因，GC

Java和C++中一个很大的区别就是Java有垃圾回收机制GC自动管理内存的回收，因此开发人员不需要调用方法来释放内存，而C++没有自动回收内存的机制，所以处处都需要留意内存的回收情况，万一不注意就可能出现内存泄露的情况。

但这是不是就表明Java就没有内存泄露的问题呢？答案是否定的，也有些情况也会导致Java编写的程序出现内存泄露的问题。

Java内存回收机制

不论哪种语言的内存分配方式，都需要返回所分配内存的其实地址，也就是返回一个指针到内存块的首地址。Java中对象是采用new或者反射的方法创建的，这些对象的创建都是在堆（Heap）中分配的，所有对象的回收都是由Java虚拟机通过垃圾回收机制完成的。GC为了能够正确释放对象，会监控每个对象的运行状况，对他们的申请、引用、被引用、赋值等状况进行监控，Java会使用有向图的方法进行管理内存，实时监控对象是否可以达到，如果不可到达，则就将其回收，这样也可以消除引用循环的问题。在Java语言中，判断一个内存空间是否符合垃圾收集标准有两个：一个是给对象赋予了空值null，以下再没有调用过，另一个是给对象赋予了新值，这样重新分配了内存空间。

Java内存泄露的原因

1、静态集合类像HashMap、Vector等的使用最容易出现内存泄露，这些静态变量的生命周期和应用程序一致，所有的对象Object也不能被释放，因为他们也将一直被Vector等应用着。

2、内部类和外部类的引用容易出现内存泄露的问题

3、监听器的使用，java中往往会使用到监听器，在释放对象的同时没有相应删除监听器的时候也可能导致内存泄露。

4、大量临时变量的使用，没有及时将对象设置为null也可能导致内存的泄露

5、数据库的连接没有关闭情况，包括连接池方法连接数据库，如果没有关闭ResultSet等也都可能出现内存泄露的问题。

举例一个内存泄露的例子：

Vector v = new Vector(10);

for (int i = 1; i<100; i++)\{

Object o = new Object();

v.add(o);

o = null;

别以为o对象被回收了，实际上v引用了这些对象，还被引用的对象GC是没有办法回收的，这样就很可能导致内存的泄露。

4.   JAVA的异常如何使用

一.什么是异常  
　　二.Java中如何处理异常  
　　三.深刻理解try,catch,finally,throws,throw五个关键字  
　　四.在类继承的时候，方法覆盖时如何进行异常抛出声明  
　　五.异常处理和设计的几个建议

**一.什么是异常                                                                              **

异常的英文单词是exception，字面翻译就是“意外、例外”的意思，也就是非正常情况。事实上，异常本质上是程序上的错误，包括程序逻辑错误和系统错误。比如使用空的引用、数组下标越界、内存溢出错误等，这些都是意外的情况，背离我们程序本身的意图。错误在我们编写程序的过程中会经常发生，包括编译期间和运行期间的错误，在编译期间出现的错误有编译器帮助我们一起修正，然而运行期间的错误便不是编译器力所能及了，并且运行期间的错误往往是难以预料的。假若程序在运行期间出现了错误，如果置之不理，程序便会终止或直接导致系统崩溃，显然这不是我们希望看到的结果。因此，如何对运行期间出现的错误进行处理和补救呢？Java提供了异常机制来进行处理，通过异常机制来处理程序运行期间出现的错误。通过异常机制，我们可以更好地提升程序的健壮性。

在Java中异常被当做对象来处理，根类是java.lang.Throwable类，在Java中定义了很多异常类（如OutOfMemoryError、NullPointerException、IndexOutOfBoundsException等），这些异常类分为两大类：Error和Exception。

Error是无法处理的异常，比如OutOfMemoryError，一般发生这种异常，JVM会选择终止程序。因此我们编写程序时不需要关心这类异常。

Exception，也就是我们经常见到的一些异常情况，比如NullPointerException、IndexOutOfBoundsException，这些异常是我们可以处理的异常。

Exception类的异常包括checked exception和uncheckedexception（unchecked exception也称运行时异常RuntimeException，当然这里的运行时异常并不是前面我所说的运行期间的异常，只是Java中用运行时异常这个术语来表示，Exception类的异常都是在运行期间发生的）。

unchecked exception（非检查异常），也称运行时异常（RuntimeException），比如常见的NullPointerException、IndexOutOfBoundsException。对于运行时异常，java编译器不要求必须进行异常捕获处理或者抛出声明，由程序员自行决定。

checked exception（检查异常），也称非运行时异常（运行时异常以外的异常就是非运行时异常），java编译器强制程序员必须进行捕获处理，比如常见的IOExeption和SQLException。对于非运行时异常如果不进行捕获或者抛出声明处理，编译都不会通过。

在Java中，异常类的结构层次图如下图所示：

在Java中，所有异常类的父类是Throwable类，Error类是error类型异常的父类，Exception类是exception类型异常的父类，RuntimeException类是所有运行时异常的父类，RuntimeException以外的并且继承Exception的类是非运行时异常。

典型的RuntimeException包括NullPointerException、IndexOutOfBoundsException、IllegalArgumentException等。

典型的非RuntimeException包括IOException、SQLException等。

**二.Java中如何处理异常                                                                **

在Java中如果需要处理异常，必须先对异常进行捕获，然后再对异常情况进行处理。如何对可能发生异常的代码进行异常捕获和处理呢？使用try和catch关键字即可，如下面一段代码所示：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 </td> 
 <td> try&nbsp;{ &nbsp;&nbsp;File file =&nbsp;new&nbsp;File("d:/a.txt"); &nbsp;&nbsp;if(!file.exists()) &nbsp;&nbsp;&nbsp;&nbsp;file.createNewFile(); }&nbsp;catch&nbsp;(IOException e) { &nbsp;&nbsp;// TODO: handle exception } </td> 
 </tr> 
 </tbody> 
</table>

被try块包围的代码说明这段代码可能会发生异常，一旦发生异常，异常便会被catch捕获到，然后需要在catch块中进行异常处理。

这是一种处理异常的方式。在Java中还提供了另一种异常处理方式即抛出异常，顾名思义，也就是说一旦发生异常，我把这个异常抛出去，让调用者去进行处理，自己不进行具体的处理，此时需要用到throw和throws关键字。

下面看一个示例：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 </td> 
 <td> public&nbsp;class&nbsp;Main { &nbsp;&nbsp;&nbsp;&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[] args) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;createFile(); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;catch&nbsp;(Exception e) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// TODO: handle exception &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;public&nbsp;static&nbsp;void&nbsp;createFile()&nbsp;throws&nbsp;IOException{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;File file =&nbsp;new&nbsp;File("d:/a.txt"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if(!file.exists()) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;file.createNewFile(); &nbsp;&nbsp;&nbsp;&nbsp;} } </td> 
 </tr> 
 </tbody> 
</table>

这段代码和上面一段代码的区别是，在实际的createFile方法中并没有捕获异常，而是用throws关键字声明抛出异常，即告知这个方法的调用者此方法可能会抛出IOException。那么在main方法中调用createFile方法的时候，采用try...catch块进行了异常捕获处理。

当然还可以采用throw关键字手动来抛出异常对象。下面看一个例子：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 </td> 
 <td> public&nbsp;class&nbsp;Main { &nbsp;&nbsp;&nbsp;&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[] args) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int[] data =&nbsp;new&nbsp;int[]{1,2,3}; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(getDataByIndex(-1,data)); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;catch&nbsp;(Exception e) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(e.getMessage()); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;public&nbsp;static&nbsp;int&nbsp;getDataByIndex(int&nbsp;index,int[] data) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if(index&lt;0||index&gt;=data.length) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;throw&nbsp;new&nbsp;ArrayIndexOutOfBoundsException("数组下标越界"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;data[index]; &nbsp;&nbsp;&nbsp;&nbsp;} } </td> 
 </tr> 
 </tbody> 
</table>

然后在catch块中进行捕获。

也就说在Java中进行异常处理的话，对于可能会发生异常的代码，可以选择三种方法来进行异常处理：

1）对代码块用try..catch进行异常捕获处理；

2）在 该代码的方法体外用throws进行抛出声明，告知此方法的调用者这段代码可能会出现这些异常，你需要谨慎处理。此时有两种情况：

如果声明抛出的异常是非运行时异常，此方法的调用者必须显示地用try..catch块进行捕获或者继续向上层抛出异常。

如果声明抛出的异常是运行时异常，此方法的调用者可以选择地进行异常捕获处理。

3）在代码块用throw手动抛出一个异常对象，此时也有两种情况，跟2）中的类似：

如果抛出的异常对象是非运行时异常，此方法的调用者必须显示地用try..catch块进行捕获或者继续向上层抛出异常。

如果抛出的异常对象是运行时异常，此方法的调用者可以选择地进行异常捕获处理。

（如果最终将异常抛给main方法，则相当于交给jvm自动处理，此时jvm会简单地打印异常信息）

**三.深刻理解try,catch,finally,throws,throw五个关键字                 　　**

下面我们来看一下异常机制中五个关键字的用法以及需要注意的地方。

1.try,catch,finally

try关键字用来包围可能会出现异常的逻辑代码，它单独无法使用，必须配合catch或者finally使用。Java编译器允许的组合使用形式只有以下三种形式：

try...catch...;      try....finally......;    try....catch...finally...

当然catch块可以有多个，注意try块只能有一个,finally块是可选的（但是最多只能有一个finally块）。

三个块执行的顺序为try—>catch—>finally。

当然如果没有发生异常，则catch块不会执行。但是finally块无论在什么情况下都是会执行的（这点要非常注意，因此部分情况下，都会将释放资源的操作放在finally块中进行）。

在有多个catch块的时候，是按照catch块的先后顺序进行匹配的，一旦异常类型被一个catch块匹配，则不会与后面的catch块进行匹配。

在使用try..catch..finally块的时候，注意千万不要在finally块中使用return，因为finally中的return会覆盖已有的返回值。下面看一个例子：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 </td> 
 <td> import&nbsp;java.io.FileInputStream; import&nbsp;java.io.FileNotFoundException; import&nbsp;java.io.IOException; &nbsp; &nbsp; public&nbsp;class&nbsp;Main { &nbsp;&nbsp;&nbsp;&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[] args) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;String str =&nbsp;new&nbsp;Main().openFile(); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(str); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;public&nbsp;String openFile() { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;FileInputStream inputStream =&nbsp;new&nbsp;FileInputStream("d:/a.txt"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;ch = inputStream.read(); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println("aaa"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;"step1"; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;catch&nbsp;(FileNotFoundException e) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println("file not found"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;"step2"; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}catch&nbsp;(IOException e) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println("io exception"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;"step3"; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}finally{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println("finally block"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//return "finally"; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;} } </td> 
 </tr> 
 </tbody> 
</table>

这段程序的输出结果为：

可以看出，在try块中发生FileNotFoundException之后，就跳到第一个catch块，打印"file notfound"信息，并将"step2"赋值给返回值，然后执行finally块，最后将返回值返回。

从这个例子说明，无论try块或者catch块中是否包含return语句，都会执行finally块。

如果将这个程序稍微修改一下，将finally块中的return语句注释去掉，运行结果是：

最后打印出的是"finally"，返回值被重新覆盖了。

因此如果方法有返回值，切忌不要再finally中使用return，这样会使得程序结构变得混乱。

2.throws和thow关键字

1）throws出现在方法的声明中，表示该方法可能会抛出的异常，然后交给上层调用它的方法程序处理，允许throws后面跟着多个异常类型；

2）一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。throw只会出现在方法体中，当方法在执行过程中遇到异常情况时，将异常信息封装为异常对象，然后throw出去。throw关键字的一个非常重要的作用就是 异常类型的转换（会在后面阐述道）。

throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由方法去处理异常，真正的处理异常由此方法的上层调用处理。

**四.在类继承的时候，方法覆盖时如何进行异常抛出声明                        **

本小节讨论子类重写父类方法的时候，如何确定异常抛出声明的类型。下面是三点原则：

1）父类的方法没有声明异常，子类在重写该方法的时候不能声明异常；

2）如果父类的方法声明一个异常exception1，则子类在重写该方法的时候声明的异常不能是exception1的父类；

3）如果父类的方法声明的异常类型只有非运行时异常（运行时异常），则子类在重写该方法的时候声明的异常也只能有非运行时异常（运行时异常），不能含有运行时异常（非运行时异常）。

**五.异常处理和设计的几个建议                                                         **

以下是根据前人总结的一些异常处理的建议：

1.只在必要使用异常的地方才使用异常，不要用异常去控制程序的流程

谨慎地使用异常，异常捕获的代价非常高昂，异常使用过多会严重影响程序的性能。如果在程序中能够用if语句和Boolean变量来进行逻辑判断，那么尽量减少异常的使用，从而避免不必要的异常捕获和处理。比如下面这段经典的程序：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 </td> 
 <td> public&nbsp;void&nbsp;useExceptionsForFlowControl() {&nbsp;&nbsp; &nbsp;&nbsp;try&nbsp;{&nbsp;&nbsp; &nbsp;&nbsp;while&nbsp;(true) {&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;increaseCount();&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;&nbsp; &nbsp;&nbsp;}&nbsp;catch&nbsp;(MaximumCountReachedException ex) {&nbsp;&nbsp; &nbsp;&nbsp;}&nbsp;&nbsp; &nbsp;&nbsp;//Continue execution&nbsp;&nbsp; }&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; public&nbsp;void&nbsp;increaseCount()&nbsp;throws&nbsp;MaximumCountReachedException {&nbsp;&nbsp; &nbsp;&nbsp;if&nbsp;(count &gt;=&nbsp;5000)&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;throw&nbsp;new&nbsp;MaximumCountReachedException();&nbsp;&nbsp; } </td> 
 </tr> 
 </tbody> 
</table>

上边的useExceptionsForFlowControl()用一个无限循环来增加count直到抛出异常，这种做法并没有说让代码不易读，而是使得程序执行效率降低。

2.切忌使用空catch块

在捕获了异常之后什么都不做，相当于忽略了这个异常。千万不要使用空的catch块，空的catch块意味着你在程序中隐藏了错误和异常，并且很可能导致程序出现不可控的执行结果。如果你非常肯定捕获到的异常不会以任何方式对程序造成影响，最好用Log日志将该异常进行记录，以便日后方便更新和维护。

3.检查异常和非检查异常的选择

一旦你决定抛出异常，你就要决定抛出什么异常。这里面的主要问题就是抛出检查异常还是非检查异常。

检查异常导致了太多的try…catch代码，可能有很多检查异常对开发人员来说是无法合理地进行处理的，比如SQLException，而开发人员却不得不去进行try…catch，这样就会导致经常出现这样一种情况：逻辑代码只有很少的几行，而进行异常捕获和处理的代码却有很多行。这样不仅导致逻辑代码阅读起来晦涩难懂，而且降低了程序的性能。

我个人建议尽量避免检查异常的使用，如果确实该异常情况的出现很普遍，需要提醒调用者注意处理的话，就使用检查异常；否则使用非检查异常。

因此，在一般情况下，我觉得尽量将检查异常转变为非检查异常交给上层处理。

4.注意catch块的顺序

不要把上层类的异常放在最前面的catch块。比如下面这段代码：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 </td> 
 <td> try&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;FileInputStream inputStream =&nbsp;new&nbsp;FileInputStream("d:/a.txt"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;ch = inputStream.read(); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println("aaa"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;"step1"; &nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;catch&nbsp;(IOException e) { 　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println("io exception");　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;"step2"; &nbsp;&nbsp;&nbsp;&nbsp;}catch&nbsp;(FileNotFoundException e) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println("file not found");　　　　&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;"step3"; &nbsp;&nbsp;&nbsp;&nbsp;}finally{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println("finally block"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//return "finally"; &nbsp;&nbsp;&nbsp;&nbsp;} </td> 
 </tr> 
 </tbody> 
</table>

第二个catch的FileNotFoundException将永远不会被捕获到，因为FileNotFoundException是IOException的子类。

5.不要将提供给用户看的信息放在异常信息里

比如下面这段代码：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 </td> 
 <td> public&nbsp;class&nbsp;Main { &nbsp;&nbsp;&nbsp;&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[] args) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try&nbsp;{ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;String user =&nbsp;null; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;String pwd =&nbsp;null; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;login(user,pwd); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;catch&nbsp;(Exception e) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(e.getMessage()); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;} &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;public&nbsp;static&nbsp;void&nbsp;login(String user,String pwd) { &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if(user==null||pwd==null) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;throw&nbsp;new&nbsp;NullPointerException("用户名或者密码为空"); &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//... &nbsp;&nbsp;&nbsp;&nbsp;} } </td> 
 </tr> 
 </tbody> 
</table>

展示给用户错误提示信息最好不要跟程序混淆一起，比较好的方式是将所有错误提示信息放在一个配置文件中统一管理。

6.避免多次在日志信息中记录同一个异常

只在异常最开始发生的地方进行日志信息记录。很多情况下异常都是层层向上跑出的，如果在每次向上抛出的时候，都Log到日志系统中，则会导致无从查找异常发生的根源。

7. 异常处理尽量放在高层进行

尽量将异常统一抛给上层调用者，由上层调用者统一之时如何进行处理。如果在每个出现异常的地方都直接进行处理，会导致程序异常处理流程混乱，不利于后期维护和异常错误排查。由上层统一进行处理会使得整个程序的流程清晰易懂。

8. 在finally中释放资源

如果有使用文件读取、网络操作以及数据库操作等，记得在finally中释放资源。这样不仅会使得程序占用更少的资源，也会避免不必要的由于资源未释放而发生的异常情况。

5.   css优先级（p以及class）

内联样式表的权值最高 1000；

ID 选择器的权值为 100

Class 类选择器的权值为 10

HTML 标签选择器的权值为 1

A  选择器都有一个权值，权值越大越优先；

B  当权值相等时，后出现的样式表设置要优于先出现的样式表设置；

C  创作者的规则高于浏览者：即网页编写者设置的CSS 样式的优先权高于浏览器所设置的样式；

D  继承的CSS 样式不如后来指定的CSS 样式；

E  在同一组属性设置中标有“!important”规则的优先级最大；示例如下：

6.   angular js框架，控制，特性

MVC

7.js捕获对象属性

8http协议有无状态？简介

9.spring游离态

10.struts控制器主键

11.设计模式继承缺点

继承的优缺点   
优点   
新的实现很容易，因为大部分是继承而来的   
很容易修改和扩展已有的实现   
  
缺点   
打破了封装，因为基类向子类暴露了实现细节   
白盒重用，因为基类的内部细节通常对子类是可见的   
当父类的实现改变时可能要相应的对子类做出改变   
不能在运行时改变由父类继承来的实现   
由此可见，组合比继承具有更大的灵活性和更稳定的结构，一般情况下应该优先考虑组合。只   
  
  
有当下列条件满足时才考虑使用继承：   
子类是一种特殊的类型，而不只是父类的一个角色   
子类的实例不需要变成另一个类的对象   
子类扩展，而不是覆盖或者使父类的功能失效