一、Java类中能存在同名的两个成员方法
在Java中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded），这个过程称为方法重载（method overloading）。方法重载是Java实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言，这个概念最初可能有点奇怪。但是你将看到，方法重载是Java最激动人心和最有用的特性之一。当一个重载方法被调用时，Java用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java调用一个重载方法时，参数与调用参数匹配的方法被执行。下面是一个说明方法重载的简单例子：// Demonstrate method overloading.
public class OverloadDemo{
void test(){
System.out.println("No parameters");
}// Overload
// test for one integer parameter.
void test(int a){
System.out.println("a:"+ a);
}
// Overload test for two integer parameters.
void test(int a, int b){
System.out.println("a and b:"+ a+""+ b);
}
// overload test for a double parameter
double test(double a){
System.out.println("double a:"+ a);
return a* a;
}
public static void main(String args[]){
OverloadDemo ob= new OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result= ob.test(123.25);
System.out.println("Result of ob.test(123.25):"+ result);
}
}
该程序产生如下输出： No parameters a: 10 a and b: 10 20 double a: 123.25 Result of ob.test(123.25): 15190.5625从上述程序可见，test()被重载了四次。第一个版本没有参数，第二个版本有一个整型参数，第三个版本有两个整型参数，第四个版本有一个double型参数。由于重载不受方法的返回类型的影响，test()第四个版本也返回了一个和重载没有因果关系的值。当一个重载的方法被调用时，Java在调用方法的参数和方法的自变量之间寻找匹配。但是，这种匹配并不总是精确的。在一些情况下，Java的自动类型转换也适用于重载方法的自变量。例如，看下面的程序：// Automatic type conversions apply to overloading. class OverloadDemo{ void test(){ System.out.println("No parameters");}// Overload test for two integer parameters. void test(int a，int b){ System.out.println("a and b:"+ a+""+ b);}// overload test for a double parameter void test(double a){ System.out.println("Inside test(double) a:"+ a);}} class Overload{ public static void main(String args[]){ OverloadDemo ob= new OverloadDemo(); int i= 88; ob.test();ob.test(10，20); ob.test(i);// this will invoke test(double) ob.test(123.2);// this will invoke test(double)}}该程序产生如下输出： No parameters a and b: 10 20 Inside test(double) a: 88 Inside test(double) a: 123.2在本例中，OverloadDemo的这个版本没有定义test(int)。因此当在Overload内带整数参数调用test()时，找不到和它匹配的方法。但是，Java可以自动地将整数转换为double型，这种转换就可以解决这个问题。因此，在test(int)找不到以后，Java将i扩大到double型，然后调用test(double)。当然，如果定义了test(int)，当然先调用test(int)而不会调用test(double)。只有在找不到精确匹配时，Java的自动转换才会起作用。方法重载支持多态性，因为它是Java实现“一个接口，多个方法”范型的一种方式。要理解这一点，考虑下面这段话：在不支持方法重载的语言中，每个方法必须有一个惟一的名字。但是，你经常希望实现数据类型不同但本质上相同的方法。可以参考绝对值函数的例子。在不支持重载的语言中，通常会含有这个函数的三个及三个以上的版本，每个版本都有一个差别甚微的名字。例如，在C语言中，函数abs()返回整数的绝对值，labs()返回long型整数的绝对值()，而fabs()返回浮点值的绝对值。尽管这三个函数的功能实质上是一样的，但是因为C语言不支持重载，每个函数都要有它自己的名字。这样就使得概念情况复杂许多。尽管每一个函数潜在的概念是相同的，你仍然不得不记住这三个名字。在Java中就不会发生这种情况，因为所有的绝对值函数可以使用同一个名字。确实,Java的标准的类库包含一个绝对值方法，叫做abs()。这个方法被Java的math类重载，用于处理数字类型。Java根据参数类型决定调用的abs()的版本。重载的价值在于它允许相关的方法可以使用同一个名字来访问。因此，abs这个名字代表了它执行的通用动作（general action）。为特定环境选择正确的指定（specific）版本是编译器要做的事情。作为程序员的你，只需要记住执行的通用操作就行了。通过多态性的应用，几个名字减少为一个。尽管这个例子相当简单，但如果你将这个概念扩展一下，你就会理解重载能够帮助你解决更复杂的问题。当你重载一个方法时,该方法的每个版本都能够执行你想要的任何动作。没有什么规定要求重载方法之间必须互相关联。但是，从风格上来说，方法重载还是暗示了一种关系。这就是当你能够使用同一个名字重载无关的方法时，你不应该这么做。例如，你可以使用sqr这个名字来创建一种方法，该方法返回一个整数的平方和一个浮点数值的平方根。但是这两种操作在功能上是不同的。按照这种方式应用方法就违背了它的初衷。在实际的编程中，你应该只重载相互之间关系紧密的操作。 7.1.1构造函数重载除了重载正常的方法外，构造函数也能够重载。实际上，对于大多数你创建的现实的类，重载构造函数是很常见的，并不是什么例外。为了理解为什么会这样，让我们回想上一章中举过的Box类例子。下面是最新版本的Box类的例子： class Box{ double width; double height; double depth;// This is the constructor for Box. Box(double w，double h，double d){width= w; height= h;depth= d;}// compute and return volume double volume(){ return width* height* depth;}}
本文来自CSDN博客，转载请标明出处：
二、在java中***异常处理的机制有哪几种***分别是什么
1引子
try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。
package myExample.testException;
public class TestException{
public TestException(){
}
boolean testEx() throws Exception{
boolean ret= true;
try{
ret= testEx1();
}catch(Exception e){
System.out.println("testEx, catch exception");
ret= false;
throw e;
}finally{
System.out.println("testEx, finally; return value="+ret);
return ret;
}
}
boolean testEx1() throws Exception{
boolean ret= true;
try{
ret= testEx2();
if(!ret){
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
}catch(Exception e){
System.out.println("testEx1, catch exception");
ret= false;
throw e;
}
finally{
System.out.println("testEx1, finally; return value="+ret);
return ret;
}
}
boolean testEx2() throws Exception{
boolean ret= true;
try{
int b=12;
int c;
for(int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
}
return true;
}catch(Exception e){
System.out.println("testEx2, catch exception");
ret= false;
throw e;
}
finally{
System.out.println("testEx2, finally; return value="+ret);
return ret;
}
}
public static void main(String[] args){
TestException testException1= new TestException();
try{
testException1.testEx();
}catch(Exception e){
e.printStackTrace();
}
}
}
你的答案是什么？是下面的答案吗？
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
如果你的答案真的如上面所说，那么你错啦。^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。
现在公布正确答案：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false
2基础知识
2.1相关概念
例外是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻止程序的正常运行。为了加强程序的鲁棒性，程序设计时，必须考虑到可能发生的异常事件并做出相应的处理。C语言中，通过使用if语句来判断是否出现了例外，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。全程变量ErroNo常常用来反映一个异常事件的类型。但是，这种错误处理机制会导致不少问题。
Java通过面向对象的方法来处理例外。在一个方法的运行过程中，如果发生了例外，则这个方法生成代表该例外的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一例外。我们把生成例外对象并把它提交给运行时系统的过程称为抛弃(throw)一个例外。运行时系统在方法的调用栈中查找，从生成例外的方法开始进行回朔，直到找到包含相应例外处理的方法为止，这一个过程称为捕获(catch)一个例外。
2.2 Throwable类及其子类
用面向对象的方法处理例外，就必须建立类的层次。类 Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个例外被抛弃。图1表示了例外处理的类层次。
从图中可以看出，类Throwable有两个直接子类：Error和Exception。Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类例外进行处理）；Exception类对象是Java程序处理或抛弃的对象。它有各种不同的子类分别对应于不同类型的例外。其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。Java编译器要求Java程序必须捕获或声明所有的非运行时例外，但对运行时例外可以不做处理。
图1例外处理的类层次
2.3异常处理关键字
Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。JB的在线帮助中对这几个关键字是这样解释的：
Throws: Lists the exceptions a method could throw.
Throw: Transfers control of the method to the exception handler.
Try： Opening exception-handling statement.
Catch： Captures the exception.
Finally： Runs its code before terminating the program.
2.3.1 try语句
try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。
2.3.2 catch语句
catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。
也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。
2.3.3 finally语句
try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。
2.3.4 throws语句
throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或 RuntimeException，或它们的子类，这个规则不起作用，因为这在程序的正常部分中是不期待出现的。如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。
2.3.5 throw语句
throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。
3关键字及其中语句流程详解
3.1 try的嵌套
你可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部，写另一个try语句保护其他代码。每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，堆栈就会展开，直到遇到有处理这种异常的try语句。下面是一个try语句嵌套的例子。
class MultiNest{
static void procedure(){
try{
int a= 0;
int b= 42/a;
} catch(java.lang.ArithmeticException e){
System.out.println("in procedure, catch ArithmeticException:"+ e);
}
}
public static void main(String args[]){
try{
procedure();
} catch(java.lang. Exception e){
System.out.println("in main, catch Exception:"+ e);
}
}
}
这个例子执行的结果为：
in procedure, catch ArithmeticException: java.lang.ArithmeticException:/ by zero
成员函数procedure里有自己的try/catch控制，所以main不用去处理 ArrayIndexOutOfBoundsException；当然如果如同最开始我们做测试的例子一样，在procedure中catch到异常时使用throw e;语句将异常抛出，那么main当然还是能够捕捉并处理这个procedure抛出来的异常。例如在procedure函数的catch中的System.out语句后面增加throw e;语句之后，执行结果就变为：
in procedure, catch ArithmeticException: java.lang.ArithmeticException:/ by zero
in main, catch Exception: java.lang.ArithmeticException:/ by zero
3.2 try-catch程序块的执行流程以及执行结果
相对于try-catch-finally程序块而言，try-catch的执行流程以及执行结果还是比较简单的。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
1．如果try块中所有语句正常执行完毕，那么就不会有其他的“动做”被执行，整个try-catch程序块正常完成。
2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
²如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。
²如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止（completes abruptly）”。
3．如果try由于其他原因R突然中止（completes abruptly），那么这个try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。
3.3 try-catch-finally程序块的执行流程以及执行结果
try-catch-finally程序块的执行流程以及执行结果比较复杂。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
1．如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况：
²如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
²如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
²如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：
²如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：
²如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
²如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
²如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：
²如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
（注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throw e抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是complete abruptly的（别小看这个用得最多的return，它也是一种导致complete abruptly的原因之一啊——后文中有关于导致complete abruptly的原因分析），所以整个try-catch-finally程序块的结果是“complete abruptly”，所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的，而只能将finally中的return结果获取到。
如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值，那么一定要注意你所调用的下级函数中的finally语句，它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。当然这种情况是可以避免的，以testEx2为例：如果你一定要使用finally而且又要将catch中throw的e在testEx1中被捕获到，那么你去掉testEx2中的finally中的return就可以了。
这个事情已经在OMC2.0的MIB中出现过啦：服务器的异常不能完全被反馈到客户端。）
²如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况：
²如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止（completes abruptly）”。
²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，异常V将被抛弃。
3．如果try由于其他原因R突然中止（completes abruptly），那么finally块被执行，分为两种情况：
²如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
²如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
3.4 try-catch-finally程序块中的return
从上面的try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权（语句流程）转到finally块中；这种情况下一定要注意返回值的处理。
例如，在try或者catch中return false了，而在finally中又return true，那么这种情况下不要期待你的try或者catch中的return false的返回值false被上级调用函数获取到，上级调用函数能够获取到的只是finally中的返回值，因为try或者catch中的return语句只是转移控制权的作用。
3.5如何抛出异常
如果你知道你写的某个函数有可能抛出异常，而你又不想在这个函数中对异常进行处理，只是想把它抛出去让调用这个函数的上级调用函数进行处理，那么有两种方式可供选择：
第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch。比如将最开始的例子中的testEx2改为下面的方式，那么testEx1就能捕捉到testEx2抛出的异常了。
boolean testEx2() throws Exception{
boolean ret= true;
int b=12;
int c;
for(int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
}
return true;
}
第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：
boolean testEx2() throws Exception{
boolean ret= true;
try{
int b=12;
int c;
for(int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
}
return true;
}catch(Exception e){
System.out.println("testEx2, catch exception");
Throw e;
}
}
第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：
boolean testEx2() throws Exception{
boolean ret= true;
try{
int b=12;
int c;
for(int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
throw new Exception("aaa");
}
return true;
}catch(java.lang.ArithmeticException e){
System.out.println("testEx2, catch exception");
ret= false;
throw new Exception("aaa");
}finally{
System.out.println("testEx2, finally; return value="+ret);
}
}
4关于abrupt completion
前面提到了complete abruptly（暂且理解为“突然中止”或者“异常结束”吧），它主要包含了两种大的情形：abrupt completion of expressions and statements，下面就分两种情况进行解释。
4.1 Normal and Abrupt Completion of Evaluation
每一个表达式（expression）都有一种使得其包含的计算得以一步步进行的正常模式，如果每一步计算都被执行且没有异常抛出，那么就称这个表达式“正常结束（complete normally）”；如果这个表达式的计算抛出了异常，就称为“异常结束（complete abruptly）”。异常结束通常有一个相关联的原因（associated reason），通常也就是抛出一个异常V。
与表达式、操作符相关的运行期异常有：
² A class instance creation expression, array creation expression, or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available.
² An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero.
² A field access throws a NullPointerException if the value of the object reference expression is null.
² A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null.
² An array access throws a NullPointerException if the value of the array reference expression is null.
² An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.
² A cast throws a ClassCastException if a cast is found to be impermissible at run time.
² An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero.
² An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.
4.2 Normal and Abrupt Completion of Statements
正常情况我们就不多说了，在这里主要是列出了abrupt completion的几种情况：
² break, continue, and return语句将导致控制权的转换，从而使得statements不能正常地、完整地执行。
²某些表达式的计算也可能从java虚拟机抛出异常，这些表达式在上一小节中已经总结过了；一个显式的的throw语句也将导致异常的抛出。抛出异常也是导致控制权的转换的原因（或者说是阻止statement正常结束的原因）。
如果上述事件发生了，那么这些statement就有可能使得其正常情况下应该都执行的语句不能完全被执行到，那么这些statement也就是被称为是complete abruptly.
导致abrupt completion的几种原因：
² A break with no label
² A break with a given label
² A continue with no label
² A continue with a given label
² A return with no value
² A return with a given value A
² throw with a given value, including exceptions thrown by the Java virtual machine
5关于我们的编程的一点建议
弄清楚try-catch-finally的执行情况后我们才能正确使用它。
如果我们使用的是try-catch-finally语句块，而我们又需要保证有异常时能够抛出异常，那么在finally语句中就不要使用return语句了（finally语句块的最重要的作用应该是释放申请的资源），因为finally中的return语句会导致我们的throw e被抛弃，在这个try-catch-finally的外面将只能看到finally中的返回值（除非在finally中抛出异常）。（我们需要记住：不仅throw语句是abrupt completion的原因，return、break、continue等这些看起来很正常的语句也是导致abrupt completion的原因。）
三、java中的空指针异常怎么解决
原文：
你这个问题的解决
问题定位：
在堆栈异常信息的第一行就可以定位到是哪里出了空指针，倘若这里不是你写的类，可以往下翻一下，找到你写的类，就是这里出现的空指针。
问题解决：
对一个空对象调用里面的方法或者属性的时候会报空指针，检查这个对象为什么是空即可。
Java空指针异常的若干解决方案
Java中任何对象都有可能为空，当我们调用空对象的方法时就会抛出 NullPointerException空指针异常，这是一种非常常见的错误类型。我们可以使用若干种方法来避免产生这类异常，使得我们的代码更为健壮。本文将列举这些解决方案，包括传统的空值检测、编程规范、以及使用现代 Java语言引入的各类工具来作为辅助。
运行时检测
最显而易见的方法就是使用 if(obj== null)来对所有需要用到的对象来进行检测，包括函数参数、返回值、以及类实例的成员变量。当你检测到 null值时，可以选择抛出更具针对性的异常类型，如 IllegalArgumentException，并添加消息内容。我们可以使用一些库函数来简化代码，如 Java 7开始提供的 Objects#requireNonNull方法：
public void testObjects(Object arg){
Object checked= Objects.requireNonNull(arg,"arg must not be null");
checked.toString();}
Guava的 Preconditions类中也提供了一系列用于检测参数合法性的工具函数，其中就包含空值检测：
public void testGuava(Object arg){
Object checked= Preconditions.checkNotNull(arg,"%s must not be null","arg");
checked.toString();
}
我们还可以使用 Lombok来生成空值检测代码，并抛出带有提示信息的空指针异常：
public void testLombok(@NonNull Object arg){
arg.toString();
生成的代码如下：
public void testLombokGenerated(Object arg){
if(arg== null){
throw new NullPointerException("arg is marked@NonNull but is null");
}
arg.toString();
}
这个注解还可以用在类实例的成员变量上，所有的赋值操作会自动进行空值检测。
编程规范
·通过遵守某些编程规范，也可以从一定程度上减少空指针异常的发生。
使用那些已经对 null值做过判断的方法，如 String#equals、String#valueOf、以及三方库中用来判断字符串和集合是否为空的函数：
if(str!= null&& str.equals("text")){}
if("text".equals(str)){}
if(obj!= null){ obj.toString();}
String.valueOf(obj);//"null"
// from spring-core
StringUtils.isEmpty(str);
CollectionUtils.isEmpty(col);
// from guava
Strings.isNullOrEmpty(str);
// from commons-collections4
CollectionUtils.isEmpty(col);
·如果函数的某个参数可以接收 null值，考虑改写成两个函数，使用不同的函数签名，这样就可以强制要求每个参数都不为空了：
public void methodA(Object arg1){
methodB(arg1, new Object[0]);
}
public void methodB(Object arg1, Object[] arg2){
for(Object obj: arg2){}// no null check
}
·如果函数的返回值是集合类型，当结果为空时，不要返回 null值，而是返回一个空的集合；如果返回值类型是对象，则可以选择抛出异常。Spring JdbcTemplate正是使用了这种处理方式：
//当查询结果为空时，返回 new ArrayList<>()
jdbcTemplate.queryForList("SELECT* FROM person");
//若找不到该条记录，则抛出 EmptyResultDataAccessException
jdbcTemplate.queryForObject("SELECT age FROM person WHERE id= 1", Integer.class);
//支持泛型集合
public<T> List<T> testReturnCollection(){
return Collections.emptyList();
}
静态代码分析
Java语言有许多静态代码分析工具，如 Eclipse IDE、SpotBugs、Checker Framework等，它们可以帮助程序员检测出编译期的错误。结合@Nullable和@Nonnull等注解，我们就可以在程序运行之前发现可能抛出空指针异常的代码。
但是，空值检测注解还没有得到标准化。虽然 2006年 9月社区提出了 JSR 305规范，但它长期处于搁置状态。很多第三方库提供了类似的注解，且得到了不同工具的支持，其中使用较多的有：
javax.annotation.Nonnull：由 JSR 305提出，其参考实现为 com.google.code.findbugs.jsr305；
org.eclipse.jdt.annotation.NonNull：Eclipse IDE原生支持的空值检测注解；
edu.umd.cs.findbugs.annotations.NonNull：SpotBugs使用的注解，基于 findbugs.jsr305；
org.springframework.lang.NonNull：Spring Framework 5.0开始提供；
org.checkerframework.checker.nullness.qual.NonNull：Checker Framework使用；
android.support.annotation.NonNull：集成在安卓开发工具中；
我建议使用一种跨 IDE的解决方案，如 SpotBugs或 Checker Framework，它们都能和 Maven结合得很好。
SpotBugs与@NonNull、@CheckForNull
SpotBugs是 FindBugs的后继者。通过在方法的参数和返回值上添加@NonNull和@CheckForNull注解，SpotBugs可以帮助我们进行编译期的空值检测。需要注意的是，SpotBugs不支持@Nullable注解，必须用@CheckForNull代替。如官方文档中所说，仅当需要覆盖@ParametersAreNonnullByDefault时才会用到@Nullable。
官方文档中说明了如何将 SpotBugs应用到 Maven和 Eclipse中去。我们还需要将 spotbugs-annotations加入到项目依赖中，以便使用对应的注解。
<dependency><groupId>com.github.spotbugs</groupId>
<artifactId>spotbugs-annotations</artifactId>
<version>3.1.7</version>
</dependency>
以下是对不同使用场景的说明：
@NonNullprivate Object returnNonNull(){
//错误：returnNonNull()可能返回空值，但其已声明为@Nonnull
return null;
}
@CheckForNull
private Object returnNullable(){
return null;
}
public void testReturnNullable(){
Object obj= returnNullable();
//错误：方法的返回值可能为空
System.out.println(obj.toString());
}
private void argumentNonNull(@NonNull Object arg){
System.out.println(arg.toString());
}
public void testArgumentNonNull(){
//错误：不能将 null传递给非空参数
argumentNonNull(null);
}
public void testNullableArgument(@CheckForNull Object arg){
//错误：参数可能为空
System.out.println(arg.toString());
}
对于 Eclipse用户，还可以使用 IDE内置的空值检测工具，只需将默认的注解 org.eclipse.jdt.annotation.Nullable替换为 SpotBugs的注解即可：
Checker Framework与@NonNull、@Nullable
Checker Framework能够作为 javac编译器的插件运行，对代码中的数据类型进行检测，预防各类问题。我们可以参照官方文档，将 Checker Framework与 maven-compiler-plugin结合，之后每次执行 mvn compile时就会进行检查。Checker Framework的空值检测程序支持几乎所有的注解，包括 JSR 305、Eclipse、甚至 lombok.NonNull。
import org.checkerframework.checker.nullness.qual.Nullable;@Nullable
private Object returnNullable(){
return null;
}
public void testReturnNullable(){
Object obj= returnNullable();
//错误：obj可能为空
System.out.println(obj.toString());
}
Checker Framework默认会将@NonNull应用到所有的函数参数和返回值上，因此，即使不添加这个注解，以下程序也是无法编译通过的：
private Object returnNonNull(){//错误：方法声明为@NonNull，但返回的是 null。
return null;
}
private void argumentNonNull(Object arg){
System.out.println(arg.toString());
}
public void testArgumentNonNull(){
//错误：参数声明为@NonNull，但传入的是 null。
argumentNonNull(null);
}
Checker Framework对使用 Spring Framework 5.0以上的用户非常有用，因为 Spring提供了内置的空值检测注解，且能够被 Checker Framework支持。一方面我们无需再引入额外的 Jar包，更重要的是 Spring Framework代码本身就使用了这些注解，这样我们在调用它的 API时就能有效地处理空值了。举例来说，StringUtils类里可以传入空值的函数、以及会返回空值的函数都添加了@Nullable注解，而未添加的方法则继承了整个框架的@NonNull注解，因此，下列代码中的空指针异常就可以被 Checker Framework检测到了：
//这是 spring-core中定义的类和方法public abstract class StringUtils{
// str参数继承了全局的@NonNull注解
public static String capitalize(String str){}
@Nullable
public static String getFilename(@Nullable String path){}
}
//错误：参数声明为@NonNull，但传入的是 null。
StringUtils.capitalize(null);
String filename= StringUtils.getFilename("/path/to/file");
//错误：filename可能为空。
System.out.println(filename.length());
Optional类型
Java 8引入了 Optional<T>类型，我们可以用它来对函数的返回值进行包装。这种方式的优点是可以明确定义该方法是有可能返回空值的，因此调用方必须做好相应处理，这样也就不会引发空指针异常。但是，也不可避免地需要编写更多代码，而且会产生很多垃圾对象，增加 GC的压力，因此在使用时需要酌情考虑。
Optional<String> opt;//创建
opt= Optional.empty();
opt= Optional.of("text");
opt= Optional.ofNullable(null);
//判断并读取
if(opt.isPresent()){
opt.get();
}
//默认值
opt.orElse("default");
opt.orElseGet(()->"default");
opt.orElseThrow(()-> new NullPointerException());
//相关操作
opt.ifPresent(value->{
System.out.println(value);
});
opt.filter(value-> value.length()> 5);
opt.map(value-> value.trim());
opt.flatMap(value->{
String trimmed= value.trim();
return trimmed.isEmpty()? Optional.empty(): Optional.of(trimmed);
});
方法的链式调用很容易引发空指针异常，但如果返回值都用 Optional包装起来，就可以用 flatMap方法来实现安全的链式调用了：
String zipCode= getUser().flatMap(User::getAddress)
.flatMap(Address::getZipCode)
.orElse("");
Java 8 Stream API同样使用了 Optional作为返回类型：
stringList.stream().findFirst().orElse("default");stringList.stream()
.max(Comparator.naturalOrder())
.ifPresent(System.out::println);
此外，Java 8还针对基础类型提供了单独的 Optional类，如 OptionalInt、OptionalDouble等，在性能要求比较高的场景下很适用。
其它 JVM语言中的空指针异常
Scala语言中的 Option类可以对标 Java 8的 Optional。它有两个子类型，Some表示有值，None表示空。
val opt: Option[String]= Some("text")opt.getOrElse("default")
除了使用 Option#isEmpty判断，还可以使用 Scala的模式匹配：
opt match{case Some(text)=> println(text)
case None=> println("default")
Scala的集合处理函数库非常强大，Option则可直接作为集合进行操作，如 filer、map、以及列表解析（for-comprehension）：
opt.map(_.trim).filter(_.length> 0).map(_.toUpperCase).getOrElse("DEFAULT")val upper= for{
text<- opt
trimmed<- Some(text.trim())
upper<- Some(trimmed) if trimmed.length> 0
} yield upper
upper.getOrElse("DEFAULT")
Kotlin使用了另一种方式，用户在定义变量时就需要明确区分可空和不可空类型。当可空类型被使用时，就必须进行空值检测。
var a: String="text"a= null//错误：无法将 null赋值给非空 String类型。
val b: String?="text"
//错误：操作可空类型时必须使用安全操作符（?.）或强制忽略（!!.）。
println(b.length)
val l: Int?= b?.length//安全操作
b!!.length//强制忽略，可能引发空值异常
Kotlin的特性之一是与 Java的可互操作性，但 Kotlin编译器无法知晓 Java类型是否为空，这就需要在 Java代码中使用注解了，而 Kotlin支持的注解也非常广泛。Spring Framework 5.0起原生支持 Kotlin，其空值检测也是通过注解进行的，使得 Kotlin可以安全地调用 Spring Framework的所有 API。
结论
在以上这些方案中，我比较推荐使用注解来预防空指针异常，因为这种方式十分有效，对代码的侵入性也较小。所有的公共 API都应该使用@Nullable和@NonNull进行注解，这样就能强制调用方对空指针异常进行预防，让我们的程序更为健壮。