Java面试知识点总结(Java基础 )

一、基础篇

1.1、Java基础

1.1.1、面向对象的特征：继承、封装、多态、抽象

抽象：

从具体事物抽出、概括出它们共同的方面、本质属性与关系等，而将个别的、非本质的方面、属性与关系舍弃，这种思维过程，称为抽象。

Object 类位于 java.lang 包中，是所有 Java 类的祖先，是对万事万物的抽象。Java 中的每个类都由它扩展而来。

封装

封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的类或对象进行信息隐藏。一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。

继承

继承的成本很低，通过extends关键字就可以使用别人的方法，在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

但是我们也应该谨慎使用继承，防止方法污染和方法爆炸

多态

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。

1.1.2、final, finally, finalize 的区别

final

用于声明属性,方法和类, 分别表示属性不可变, 方法不可覆盖, 类不可继承。

finally

异常处理语句结构的一部分，表示总是执行。finally关键字是对Java异常处理模型的最佳补充。finally结构使代码总会执行，不关有无异常发生。使得finally可以维护对象的内部状态，并可以清理非内存资源，比如关闭文件的读写操作，或者是关闭数据库的连接等等。

finalize

Object类的一个方法，这个方法是由垃圾收集器在确定这个对象没有被引用是对这个对象调用的。它是Object类中定义的，因此，所有的类都继承了它。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。 JVM不保证此方法总被调用。

1.1.3、Exception、Error、运行时异常与一般异常有何异同

Exception

Exception ：表示可恢复的例外，可补足的。

Error

Error：表示由JVM 所侦测到的无法预期的错误，由于这是属于 JVM 层次的严重错误，导致 JVM 无法继续执行，因此，这是不可捕捉的，无法采取任何恢复的操作，顶多只能显示错误信息。

Runtime Exception

Runtime Exception，也叫运行时异常，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过 NullPointerException 异常，它就是运行时异常，并且，这种异常还是最常见的异常之一。

处理 RuntimeException 的原则是：假如出现 RuntimeException，那么一定是程序员的错误，例如，可以通过检查数组小标和数组边界来避免越界访问异常。

出现运行时异常后，系统会把异常一直往上抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由 Thread.run() 抛出，如果是单线程就被 main() 抛出。抛出之后，如果是线程，这个线程也就退出了。如果主程序抛出的异常，那么这个程序也就退出了。运行时异常是 Exception 的子类，也就是一般异常的特点，也可以被catch 块处理的。只不够往往我们不处理罢了。也就是说，我如果不对运行时异常进行处理，那么出现运行时异常之后，要么线程终止，要么主程序终止。

如果不想终止，则必须捕捉所有的运行时异常，决不让这个线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。在这个场景这样的处理可能是一个比较好的应用，但并不代表在所有的场景都应该如此。如果在其它场景，遇到了一些错误，如果退出程序比较好，这时你就可以不太理会运行时异常，或者是通过对异常的处理显示的控制程序退出。

异常处理的目标之一就是为了把程序从异常中恢复出来。

checked exception

checked 异常也就是经常遇到的 IO 异常以及 SQL 异常都是这种异常。对于这种异常，Java 编译器强制要求我们必须对出现的这些异常进行 catch。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆 catch 块去处理可能的异常。这类异常一般是外部错误，例如试图从文件尾后读取数据错误，这并不是程序本身的错误，而是在应用环境中出现的外部错误。

在定义方法时必须声明所有可能会抛出的checked exception;在调用这个方法时，必须捕获它的checked exception，不然就得把它的exception传递下去；checked exception是从java.lang.Exception类衍生出来的。

1.1.4、请写出5种常见到的Runtime Exception

ClassCastException 类型强制转换异常

Object x = new Integer(0);
System.out.println((String)x);

当试图将对象强制转换为不是实例的子类时，抛出该异常

ArithmeticException 算术异常类

int a=5/0;

一个整数“除以零”时，抛出异常

NullPointerException 空指针异常类

String s=null;
int size=s.size();

当应用程序试图在需要对象的地方使用 null 时，抛出异常

StringIndexOutOfBoundsException

"hello".indexOf(-1);

指示索引或者为负，或者超出字符串的大小，抛出异常

NegativeArraySizeException 数组负下标异常

数组大小为负值异常。当使用负数大小值创建数组时抛出该异常

String[] ss=new String[-1];

如应用程序试图创建大小为负的数组，则抛出异常

IllegalArgumentException 参数异常

抛出的异常表明向方法传递了一个不合法或不正确的参数

NumberFormatException 数字格式异常

当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常

ArrayIndexOutOfBoundsException 数组下标越界异常

当使用的数组下标超出数组允许范围时，抛出该异常

ClassNotFoundException 找不到类异常

当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常

ArrayStoreException 数组存储异常

当向数组中存放非数组声明类型对象时抛出

IOException 输入输出异常

NoSuchMethodException 方法未找到异常

FileNotFoundException 文件未找到异常

1.1.5、int 和 Integer 有什么区别，Integer的值缓存范围

• Integer是int的包装类；int是基本数据类型；
• Integer变量必须实例化后才能使用；int变量不需要；
• Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值 ；
• Integer的默认值是null；int的默认值是0。

Integer的值缓存范围为 -128~127

1.1.6、包装类，装箱和拆箱

自动拆装箱是Java1.5的一个新特性，自动装箱/拆箱大大方便了基本类型数据和它们包装类的使用。

自动装箱：基本类型自动转为包装类（int —> Integer）

自动拆箱：包装类自动转为基本类型（Integer —> int）

java对于自动装箱与拆箱的设计，是一种模式：叫享元模式（flyweight）

包装类是针对于原生数据类型的包装。因为有8个原生数据类型，所以对应有8个包装类。所有的包装类（8个）都位于java.lang下。

每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一经创建，其内容（所封装的基本类型数据值）不可改变。

基本类型和对应的包装类可以相互装换：

• 由基本类型向对应的包装类转换称为装箱，例如把 int 包装成 Integer 类的对象；
• 包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。

1.1.7、String、StringBuilder、StringBuffer

String 字符串常量

StringBuffer 字符串变量（线程安全）

StringBuilder 字符串变量（非线程安全）

简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：

String S1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is only a”).append(“simple”).append(“ test”);

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个
String S1 = “This is only a” + “ simple” + “test”;其实就是：
String S1 = “This is only a simple test”;所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：

String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;

这时候 JVM 会规规矩矩的按照原来的方式去做

在大部分情况下StringBuilder >StringBuffer > String
StringBuilde
java.lang.StringBuilder可变的字符序列是Java1.5新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

1.1.8、重载和重写的区别

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

在上面的例子中可以看到，尽管b属于Animal类型，但是它运行的是Dog类的move方法。

这是由于在编译阶段，只是检查参数的引用类型。

然而在运行时，Java虚拟机(JVM)指定对象的类型并且运行该对象的方法。

因此在上面的例子中，之所以能编译成功，是因为Animal类中存在move方法，然而运行时，运行的是特定对象的方法。

思考以下例子：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
   }
}

以上实例编译运行结果如下：

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

该程序将抛出一个编译错误，因为b的引用类型Animal没有bark方法。

方法的重写规则

• 参数列表必须完全与被重写方法的相同；
• 返回类型必须完全与被重写方法的返回类型相同；
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
• 父类的成员方法只能被它的子类重写。
• 声明为final的方法不能被重写。
• 声明为static的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个方法，则不能重写这个方法。

Super关键字的使用

当需要在子类中调用父类的被重写方法时，要使用super关键字。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
 
      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法
 
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

重写与重载之间的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

总结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

• 方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
• 方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
• 方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

1.1.9、抽象类和接口有什么区别

抽象类（abstract class）：

使用abstract修饰符修饰的类。官方点的定义就是：如果一个类没有包含足够多的信息来描述一个具体的对象，这样的类就是抽象类。

实际点来说，一个抽象类不能实例化，因为“没有包含足够多的信息来描述一个具体的对象”。但终归属于类，所以仍然拥有普通类一样的定义。依然可以在类的实体（直白点就是能在｛｝里面)定义成员变量，成员方法，构造方法等。

接口（interface）：

官方定义：接口在Java中是一个抽象类型，是抽象方法的集合。一个类通过继承接口的方式，从而继承接口的抽象方法。

从定义上看，接口是个集合，并不是类。类描述了属性和方法，而接口只包含方法（未实现的方法）。接口和抽象类一样不能被实例化，因为不是类。但是接口可以被实现（使用 implements 关键字）。实现某个接口的类必须在类中实现该接口的全部方法。虽然接口内的方法都是抽象的（和抽象方法很像，没有实现）但是不需要abstract关键字。

接口中没有构造方式（因为接口不是类）

接口中的方法必须是抽象的（不能实现）

接口中除了static、final变量，不能有其他变量

接口支持多继承（一个类可以实现多个接口）

抽象类和接口的区别：

默认的方法实现

抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。

抽象类中可以有已经实现了的方法，也可以有被abstract修饰的方法（抽象方法），因为存在抽象方法，所以该类必须是抽象类。但是接口要求只能包含抽象方法，抽象方法是指没有实现的方法。所以就不能像抽象类那么无赖了，接口就根本不能存在方法的实现。

实现

抽象类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。

子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现。

抽象类虽然不能实例化来使用，但是可以被继承，让子类来具体实现父类的所有抽象方法。有点老子没完成的梦想交给儿子来完成，但是如果子类将抽象方法没有全部实现，就必须把自己也修饰成抽象类，交于继承它的子类来完成实现。就相当于，儿子能力不够也没完成老爹的梦想，现在儿子等着再生儿子（被继承），然后让孙子去完成。以此类推，知道没有抽象函数。

接口的实现，通过implements关键字。实现该接口的类，必须把接口中的所有方法给实现。不能再推给下一代。和抽象类相比，抽象类是将梦想传给家族，一代一代去完成。那么接口就是掌门人找大师兄来完成帮派的鸿星伟业，这时候就只有一次希望，要么有能力就实现，没能力就不要接。

抽象类可以有构造器，而接口不能有构造器

抽象类属于类，天生享有类的所有特性（但是不能实例化），当然包括类的构造方法，也就是构造器。

但是接口是所有抽象方法的集合，注意，是集合，不是类。当然没有构造方法一说，更别提什么构造器了。

抽象方法可以有public、protected和default这些修饰符

接口方法默认修饰符是public。你不可以使用其它修饰符。

抽象类在java语言中所表示的是一种继承关系，一个子类只能存在一个父类，但是可以存在多个接口。

抽象方法比接口速度要快

接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。

如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。

如果你往接口中添加方法，那么你必须改变实现该接口的类。

什么时候使用抽象类和接口

• 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
• 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
• 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

1.1.10、说说反射的用途及实现

什么是Java类中的反射？

当程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言。我们认为 Java 并不是动态语言，但是它却又一个非常突出的动态相关的机制，俗称：反射。
Reflection 是Java 程序开发语言的特征之一，它允许运行中的 Java 程序获取自身的信息，并且可以操作类和对象的内部属性。

通过反射，我们可以在运行时获得程序或程序集中每一个类型成员和成员变量的信息。
程序中一般的对象类型都是在编译期就确定下来的，而Java 反射机制可以动态的创建对象并调用其属性，这样对象的类型在编译期是未知的。所以我们可以通过反射机制直接创建对象即使这个对象在编译期是未知的，
反射的核心：是 JVM 在运行时 才动态加载的类或调用方法或属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。

Java反射框架提供以下功能：

1. 在运行时判断任意一个对象所属的类
2. 在运行时构造任意一个类的对象
3. 在运行时判断任意一个类所具有的成员变量和方法（通过反射设置可以调用 private）
4. 在运行时调用人一个对象的方法

反射的主要用途

很多人都认为反射在实际Java中开发应用中并不广泛，其实不然。
当我们在使用 IDE（如 Eclipse\IDEA）时，当我们输入一个对象或者类并向调用它的属性和方法时，一按 (“.”)点号，编译器就会自动列出她的属性或方法，这里就会用到反射。

反射最重要的用途就是开发各种通用框架。

反射的基本运用

以上我们提到了反射可以拟用于判断任意对象所属的类，获得 Class对象，构造人一个对象以及调用一个对象。这里我们介绍一下基本反射功能的事先（反射相关类一般都在 java.lang.relfect包里）。

获得 Class 对象

使用 Class类的 forName() 静态方法：

public static Class<?> forName(String className)

在JDBC开发中常用此方法加载数据库驱动:

Class.forName(driver)

直接获取某一个对象的 class，比如：

Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;

调用某个对象的getClass() 方法，比如：

StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();

判断是否为某个类的实例

一般地，我们用 instanceof关键字来判断是否为某个类的实例。同时我们也可以借助反射中Class对象的 isInstance()方法来判断是否为某个类的实例，它是一个 Native 方法：

  public native boolean isInstance(Object obj);

创建实例

通过反射来生成对象主要有两种方式。

使用 Class 对象的 newInstance() 方法来创建对象对应类的实例

Class<?> c  = String.calss;
Object str = c.getInstance();

先通过 Class 对象获取制定的 Constructor 对象，在调用 Constructor 对象的 newInstance() 方法来创建实例

这种方法可以用指定的构造器构造类的实例。

  //获取String所对应的Class对象
   Class<?> c = String.class;
  //获取String类带一个String参数的构造器
  Constructor constructor = c.getConstructor(String.class);
  //根据构造器创建实例
  Object obj = constructor.newInstance("23333");
  System.out.println(obj);

1.1.11、说说自定义注解的场景及实现

元注解

java中有四种元注解：@Retention、@Inherited、@Documented、@Target

Java注解基本知识

• 注解是代码的附属信息，不能干扰代码的正常执行，无论删除或增加注解，代码都能够正常执行
• 定义注解使用@interface修饰符
• Java预定义注解被称为元注解，它们被Java编译器使用，比如：@Retention注解和@Target注解，前者定义注解的保留期限，后者定义注解的应用目标
• 注解的成员声明和接口的方法声明类似，还可以使用default关键字指定成员的默认值
• 如果注解只有一个成员，则成员名必须取名为value(),使用时如果给成员赋值可以不写成员名和赋值符号’=’
• 如果注解有多个成员，在赋值时如果只给value()成员赋值，也可以不写成员名和赋值符号’=’
• 如果在赋值时要同时给多个成员赋值，则必须写成员名和赋值符号’=’
• 所有注解类都隐式继承与java.lang.annotation.Annotation,但是注解不允许显示继承于其他的接口

如何访问注解

通过Java的反射机制读取注解的信息
若要通过反射来读取注解信息，那么被定义的注解的保留期限必须是RententionPolicy.RUNTIME,
只有该策略下的注解信息会被保留在目标类代码的字节码中，并且当类加载器加载字节码时会将注解信息加载到JVM中

自定义注解使用场景

• 类属性自动赋值。
• 验证对象属性完整性。
• 代替配置文件功能，像spring基于注解的配置。
• 可以生成文档，像Java代码注释中的@see,@param等

定义注解

@Retention(RetentionPolicy.RUNTIME) // 定义@NeedTest注解的保留期限，该注解会保存到目标类的字节码中，并且会被类加载器加载到JVM中
@Target(ElementType.METHOD) // 定义@NeedTest注解的应用目标，这是一个方法级别的注解
public @interface NeedTest {
    boolean value() default true; // 单个成员，成员名必须是value(), 默认值是true
}

使用注解

public class MyService {

    public void saySomething(){
        System.out.println("say something");
    }

    @NeedTest(true) // 成员名value()设置为true
    public void sayHello(String name){
        System.out.println("hello "+ name);
    }

    @NeedTest(false) // 成员名value()设置为false
    public void sayHi(String name){
        System.out.println("hi " + name);
    }
}

访问注解

@Test
public void testCustomAnnotation() {
    Class clazz = MyService.class;
    Method[] methods = clazz.getDeclaredMethods();
    if (methods.length == 0){
        System.out.println("method " + clazz.getName() + " has no declared method");
    }else {
        for (Method method : methods){
            NeedTest annotation = method.getAnnotation(NeedTest.class); // 所有自定义的注解都隐式继承自java.lang.annotation.Annotation接口，但是不允许显示继承其他接口
            if (annotation == null){
                System.out.println("method" + method.getName() + " has not annotated @NeedTest");
            }else {
                boolean value = annotation.value();
                System.out.println(method.getName() + " has annotated @NeedTest and value = " + value);
            }
        }
    }
}

1.1.12、HTTP请求的GET与POST方式的区别

GET和POST是HTTP请求的两种基本方法，最直观的区别就是GET把参数包含在URL中，POST通过request body传递参数。get参数有长度限制（受限于url长度，具体的数值取决于浏览器和服务器的限制），而post无限制

GET的语义是请求获取指定的资源。GET方法是安全、幂等、可缓存的（除非有 Cache-ControlHeader的约束）,GET方法的报文主体没有任何语义。

POST的语义是根据请求负荷（报文主体）对指定的资源做出处理，具体的处理方式视资源类型而不同。POST不安全，不幂等，（大部分实现）不可缓存。

1.1.13、Session与Cookie区别

Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息。如何识别特定的客户呢？cookie就可以做到。每次HTTP请求时，客户端都会发送相应的Cookie信息到服务端。它的过期时间可以任意设置，如果你不主动清除它，在很长一段时间里面都可以保留着，即便这之间你把电脑关机了。

Session是在无状态的HTTP协议下，服务端记录用户状态时用于标识具体用户的机制。它是在服务端保存的用来跟踪用户的状态的数据结构，可以保存在文件、数据库或者集群中。在浏览器关闭后这次的Session就消失了，下次打开就不再拥有这个Session。其实并不是Session消失了，而是Session ID变了，服务器端可能还是存着你上次的Session ID及其Session 信息，只是他们是无主状态，也许一段时间后会被删除。

Session与Cookie区别

1. cookie数据存放在客户的浏览器上，session数据放在服务器上。

2. cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗，考虑到安全应当使用session。

3. session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用COOKIE。

4. 单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

所以个人建议：
将登陆信息等重要信息存放为SESSION
其他信息如果需要保留，可以放在COOKIE中

1.1.14、列出自己常用的JDK包

java.lang： 这个是系统的基础类，比如String、Math、Integer、System和Thread， 提供常用功能。
java.io: 这里面是所有输入输出有关的类，比如文件操作等
java.net: 这里面是与网络有关的类，比如URL,URLConnection等。
java.util : 这个是系统辅助类，特别是集合类Collection,List,Map等。
java.sql: 这个是数据库操作的类，Connection, Statememt，ResultSet等

1.1.15、MVC设计思想

MVC模式（Model–view–controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。

• 视图：管理作为位图展示到屏幕上的图形和文字输出；
• 控制器：翻译用户的输入并依照用户的输入操作模型和视图；
• 模型：管理应用的行为和数据，响应数据请求（经常来自视图）和更新状态的指令（经常来自控制器）；

MVC优点

1. 可以为一个模型在运行时同时建立和使用多个视图。变化-传播机制可以确保所有相关的视图及时得到模型数据变化，从而使所有关联的视图和控制器做到行为同步。
2. 视图与控制器的可接插性，允许更换视图和控制器对象，而且可以根据需求动态的打开或关闭、甚至在运行期间进行对象替换。
3. 模型的可移植性。因为模型是独立于视图的，所以可以把一个模型独立地移植到新的平台工作。需要做的只是在新平台上对视图和控制器进行新的修改。
4. 潜在的框架结构。可以基于此模型建立应用程序框架，不仅仅是用在设计界面的设计中。

MVC的不足之处

1. 增加了系统结构和实现的复杂性。对于简单的界面，严格遵循MVC，使模型、视图与控制器分离，会增加结构的复杂性，并可能产生过多的更新操作，降低运行效率。

2. 视图与控制器间的过于紧密的连接。视图与控制器是相互分离，但确实联系紧密的部件，视图没有控制器的存在，其应用是很有限的，反之亦然，这样就妨碍了他们的独立重用。

3. 视图对模型数据的低效率访问。依据模型操作接口的不同，视图可能需要多次调用才能获得足够的显示数据。对未变化数据的不必要的频繁访问，也将损害操作性能。

通俗来讲

优点：

1. 视图控制模型分离， 提高代码重用性。
2. 提高开发效率。
3. 便于后期维护， 降低维护成本。
4. 方便多开发人员间的分工。

缺点：

1. 清晰的构架以代码的复杂性为代价， 对小项目优可能反而降低开发效率。
2. 运行效率相对较低 （通过系统的缓存机制来减小对性能的影响）
3. 有时会导致级联的修改。这种修改尤其体现在自上而下的方向。如果在表示层中需要增加一个功能，为保证其设计符合分层式结构，可能需要在相应的业务逻辑层和数据访问层中都增加相应的代码（可通过设计模式优化）
4. 控制层和表现层有时会过于紧密，导致没有真正分离和重用

1.1.16、equals与==的区别

一、java当中的数据类型和“==”的含义：

• 基本数据类型（也称原始数据类型） ：byte,short,char,int,long,float,double,boolean。他们之间的比较，应用双等号（==）,比较的是他们的值。
• 引用数据类型：当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址（确切的说，是堆内存地址）。

注：对于第二种类型，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。因为每new一次，都会重新开辟堆内存空间。

二、equals()方法介绍：

JAVA当中所有的类都是继承于Object这个超类的，在Object类中定义了一个equals的方法，equals的源码是这样写的：

public boolean equals(Object obj) {
    //this - s1
    //obj - s2
    return (this == obj);
}

可以看到，这个方法的初始默认行为是比较对象的内存地址值，一般来说，意义不大。所以，在一些类库当中这个方法被重写了，如String、Integer、Date。在这些类当中equals有其自身的实现（一般都是用来比较对象的成员变量值是否相同），而不再是比较类在堆内存中的存放地址了。
所以说，对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是内存中的存放位置的地址值，跟双等号（==）的结果相同；如果被复写，按照复写的要求来。

总结：

== 的作用：
　　基本类型：比较的就是值是否相同
　　引用类型：比较的就是地址值是否相同
equals 的作用:
　　引用类型：默认情况下，比较的是地址值。
注：不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同

1.1.17、hashCode和equals方法的区别与联系

hashCode() 的作用

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。
虽然，每个Java类都包含hashCode() 函数。但是，仅仅当创建并某个“类的散列表”(关于“散列表”见下面说明)时，该类的hashCode() 才有用(作用是：确定该类的每一个对象在散列表中的位置；其它情况下(例如，创建类的单个对象，或者创建类的对象数组等等)，类的hashCode() 没有作用。

上面的散列表，指的是：Java集合中本质是散列表的类，如HashMap，Hashtable，HashSet。

也就是说：**hashCode() 在散列表中才有用，在其它情况下没用。**在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

我们都知道，散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！
散列表的本质是通过数组实现的。当我们要获取散列表中的某个“值”时，实际上是要获取数组中的某个位置的元素。而数组的位置，就是通过“键”来获取的；更进一步说，数组的位置，是通过“键”对应的散列码计算得到的。

hashCode() 和 equals() 的关系

以“类的用途”来将“hashCode() 和 equals()的关系”分2种情况来说明。

第一种 不会创建“类对应的散列表”

这里所说的“不会创建类对应的散列表”是说：我们不会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中，用到该类。例如，不会创建该类的HashSet集合。

在这种情况下，该类的“hashCode() 和 equals() ”没有半毛钱关系的！
这种情况下，equals() 用来比较该类的两个对象是否相等。而hashCode() 则根本没有任何作用，所以，不用理会hashCode()。

下面，我们通过示例查看类的两个对象相等 以及 不等时hashCode()的取值。

import java.util.*;
import java.lang.Comparable;

/**
 * @desc 比较equals() 返回true 以及 返回false时， hashCode()的值。
 *
 */
public class NormalHashCodeTest{

    public static void main(String[] args) {
        // 新建2个相同内容的Person对象，
        // 再用equals比较它们是否相等
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        System.out.printf("p1.equals(p3) : %s; p1(%d) p3(%d)\n", p1.equals(p3), p1.hashCode(), p3.hashCode());
    }

    /**
     * @desc Person类。
     */
    private static class Person {
        int age;
        String name;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String toString() {
            return name + " - " +age;
        }

        /** 
         * @desc 覆盖equals方法 
         */  
        public boolean equals(Object obj){  
            if(obj == null){  
                return false;  
            }  
              
            //如果是同一个对象返回true，反之返回false  
            if(this == obj){  
                return true;  
            }  
              
            //判断是否类型相同  
            if(this.getClass() != obj.getClass()){  
                return false;  
            }  
              
            Person person = (Person)obj;  
            return name.equals(person.name) && age==person.age;  
        } 
    }
}

运行结果：

p1.equals(p2) : true; p1(1169863946) p2(1901116749)
p1.equals(p3) : false; p1(1169863946) p3(2131949076)

从结果也可以看出：p1和p2相等的情况下，hashCode()也不一定相等。

第二种 会创建“类对应的散列表”

这里所说的“会创建类对应的散列表”是说：我们会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中，用到该类。例如，会创建该类的HashSet集合。

在这种情况下，该类的“hashCode() 和 equals() ”是有关系的：

1. 如果两个对象相等，那么它们的hashCode()值一定相同。这里的相等是指，通过equals()比较两个对象时返回true。
2. 如果两个对象hashCode()相等，它们并不一定相等。
   因为在散列表中，hashCode()相等，即两个键值对的哈希值相等。然而哈希值相等，并不一定能得出键值对相等。补充说一句：“两个不同的键值对，哈希值相等”，这就是哈希冲突。

​

此外，在这种情况下。若要判断两个对象是否相等，除了要覆盖equals()之外，也要覆盖hashCode()函数。否则，equals()无效。
例如，创建Person类的HashSet集合，必须同时覆盖Person类的equals() 和 hashCode()方法。
如果单单只是覆盖equals()方法。我们会发现，equals()方法没有达到我们想要的效果。

import java.util.*;
import java.lang.Comparable;

/**
 * @desc 比较equals() 返回true 以及 返回false时， hashCode()的值。
 *
 */
public class ConflictHashCodeTest1{

    public static void main(String[] args) {
        // 新建Person对象，
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);

        // 新建HashSet对象 
        HashSet set = new HashSet();
        set.add(p1);
        set.add(p2);
        set.add(p3);

        // 比较p1 和 p2， 并打印它们的hashCode()
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        // 打印set
        System.out.printf("set:%s\n", set);
    }

    /**
     * @desc Person类。
     */
    private static class Person {
        int age;
        String name;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String toString() {
            return "("+name + ", " +age+")";
        }

        /** 
         * @desc 覆盖equals方法 
         */  
        @Override
        public boolean equals(Object obj){  
            if(obj == null){  
                return false;  
            }  
              
            //如果是同一个对象返回true，反之返回false  
            if(this == obj){  
                return true;  
            }  
              
            //判断是否类型相同  
            if(this.getClass() != obj.getClass()){  
                return false;  
            }  
              
            Person person = (Person)obj;  
            return name.equals(person.name) && age==person.age;  
        } 
    }
}

运行结果：

p1.equals(p2) : true; p1(1169863946) p2(1690552137)
set:[(eee, 100), (eee, 100), (aaa, 200)]

结果分析：

​ 我们重写了Person的equals()。但是，很奇怪的发现：HashSet中仍然有重复元素：p1 和 p2。为什么会出现这种情况呢？

​ 这是因为虽然p1 和 p2的内容相等，但是它们的hashCode()不等；所以，HashSet在添加p1和p2的时候，认为它们不相等。

下面，我们同时覆盖equals() 和 hashCode()方法。

import java.util.*;
import java.lang.Comparable;

/**
 * @desc 比较equals() 返回true 以及 返回false时， hashCode()的值。
 *
 */
public class ConflictHashCodeTest2{

    public static void main(String[] args) {
        // 新建Person对象，
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        Person p4 = new Person("EEE", 100);

        // 新建HashSet对象 
        HashSet set = new HashSet();
        set.add(p1);
        set.add(p2);
        set.add(p3);

        // 比较p1 和 p2， 并打印它们的hashCode()
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        // 比较p1 和 p4， 并打印它们的hashCode()
        System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p4), p1.hashCode(), p4.hashCode());
        // 打印set
        System.out.printf("set:%s\n", set);
    }

    /**
     * @desc Person类。
     */
    private static class Person {
        int age;
        String name;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String toString() {
            return name + " - " +age;
        }

        /** 
         * @desc重写hashCode 
         */  
        @Override
        public int hashCode(){  
            int nameHash =  name.toUpperCase().hashCode();
            return nameHash ^ age;
        }

        /** 
         * @desc 覆盖equals方法 
         */  
        @Override
        public boolean equals(Object obj){  
            if(obj == null){  
                return false;  
            }  
              
            //如果是同一个对象返回true，反之返回false  
            if(this == obj){  
                return true;  
            }  
              
            //判断是否类型相同  
            if(this.getClass() != obj.getClass()){  
                return false;  
            }  
              
            Person person = (Person)obj;  
            return name.equals(person.name) && age==person.age;  
        } 
    }
}

运行结果：

p1.equals(p2) : true; p1(68545) p2(68545)
p1.equals(p4) : false; p1(68545) p4(68545)
set:[aaa - 200, eee - 100]

结果分析：

这下，equals()生效了，HashSet中没有重复元素。
比较 p1和 p2 ，我们发现：它们的hashCode()相等，通过equals()比较它们也返回true。所以，p1和 p2 被视为相等。
比较 p1 和 p4 ，我们发现：虽然它们的hashCode()相等；但是，通过equals()比较它们返回false。所以，p1 和 p4 被视为不相等。

1.1.18、什么是Java序列化和反序列化，如何实现Java序列化？或者请解释Serializable 接口的作用

1.1.19、Object类中常见的方法，为什么wait notify会放在Object里边？

wait()暂停的是持有锁的对象，所以想调用wait()必须为：对象.wait();

notify()唤醒的是等待锁的对象，调用:对象.notify();

简单说：因为synchronized中的这把锁可以是任意对象，所以任意对象都可以调用wait()和notify()；所以wait和notify属于Object。

专业说：因为这些方法在操作同步线程时，都必须要标识它们操作线程的锁，只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法是定义在object类中。

1.1.20、Java的平台无关性如何体现出来的

Java在不同的操作系统之间，提供不同的JVM虚拟机，让JVM虚拟机实现编译后的字节码文件到实际操作系统指令集的转换。Java只提供统一的开发接口，实现统一的编码规范

Java正是凭借Java虚拟机来实现其平台无关性的。通过在机器与编译程序之间加入一层抽象（即JVM）来实现脱离平台这一性质。

其中，注意：

Java虚拟机面向编译器给其提供相同的接口（即各平台编译器相同），这就是说，编译器只要面向Java虚拟机生成Java虚拟机可以理解的代码，那么就可以通过不同平台的 不同解释器来生成与平台相对应的机器码来执行Java程序。 虚拟机暴露给编译器的接口是相同的，而虚拟机的解释器针对不同的平台而不同。

1.1.21、JDK和JRE的区别

• JDK是用于开发的而JRE是用于运行Java程序的。
• JDK和JRE都包含了JVM，从而使得我们可以运行Java程序。
• JVM是Java编程语言的核心并且具有平台独立性。

补充：

Java 开发工具包 (JDK)

Java开发工具包是Java环境的核心组件，并提供编译、调试和运行一个Java程序所需的所有工具，可执行文件和二进制文件。JDK是一个平台特定的软件，有针对Windows，Mac和Unix系统的不同的安装包。可以说JDK是JRE的超集，它包含了JRE的Java编译器，调试器和核心类。目前JDK的版本号是1.7，也被称为Java 7。

Java虚拟机(JVM)

JVM是Java编程语言的核心。当我们运行一个程序时，JVM负责将字节码转换为特定机器代码。JVM也是平台特定的，并提供核心的Java方法，例如内存管理、垃圾回收和安全机制等。JVM 是可定制化的，我们可以通过Java 选项(java options)定制它，比如配置JVM 内存的上下界。JVM之所以被称为虚拟的是因为它提供了一个不依赖于底层操作系统和机器硬件的接口。这种独立于硬件和操作系统的特性正是Java程序可以一次编写多处执行的原因。

Java运行时环境(JRE)

JRE是JVM的实施实现，它提供了运行Java程序的平台。JRE包含了JVM、Java二进制文件和其它成功执行程序的类文件。JRE不包含任何像Java编译器、调试器之类的开发工具。如果你只是想要执行Java程序，你只需安装JRE即可，没有安装JDK的必要。

1.1.22、Java 8有哪些新特性

补充