面向对象

什么是面向对象

面向对象与面向过程

概述
什么是面向过程： 自顶而下的编程模式
什么是面向对象：将事务高度抽象化的编程模式

举例说明区别
同样一个象棋设计：
面向对象：创建黑白双方的对象负责演算，棋盘的对象负责画布，规则的对象负责判断，
例子可以看出，面向对象更重视不重复造轮子，即创建一次,重复使用。
面向过程：开始—黑走—棋盘—判断—白走—棋盘—判断—循环。只需要关注每一步怎
么实现即可。

优劣对比
面向对象：占用资源相对高,速度相对慢。
面向过程：占用资源相对低,速度相对快。

面向对象的三大基本特征

封装：对象对内部数据提供了不同级别的保护。
继承：它可以使用现有类的所有功能，并在无需重新编写原来的类的
情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”
或“超类”。
继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性
和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供
实现的能力。
多态：一个类实例的相同方法在不同情形有不同表现形式。

面向对象的五大基本原则

单一职责原则（Single-Responsibility Principle）
一个类，最好只做一件事，只有一个引起它的变化。
开放封闭原则（Open-Closed principle）
软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修
改封闭的。
Liskov 替换原则（Liskov-Substitution Principle）
子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只
有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。
依赖倒置原则（Dependecy-Inversion Principle）
依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖
于抽象；抽象不依赖于具体，具体依赖于抽象。
接口隔离原则（Interface-Segregation Principle）
使用多个小的专门的接口，而不要使用一个大的总接口。

封装、继承、多态

什么是多态

同一操作作用于不同的对象，可以有不同的解释，产生不同
的执行结果。 多态是一种运行期的状态。
多态的必要条件：满足三个条件。
即有类继承或者接口实现、子类要重写父类的方法、父类的引用指向子类的对象。

简单来一段代码解释下：

public class Parent{ 
  public void call(){ 
    sout("im Parent"); 
  } 
}
public class Son extends Parent{// 1.有类继承或者接口实现 
  public void call(){// 2.子类要重写父类的方法 
    sout("im Son"); 
  } 
}
public class Daughter extends Parent{// 1.有类继承或者接口实现 
  public void call(){// 2.子类要重写父类的方法 
    sout("im Daughter"); 
  } 
}
public class Test{ 
  public static void main(String[] args){ 
    Parent p = new Son(); //3.父类的引用指向子类的对象 
    Parent p1 = new Daughter(); //3.父类的引用指向子类的对象 
  } 
}

重写动态多态，重载静态多态，重载算不算多态，为什么重载不算多态？
解答：因为在编译期已经确定调用哪个方法，所以重载并不是多态。

方法重写与重载

重载：
简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不
同参数的函数或者方法之间，互相称之为重载函数或者方法。
重写：
重写指的是在 Java 的子类与父类中有两个名称、参数列表都相同的方法的情况。由于
他们具有相同的方法签名，所以子类中的新方法将覆盖父类中原有的方法。

Java的继承与实现

继承：如果多个类的某个部分的功能相同，那么可以抽象出一个类出来，把他们的相同
部分都放到父类里，让他们都继承这个类。
实现：如果多个类处理的目标是一样的，但是处理的方法方式不同，那么就定义一个接
口，也就是一个标准，让他们的实现这个接口，各自实现自己具体的处理方法来处理那个目
标
继承的根本原因是因为要复用，而实现的根本原因是需要定义一个标准。
继承使用 extends 关键字实现，而实现通过 implements 关键字。

Java的继承与组合

Java 代码的复用有继承，组合以及代理三种具体的表现形式。

继承
继承（Inheritance）是一种联结类与类的层次模型。指的是一个类（称为子类、子接
口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，
继承是类与类或者接口与接口之间最常见的关系；继承是一种 is-a 关系。
组合
组合(Composition)体现的是整体与部分、拥有的关系，即 has-a 的关系。

建议在同样可行的情况下，优先使用组合而不是继承。
因为组合更安全，更简单，更灵活，更高效。

构造函数与默认构造函数

构造函数跟一般的实例方法十分相似；但是与其它方法不同，构造器没有返回类型，不
会被继承，且可以有范围修饰符。构造器的函数名称必须和它所属的类的名称相同。 它承
担着初始化对象数据成员的任务。
如果在编写一个可实例化的类时没有专门编写构造函数，多数编程语言会自动生成缺省
构造器（默认构造函数）。默认构造函数一般会把成员变量的值初始化为默认值，如 int ->
0，Integer -> null。

类变量、成员变量和局部变量

成员变量和方法作用域

public : 表明该成员变量或者方法是对所有类或者对象都是可见的,所有类或者对象都
可以直接访问。
private : 表明该成员变量或者方法是私有的,只有当前类对其具有访问权限,除此之外
其他类或者对象都没有访问权限.子类也没有访问权限。
protected : 表明成员变量或者方法对类自身,与同在一个包中的其他类可见,其他包下
的类不可访问,除非是他的子类。
default : 表明该成员变量或者方法只有自己和其位于同一个包的内可见,其他包内的
类不能访问,即便是它的子类。

平台无关性

Java如何实现的平台无关性的

Java 语言规范
通过规定 Java 语言中基本数据类型的取值范围和行为
Class 文件
所有 Java 文件要编译成统一的 Class 文件
Java 虚拟机
通过 Java 虚拟机将 Class 文件转成对应平台的二进制文件等

JVM还支持哪些语言

Kotlin、 Groovy、JRuby、Jython、Scala 、Fantom、Clojure 、Rhino、Ceylon 等

值传递

值传递、引用传递

为什么说Java中只有值传递

引用数据类型参数(如对象)也按值传递给方法。这意味着，当方法返回时，
传入的引用仍然引用与以前相同的对象。但是，如果对象字段具有适当的访问级别，则可以
在方法中更改这些字段的值。

Java基础知识

基本数据类型

8种基本数据类型

字符型
char
布尔型
boolean
数值型
1.整型：byte、short、int、long
2.浮点型：float、double
String 不是基本数据类型，是引用类型。

整型中byte、short、int、long的取值范围

溢出的时候并不会抛异常，也没有任何提示。所以，在程序中，使
用同类型的数据进行运算的时候，一定要注意数据溢出的问题。

什么是浮点型

什么是单精度和双精度？

单精度浮点数在计算机存储器中占用 4 个字节（32 bits）
双精度浮点数(double)使用 64 位（8 字节） 来存储一个浮点数。

为什么不能用浮点型表示金额？

计算机中保存的小数其实是十进制的小数的近似值，并不是准确值

BigDecimal 或者 Long（单位为分）来表示金额。

自动拆装箱

自动拆装箱

Java 基本类型共有八种，基本类型可以分为三类：
字符类型 char
布尔类型 boolean
数值类型 byte、short、int、long、float、double。
数值类型又可以分为整数类型 byte、short、int、long 和浮点数类型 float、double。

Integ的缓存机制

如何正确定义接口的返回值(boolean/Boolean)类型及命名(success/Success)

在定义 POJO 中的布尔类型的变量时，不要使用 isSuccess 这种形式，而要
直接使用 success！

Boolean：Java 开发手册建议使用封装类来定义 POJO 和 RPC 返回值中的变量。但是这不意味着
可以随意的使用 null，我们还是要尽量避免出现对 null 的处理的。

String

字符串的不可变性

一旦一个 string 对象在内存(堆)中被创建出来，他就无法被修改。特别要注意的是，
String 类的所有方法都没有改变字符串本身的值，都是返回了一个新的对象。

如果你需要一个可修改的字符串，应该使用 StringBuffer 或者 StringBuilder。否则
会有大量时间浪费在垃圾回收上，因为每次试图修改都有新的 string 对象被创建出来。

String的长度限制

根据 Integer 类的定义，java.lang.Integer#MAX_VALUE 的最大值是 2^31 - 1;

JDK6和JDK7中的substing的原理及区别

JDK6内存泄露

replaceFirt、replaceAll、replace区别

replaceAll() 替换符合正则的所有文字
replaceFirst() 替换第一个符合正则的数据

String、StringBuilder和StringBuffer之间的区别与联系

String对“+”的重载

字符串拼接的几种方式与区别

1、如果不是在循环体中进行字符串拼接的话，直接使用+就好了。
2、如果在并发场景中进行字符串拼接的话，要使用 StringB uffer 来代替
StringBuilder。

String.valueOf和Integer.toString的区别

没有任何区别，因为 String.valueOf(i)也是调用 Integer.toString(i)
来实现的。

switch对String的支持

对int直接支持，其他事ascii码比较，String是通过 equals()和 hashCode()方法来实现的。

常量池

运行时常量池

运行时常量池（ Runtime Constant Pool）是每一个类或接口的常量池（ Constant_Pool）的运行时表示形式。
运行时常量池中主要保存的是字面量和符号引用
Java 虚拟机规范约定：每一个运行时常量池都在 Java 虚拟机的方法区中分配，
在加载类和接口到虚拟机后，就创建对应的运行时常量池。

Class常量池

Class 常量池可以理解为是 Class 文件中的资源仓库。
常量池中主要存放两大类常量：字面量（literal）和符号引用（symbolic references）。
字面量（literal）是用于表达源代码中一个固定值的表示法（notation）。

字符串池

在 JVM 中，为了减少相同的字符串的重复创建，为了达到节省内存的目的。会单独开
辟一块内存，用于保存字符串常量，这个内存区域被叫做字符串常量池。
当代码中出现双引号形式（字面量）创建字符串对象时，JVM 会先对这个字符串进行
检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回；否则，
创建新的字符串对象，然后将这个引用放入字符串常量池，并返回该引用。
这种机制，就是字符串驻留或池化。

intern

在 JVM 中，为了减少相同的字符串的重复创建，为了达到节省内存的目的。会单独开
辟一块内存，用于保存字符串常量，这个内存区域被叫做字符串常量池。
在每次赋值的时候使用 String 的 intern 方法，如果常量池中有相同值，就会重复使
用该对象，返回对象引用。

Java中各种关键字

transient

当对象存储 时，它的值不需要维持。

instanceof

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类
的实例，返回 boolean 的数据类型。

volatile

volatile 通常被比喻成”轻量级的 synchronized”，也是 Java 并发编程中比较重要的
一个关键字。和 synchronized 不同，volatile 是一个变量修饰符，只能用来修饰变量。无
法修饰方法及代码块等。

synchronized 可以保证原子性、有序性和可见性。而 volatile 却只能保证有序性和可见性。

缓存一致性协议硬核讲解

synchronized

主要有两种用法，分别是同步
方法和同步代码块。也就是说，synchronized 既可以修饰方法也可以修饰代码块。

final

所表示的是“这部分是无法修改的”。

static

表示“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态 static
代码块。

const

预留关键字，java中预留关键字还有goto

集合类

Collection和Collections的区别

Collection 是一个集合接口。
Collections 是一个包装类。

常用集合类的使用

Set和List的区别

有序无序，是否可重复

ArrayList和LinkedList和Vector的区别

ArrayList 是一个可改变大小的数组.
LinkedList 是一个双链表
Vector 和 ArrayList 类似,但属于强同步类。Vector 每次请求其大
小的双倍空间，而 ArrayList 每次对 size 增长 50%。

SynchronizedList和Vector的区别

Set如何保证元素不重复

HashMap、HashTable、ConcurrentHashMap区别

线程安全：HashTable 中的方法是同步的，而 HashMap 中的方法在默认情况下是
非同步的。

Java8中Map相关的红黑树的引用背景、原理等

Java8中stream相关用法

Stream 的创建

//将一个集合类转换成流。
List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis", "H ello", "HelloWorld", "Hollis"); 
Stream<String> stream = strings.stream();
//直接通过 of 方法，创建并返回一个 Stream。
Stream<String> stream = Stream.of("Hollis", "HollisChuang", "hollis", "Hell o", "HelloWorld", "Hollis");

filter
filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤掉空字
符串：

List<String> strings = Arrays.asList("Hollis", "", "HollisChuang", "H", "ho 
llis"); 
strings.stream().filter(string -> !string.isEmpty()).forEach(System.out::p 
rintln); 
//Hollis, , HollisChuang, H, hollis

map
map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应
的平方数：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
numbers.stream().map( i -> i*i).forEach(System.out::println); 
//9,4,4,9,49,9,25

limit/skip
limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素。以下代码片段使
用 limit 方法保理 4 个元素：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
numbers.stream().limit(4).forEach(System.out::println); 
//3,2,2,3

sorted
sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法进行排序：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
numbers.stream().sorted().forEach(System.out::println); 
//2,2,3,3,3,5,7

distinct
distinct 主要用来去重，以下代码片段使用 distinct 对元素进行去重：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
numbers.stream().distinct().forEach(System.out::println); 
//3,2,7,5

forEach
Stream 提供了方法 ‘forEach’ 来迭代流中的每个数据。以下代码片段使用 forEach
输出了 10 个随机数：

Random random = new Random(); 
random.ints().limit(10).forEach(System.out::println);

count
count 用来统计流中的元素个数。

List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis","Ho 
llis666", "Hello", "HelloWorld", "Hollis"); 
System.out.println(strings.stream().count()); 
//7

collect
collect 就是一个归约操作，可以接受各种做法作为参数，将流中的元素累积成一个汇
总结果：

List<String> strings = Arrays.asList("Hollis", "HollisChuang", "hollis","Ho 
llis666", "Hello", "HelloWorld", "Hollis"); 
strings = strings.stream().filter(string -> string.startsWith("Hollis")).c 
ollect(Collectors.toList()); 
System.out.println(strings); 
//Hollis, HollisChuang, Hollis666, Hollis

Apache集合处理工具类的使用

• Bag - Bag 界面简化了每个对象具有多个副本的集合。
• BidiMap - BidiMap 接口提供双向映射，可用于使用值使用键或键查找值。
• MapIterator - MapIterator 接口提供简单而容易的迭代迭代。
• Transforming Decorators - 转换装饰器可以在将集合添加到集合时更改集合的每 个对象。
• Composite Collections - 在需要统一处理多个集合的情况下使用复合集合。
• Ordered Map - 有序地图保留添加元素的顺序。
• Ordered Set - 有序集保留了添加元素的顺序。
• Reference map - 参考图允许在密切控制下对键/值进行垃圾收集。
• Comparator implementations - 可以使用许多 Comparator 实现。
• Iterator implementations - 许多 Iterator 实现都可用。
• Adapter Classes - 适配器类可用于将数组和枚举转换为集合。
• Utilities - 实用程序可用于测试测试或创建集合的典型集合论属性，例如 union，intersection。 支持关闭。

Commons Collections - 教程

不同版本的JDK中HashMap的实现的区别以及原因

Arrays.asList获得的List使用时需要注意什么

Collection和Iterator区别

如何在遍历的同时删除ArrayList中的元素

普通 for 循环
使用 Iterator
filter 过滤
增强 for 循环其实也可以

fail-fast和fail-safe

CopyOnWriteArrayList

从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容
Copy 出去形成一个新的内容然后再改，这是一种延时懒惰策略。

ConcurrentSkipListMap

ConcurrentSkipListMap 是一个内部使用跳表，并且支持排序和并发的一个 Map，
是线程安全的。一般很少会被用到，也是一个比较偏门的数据结构。

跳表是一种允许在一个有顺序的序列中进行快速查询的数据结构。
在普通的顺序链表中查询一个元素，需要从链表头部开始一个一个节点进行遍历，然后找到节点。
跳表可以解决这种查询时间过长，其元素遍历的图示，跳表是一种使用”空间换时间”的概念用
来提高查询效率的链表。

枚举

枚举的用法

枚举的实现

枚举与单例

Enum类

Java枚举如何比较

switch对枚举的支持

枚举的序列化如何实现

枚举的线程安全性问题

IO

字符流、字节流

Bit 最小的二进制单位 ，是计算机的操作部分。取值 0 或者 1
Byte（字节）是计算机操作数据的最小单位由 8 位 bit 组成 取值（-128-127）
Char（字符）是用户的可读写的最小单位，在 Java 里面由 16 位 bit 组成 取值（0-
65535）
字节流
操作 byte 类型数据，主要操作类是 OutputStream、InputStream 的子类；不用缓
冲区，直接对文件本身操作。
字符流
操作字符类型数据，主要操作类是 Reader、Writer 的子类；使用缓冲区缓冲字符，
不关闭流就不会输出任何内容。
OutputStreamWriter：是 Writer 的子类，将输出的字符流变为字节流，即将一个字
符流的输出对象变为字节流输出对象。
InputStreamReader：是 Reader 的子类，将输入的字节流变为字符流，即将一个字
节流的输入对象变为字符流的输入对象。

输入流、输出流

字节流和字符流之间的相互转换

想要实现字符流和字节流之间的相互转换需要用到两个类：

OutputStreamWriter 是字符流通向字节流的桥梁
InputStreamReader 是字节流通向字符流的桥梁

同步、异步

同步与异步描述的是被调用者的。

阻塞、非阻塞

阻塞与非阻塞描述的是调用者的。

Linux5种IO模型

阻塞式 IO 模型
非阻塞 IO 模型
IO 复用模型
信号驱动 IO 模型
异步 IO 模型

BIO、NIO和AIO的区别

BIO
Java BIO 即 Block I/O ，同步并阻塞的 IO。
BIO 就是传统的 java.io 包下面的代码实现。
NIO
什么是NIO? NIO 与原来的 I/O 有同样的作用和目的, 他们之间最重要的区别是数据
打包和传输的方式。原来的 I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。
AIO
Java AIO 即 Async 非阻塞，是异步非阻塞的 IO。

三种IO的用法与原理

netty

Netty 是一个非阻塞 I/O 客户端-服务器框架，主要用于开发 Java 网络应用程序，如
协议服务器和客户端。

反射

什么是反射

反射机制指的是程序在运行时能够获取自身的信息。在 java 中，只要给定类的名字，
那么就可以通过反射机制来获得类的所有属性和方法。

反射有什么作用

在运行时判断任意一个对象所属的类。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时任意调用一个对象的方法。
在运行时构造任意一个类的对象。

Class类

java.lang.reflect.*

动态代理

静态代理

静态代理，就是代理类是由程序员自己编写的，在编译期就确定好了的。

动态代理

动态代理和反射的关系

反射是动态代理的一种实现方式。

动态代理的几种实现方式

1、JDK 动态代理：
java.lang.reflect 包中的 Proxy 类和 InvocationHandler 接口提
供了生成动态代理类的能力。
2、Cglib 动态代理：Cglib (Code Generation Library )是一个第三方代码生成类
库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

Java 实现动态代理的大致步骤
1、定义一个委托类和公共接口。
2、自己定义一个类（调用处理器类，即实现 InvocationHandler 接口），这个类的
目的是指定运行时将生成的代理类需要完成的具体任务（包括 Preproces s 和
Postprocess），即代理类调用任何方法都会经过这个调用处理器类（在本文最后一节对
此进行解释）。
3、生成代理对象（当然也会生成代理类），需要为他指定(1)委托对象(2)实现的一系
列接口(3)调用处理器类的实例。因此可以看出一个代理对象对应一个委托对象，对应一个
调用处理器实例。
Java 实现动态代理主要涉及哪几个类
java.lang.reflect.Proxy: 这是生成代理类的主类，通过 Proxy 类生成的代理类都继
承了 Proxy 类，即 DynamicProxyClass extends Proxy。
java.lang.reflect.InvocationHandler: 这里称他为”调用处理器”，他是一个接口，我
们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现
InvocationHandler 接口。

AOP

Spring AOP 中的动态代理主要有两种方式，JDK 动态代理和 CGLIB 动态代理。
JDK 动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。
JDK 动态代理的核心是 InvocationHandler 接口和 Proxy 类。
如果目标类没有实现接口，那么 Spring AOP 会选择使用 CGLIB 来动态代理目标类。
CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态
的生成某个类的子类，注意，CGLIB 是通过继承的方式做的动态代理，因此如果某个类被
标记为 final，那么它是无法使用 CGLIB 做动态代理的。

序列化

什么是序列化与反序列化

序列化是将对象转换为可传输格式的过程。 是一种数据的持久化手段。一般广泛应用
于网络传输，RMI 和 RPC 等场景中。
反序列化是序列化的逆操作。
序列化是将对象的状态信息转换为可存储或传输的形式的过程。一般是以字节码或
XML 格式传输。而字节码或 XML 编码格式可以还原为完全相等的对象。这个相反的过程
称为反序列化。

Java如何实现序列号与反序列化

Serializable和Externalize有何不同

可序列化类的所有⼦类型本⾝都是可序列化的。

为什么需要序列化

serialVersionUID

为什么serialVersionUID不能随便改

它是怎么保证只有实现了该接口的方法才能进行序列化与反序列化的呢？
原因是在执行序列化的过程中，会执行到以下代码：

if (obj instanceof String) { 
    writeString((String) obj, unshared); 
} else if (cl.isArray()) {
    writeArray(obj, desc, unshared); 
} else if (obj instanceof Enum) { 
    writeEnum((Enum<?>) obj, desc, unshared); 
} else if (obj instanceof Serializable) { 
    writeOrdinaryObject(obj, desc, unshared); 
} else { 
    if (extendedDebugInfo) { 
        throw new NotSerializableException( cl.getName() + "\n" + debugInfoStack.toString()); 
    } else { 
        throw new NotSerializableException(cl.getName()); 
    } 
}

transient

序列化底层原理

通过 ObjectOutputStream 和 ObjectInputStream 对对象进行序列化及反序列
化。
writeObject 和 readObject 方法
ArrayList 的序列化方式

序列化如何破坏单例模式

答：序列化会通过反射调用无参数的构造方法创建一个新的对象。
解决方案：只要在 Singleton 类中定义 readResolve 就可以解决该问题：

private Object readResolve() { 
    return singleton; 
}

在 Singleton 中定义 readResolve 方法，并在该方法中指定要返回的对象的生成策略，就可以防止单例被破坏。

protobuf

Protocol Buffer (简称 Protobuf) 是 Google 出品的性能优异、跨语言、跨平台的序
列化库。

为什么说序列化并不安全

注解

元注解

@Target（表示该注解可以用于什么地方）、
@Retention（表示在什么级别保存该注解信息）、
@Documented（将此注解包含再 javadoc 中）、
@Inherited（允许子类继承父类中的注解）。

自定义注解

除了元注解，都是自定义注解。通过元注解定义出来的注解。

Java中常用的注解使用

@Override 表示当前方法覆盖了父类的方法。
@Deprecation 表示方法已经过时,方法上有横线，使用时会有警告。
@SuppressWarnings 表示关闭一些警告信息(通知 java 编译器忽略特定的编译警
告)。
SafeVarargs (jdk1.7 更新) 表示：专门为抑制“堆污染”警告提供的。
@FunctionalInterface (jdk1.8 更新) 表示：用来指定某个接口必须是函数式接口，
否则就会编译出错。

注解与反射的结合

如何自定义一个注解

在 Java 中，类使用 class 定义，接口使用 interface 定义，注解和接口的定义差不多，
增加了一个@符号，即@interface，

Spring常用注解

@Configuration 把一个类作为一个 IoC 容器，它的某个方法头上如果注册了
@Bean，就会作为这个 Spring 容器中的 Bean。
@Scope 注解 作用域。
@Lazy(true) 表示延迟初始化。
@Service 用于标注业务层组件。
@Controller 用于标注控制层组件@Repository 用于标注数据访问组件，即 DAO 组
件。
@Component 泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@Scope 用于指定 scope 作用域的（用在类上）。
@PostConstruct 用于指定初始化方法（用在方法上）。
@PreDestory 用于指定销毁方法（用在方法上）。
@DependsOn：定义 Bean 初始化及销毁时的顺序。
@Primary：自动装配时当出现多个 Bean 候选者时，被注解为@Primary 的 Bean
将作为首选者，否则将抛出异常。
@Autowired 默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier
注解一起使用。如下： @Autowired @Qualifier(“personDaoBean”) 存在多个实例配
合使用。
@Resource 默认按名称装配，当找不到与名称匹配的 bean 才会按类型装配。
@PostConstruct 初始化注解。
@PreDestroy 摧毁注解 默认 单例 启动就加载。

泛型

什么是泛型

Java 泛型（ generics） 是 JDK 5 中引⼊的⼀个新特性， 允许在定义类和接⼜的
时候使⽤类型参数（ type parameter） 。

类型擦除

泛型带来的问题

泛型中KTVE? object等的含义

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的 java 类型（无限制通配符类型）
S、U、V - 2nd、3rd、4th types
Object - 是所有类的根类，任何类的对象都可以设置给该 Object 引用变量，使用的
时候可能需要类型强制转换，但是用使用了泛型 T、E 等这些标识符后，在实际用之前类型
就已经确定了，不需要再进行类型强制转换。

泛型各种用法

限定通配符和非限定通配符

限定通配符对类型进⾏限制， 泛型中有两种限定通配符：
表示类型的上界，格式为：<？ extends T>，即类型必须为 T 类型或者 T 子类 表示
类型的下界，格式为：<？ super T>，即类型必须为 T 类型或者 T 的父类
泛型类型必须⽤限定内的类型来进⾏初始化，否则会导致编译错误。
⾮限定通配符表⽰可以⽤任意泛型类型来替代，类型为

上下界限定符extends和super

（Bounds）”的概念。
<? extends T>：是指 “上界通配符（Upper Bounds Wildcards）”，即泛型中
的类必须为当前类的子类或当前类。
<? super T>：是指 “下界通配符（Lower Bounds Wildcards）”，即泛型中的
类必须为当前类或者其父类。

List