JAVA面试-基础加强与巩固：反射、注解、泛型等

作者-焕然一璐，支持原创，转载请注明出处，谢谢合作。
原文链接：http://www.jianshu.com/p/aaf8594e02eb

企业重视的是学习能力：基础很重要

JDK1.5新特性

1. 泛型
2. foreach
3. 自动拆箱装箱
4. 枚举
5. 静态导入（Static import）
6. 元数据（Metadata）
7. 线程池
8. 注解

JDK1.6新特性

1. Desktop类和SystemTray类
2. 使用JAXB2来实现对象与XML之间的映射
3. StAX
4. 使用Compiler API
5. 轻量级Http Server API
6. 插入式注解处理API(Pluggable Annotation Processing API)
7. 用Console开发控制台程序
8. 对脚本语言的支持
9. Common Annotations

JDK1.7新特性

1 对集合类的语言支持；
2 自动资源管理；
3 改进的通用实例创建类型推断；
4 数字字面量下划线支持；
5 switch中使用string；
6 二进制字面量；
7 简化可变参数方法调用。

JDK1.8新特性

1. 接口的默认方法，也就是接口中可以有实现方法
2. 函数式接口与静态导入
3. Lambda 表达式
4. 访问局部变量

静态导入：JDK1.5新特性

//静态导入某一个方法
import static java.lang.Math.abs;
//静态导入一个类的所有静态方法
import static java.lang.Math.*;

public static void main(String[] args) {
    //方法可以直接使用
    System.out.println(abs(-100));
}


//如果类里面原本就有同名的方法的话，就会覆盖掉静态导入的方法了
public static void abs() {

}

可变参数

没有可变参数之前，实现不定长参数只能通过方法的重载实现，但是这样做工作量很大。

没有可变参数之前，实现可变参数的方法可以通过Obiect[]来实现。

1. 可变参数只能放在参数列表的最后一个

2. 编译器隐含为可变参数创建数组，因此可以通过数组的方式去使用可变参数

    public static int add(int x, int... args) {
        int sum = x;
   
        for (int i = 0; i < args.length; i++) {
            sum += args[i];
        }
   
        return sum;
    }
   

增强for循环

    //数组或者实现了Iterable接口的对象
    for 修饰符 Type arg : 要迭代的对象) {
        
    }

基本数据类型的自动装箱与拆箱

    //自动装箱示例，自动将基本数据类型包装成对象
    Integer i1 = 1000;
    Integer i2 = 1000;

    //自动拆箱示例，自动将对象解包成基本数据类型
    System.out.println(i1 + 10);


    //如果数值在-128到127之前，对象会复用（享元设计模式）
    System.out.println(i1 == i2);

-128到127会缓冲起来，节省内存。这是享元设计模式的应用，内部状态/外部状态（可变）

枚举

为什么要使用枚举？

比如，我们要使用1-7代表星期一到星期天，那么通常我们会想到的做法做，定义一个类，并且提供一些公有的静态常量，例如：

public class WeekDay {
    public static final int SUN = 1;
    public static final int MON = 2;
}

但是当我们使用的时候，有些人可能不想去理会这个细节，比如会直接传入1（可能他自己觉得1是代表星期一的），因此运行的时候就会出现一些意想不到的问题。

为了解决这个问题，java 5重新引入枚举，保证变量的值只能取指定值中的某一个，通过在代码编译的时候就可以知道传的值是否合法。

枚举的模拟：

/**
 * 自己手动实现枚举类
 * 1. 构造方法必须是私有的
 * 2. 提供公有的静态成员变量代表枚举，并且通过匿名内部子类去生成对象
 * 3. 对外提供的方法必须是抽象的
 */
public abstract class WeekDay {

    public static WeekDay MON = new WeekDay(0) {
        @Override
        public WeekDay next() {
            return SUN;
        }

        @Override
        public String toString() {
            return "SUN";
        }

    };

    public static WeekDay SUN = new WeekDay(1) {
        @Override
        public WeekDay next() {
            return MON;
        }

        @Override
        public String toString() {
            return "MON";
        }
    };

    private int num;

    //私有构造方法
    private WeekDay() {

    }

    //在生成匿名内部类的时候，可以传参给父类的构造函数
    private WeekDay(int num) {
        this.num = num;
    }

    //对外提供的抽象方法，由子类去实现
    public abstract WeekDay next();

}

一些关键的点已经在上面的注释中给出，在使用的时候，我们只能通过这样去生成WeekDay对象。（实际上枚举内部也是生成对象嘛）

WeekDay weekDay = WeekDay.MON;
weekDay.next();

枚举的实现

public enum WeekDay {

    //枚举对象必须放在最前面，匿名内部类的创建可以带参数，必须实现父类的抽象方法
    MON(1) {
        public WeekDay next() {
            return SUN;
        }
    },

    SUN(2) {
        public WeekDay next() {
            return MON;
        }
    };

    private int num;

    //枚举的构造函数是默认为private的，可以带参数
    WeekDay(int num) {
        this.num = num;
    }

    public abstract WeekDay next();

}

枚举使用，以及一些枚举特有的方法：

//使用方法，跟一般的对象是一模一样的
WeekDay w = WeekDay.MON;
//直接打印枚举对象实际上是调用了toString
System.out.println(w);
//打印枚举的名字，实际上打印类的简短的名字w.getClass().getSimpleName()
System.out.println(w.name());
//打印枚举对象在枚举中的位置，0开始算
System.out.println(w.ordinal());
//通过字符串去或者获取（构造）枚举对象
System.out.println(WeekDay.valueOf("MON"));

//获取枚举类的所有对象，通过数组的方式去遍历
for (WeekDay value : WeekDay.values()) {
    System.out.println(value);
}

枚举的特殊用法---利用枚举可以简简单单就实现单例模式

反射 -- JDK1.2就有了

了解反射的基础--Class类

用来描述Java类的类就是Class这个类。

每个类在java虚拟机中占用一片内存空间，里面的内容就是对应这个类的字节码（Class）

Class字节码的获取：

类名.class
对象.getClass
Class.forName("类的全名");

其中，跟反射密切相关的就是forName这个方法，通过类名去获取字节码。前面两种都是虚拟机中已经加载过了。forName方法在当虚拟机中没有加载过对应字节码的时候，就会去动态地加载进来；当已经加载过的时候，直接复用加载过的。

九种预定义好的基本Class字节码

八种数据类型，外加void也有对应的字节码。下面给出一些例子：

Class type = Integer.TYPE;
Class integerClass = int.class;
Class voidClass = Void.class;

例子：

public static void main(String[] args) throws Exception {
    
    Class c1 = Class.forName("java.lang.String");
    Class c2 = String.class;
    Class c3 = new String("123").getClass();

    //返回的都是同一份字节码，因此==
    System.out.println(c1 == c2);
    System.out.println(c2 == c3);

    //判断是不是基本类型（九种）
    System.out.println(int.class.isPrimitive());
    System.out.println(int[].class.isPrimitive());
    
    //判断是不是数组（数组也是一种类型，所有类型都可以反射）
    System.out.println(int[].class.isArray());
    
}

反射的概念

一句话总结：反射就是把Java类中的各种成分通过java的反射API映射成相应的Java类，得到这些类以后就可以对其进行使用。比如方法，构造方法，成员变量，类型，包等。下面分别取讲解。

Constructor类

得到所有的构造方法

Constructor[] constructors = Class.forName("java.lang.String").getConstructors();

得到指定参数的某一个构造方法：

Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);

创建对象

String s = (String) constructor.newInstance(new StringBuffer("abc"));
System.out.println(s.charAt(2));

也可以直接调用无参数的构造，实际上也是先找到Constructor再调用Constructor的newInstance
String s = (String) Class.forName("java.lang.String").newInstance();

查看源码可以发现，Class的newInstance方法中有把Constructor缓存起来的。因为反射的使用会大大降低系统的性能，对于计算机来说比较耗时，而且也容易发生运行时异常，因此需要慎重使用。

Field对象

Field代表类中的一个成员变量

例如我们有一个测试的类Point

public class Point {

    public int x;
    private int y;
    protected int z;

    public Point(int x, int y, int z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

那么，我们可以利用发射机制去得到虚拟机中某个对象的成员变量，并且获取他们的值

Point point = new Point(1, 2, 3);

//通过反射拿到成员变量的值
Field x = point.getClass().getField("x");
System.out.println(x.get(point));

//如果是私有或者保护变量的话，不能拿到Field，会报找不到Field的错误
//Field y = point.getClass().getField("y");

//私有变量需要通过使用getDeclaredField去获取，如果要获取值的话，需要设置setAccessible为true
//这样的反射比较暴力
Field y = point.getClass().getDeclaredField("y");
y.setAccessible(true);
System.out.println(y.get(point));

例子，把对象中所有String类型的值中的a修改为*：

public class Reflecttest1 {

    public static void main(String[] args) throws Exception {
        Test test = new Test();
        changeString(test);
        System.out.println(test);
    }

    private static void changeString(Object obj) throws Exception {
        for (Field field : obj.getClass().getFields()) {
            
            //判断是不是String类型，注意这里最好使用==
            if (field.getType() == String.class) {
                String oldV = (String) field.get(obj);
                String newV = oldV.replace('a', '*');
                field.set(obj, newV);
            }
        }
    }
}

Method类

String a = "0123";
//获取方法，并且调用
Method charAt = a.getClass().getMethod("charAt", int.class);
//通过反射调用方法，第一个参数是对象，如果为静态方法的话，应该传null
//第二个参数是可变长参数，传入的是实参
System.out.println(charAt.invoke(a, 1));

调用指定对象的main方法，注意其中传递字符串数组的问题

由于可变长参数的问题，jdk为了兼容1.4以下的版本，会把传进去的数组进行拆包。因此注释代码会报参数不匹配的错。

解决方案是

1、再利用Object数组包装一层，告诉编译器，可以拆包，但是拆开之后就是一个String数组。

2、相强制转换为Object对象，告诉编译器，不要拆包。

public class ReflectTest3 {

    public static void main(String[] args) throws Exception {

        Method mainMethod = Class.forName("com.nan.test.T").getMethod("main", String[].class);
//        mainMethod.invoke(null, new String[]{"123"});
        mainMethod.invoke(null, new Object[]{new String[]{"123"}});
        mainMethod.invoke(null, (Object) new String[]{"123"});

    }

}

class T {
    public static void main(String[] args) {
        for (String s : args) {
            System.out.println(s);
        }
    }
}

数组类型

具有相同的维度以及元素类型的数组，属于同一种Class类型。

例子：

int[] a1 = new int[3];
int[] a2 = new int[4];
int[][] a3 = new int[3][4];
String[] a4 = new String[3];

System.out.println(a1.getClass());
System.out.println(a2.getClass());
System.out.println(a3.getClass());
System.out.println(a4.getClass());

输出结果：

class [I
class [I
class [[I
class [Ljava.lang.String;

其中[代表是数组类型，I代表元素类型（int）

八种基本类型的数组不能转换成Object数组。因此下面的语句不合法：

Object[] objects = a1;

//因为基本类型的一维数组不能当成Object数组，因此只能当做是一整个数组对象
//因此打印出来的结果是数组的对象的值，而不是里面的内容
//那么，按照JDK1.5的可变长参数语法，只能解析成一个数组对象
System.out.println(Arrays.asList(a1));
//String类型可以转换成Object数组打印的是内容
System.out.println(Arrays.asList(a4));

数组

可以通过反射来对数组进行操作，因为是Object数组，因此不能确定整个数组是同一个类型，因此只能确定的是每一项的类型。

private static void printObj(Object o) {
    //判断是不是数组类型
    if (o.getClass().isArray()) {
        //通过反射APIArray去遍历数组
        int length = Array.getLength(o);
        for (int i = 0; i < length; i++) {
            Object item = Array.get(o, i);
            System.out.println(item);
        }
    } else {
        System.out.println(o);
    }
}

equals与hashCode的联系与区别。

1. 一个类的两个实例对象equals的时候，hashCode也必须相等，反之不成立。
2. hashCode只有在hash集合中才有意义，比如hashMap、hashSet等。当对象被存入hash集合或者从hash集合中移除、contains方法调用等的时候，先会通过计算hash值，算出对象应该在的存储区域，然后再通过在这块存储区域，里面通过equals方法去判断对象是否重复。（hash相等，equals可以不相等）

一般来说，两个都需要重写，而且在对象插入了hash集合以后，不要再修改这个对象与hash计算有关的数值了，因为这样会导致hash集合根据变化之后的hash值找不到这个对象了，对象不能被清理，从而造成内存泄漏。

HashSet set = new HashSet<>();
Point p0 = new Point(1,2,3);
Point p1 = new Point(1,2,3);

set.add(p0);
//如果重写了hashCode方法，这个时候不重写equals方法，那么这个对象可以被插入
//如果重写了hashCode以及equals方法，那么这个对象不可以被插入
set.add(p1);

//数值改变了，对象不能被移除（找到），从而造成内存泄漏
p0.x = 10000;
set.remove(p0);

System.out.println(set.size());

而一般的非hash集合，例如ArrayList，只保存数据的引用，数据是可以重复的。

Java反射的作用 -- 实现框架功能

框架与工具的区别：

相同：都是其他人提供的

不同点：

1. 工具类是被用户调用
2. 框架是调用用户提供的类

例如：

1. 框架提供配置文件，用户可以配置，例如类名
2. 读取用户的配置文件
3. 通过反射加载对应的类，并且动态去使用

配置文件的读取

//一定要用完整的路径，不是硬编码，而是运算出来的
InputStream is = new FileInputStream("文件目录");
Properties properties = new Properties();
properties.load(is);

String value = properties.getProperty("key");

一般配置文件的加载基本都是利用类加载器来加载。

//通过类加载器可以把与类放在一起的配置文件读取出来，这里是与类相对路径。如果写上/代表是绝对路径，需要写完整/包名。。。。。
InputStream res = ReflectTest3.class.getResourceAsStream("文件目录");
//InputStream res = ReflectTest3.class.getClassLoader().getResourceAsStream("文件目录");
properties.load(res);

内省，与java Bean

java bean的概念：符合一定get、set规则的java类

java bean的属性名为get、set方法去掉get、set前缀，剩下的-- 如果第二个字母也是小写的话，那么 -- 首字母需要变成小写

例如：

getAge-->age

setCPU-->CPU

内省：操作Java Bean对象的API

Bean b = new Bean(1);

String propertyName = "x";

//普通方法x-->X-->getX-->调用
//下面使用内省的方法去获取get方法，set方法也是同一个道理
PropertyDescriptor pd = new PropertyDescriptor(propertyName, b.getClass());
Method getXMethod = pd.getReadMethod();
System.out.println(getXMethod.invoke(b, null));

比较麻烦的写法，通过BeanInfo去做

BeanInfo beanInfo = Introspector.getBeanInfo(b.getClass());
PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor p : pds) {
    if (p.getName().equals("x")) {
        Method readMethod = p.getReadMethod();
        readMethod.invoke(b, null);
    }
}

注解 Annotation

小知识：

1. 类型名：形容词+名词
2. 方法名：动词+名词

注解的概念

注解实际上是一个类，写注解实际上是创建注解的对象。注解相当于为程序打一种标记。javac编译工具、开发工具以及其他程序可以利用反射来了解你的类以及各种元素上有没有何种标记，就可以去做相应的事。

标记可以加在包、类型（Type，包括类，枚举，接口）、字段、方法、方法的参数以及局部变量上面。

下面是java的一些比较常见的注解：

Deprecated              //标记方法过时
Override                //标记该方法是子类覆盖父类的方法，告诉编译器去检查
SuppressWarnings        //去掉过时的删除线

注解的应用结构图

一共需要三个类：

例子：

这是一个注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by Administrator on 2016/9/16.
 */

@Retention(RetentionPolicy.RUNTIME)//注解保留在哪个声明周期
@Target({ElementType.METHOD, ElementType.TYPE})//作用于什么元素身上
public @interface A {

}

注解作用的类：

@A
public class AnnotationTest {

}

获取注解（通过对AnnotationTest进行反射）：

Class c = AnnotationTest.class;
//判断是否有对应的注解
if (c.isAnnotationPresent(A.class)) {
    //获取注解
    A a = c.getAnnotation(A.class);
}

元注解，用来给注解添加注解的注解

@Target(ElementType.METHOD)         //声明注解可以作用在什么地方，特别注意TYPE是类、枚举、接口身上
@Retention(RetentionPolicy.SOURCE)  //声明注解是在哪个声明周期的，分别是源代码，class文件，运行时

注意，多个属性的话需要用大括号括起来：

@Target({ElementType.METHOD, ElementType.TYPE})

注解的生命周期

1. SOURCE：注解被保留到源文件阶段。当javac把源文件编译成.class文件的时候，就将相应的注解去掉。例如常见的Override、SuppressWarnings都属于SOURCE类型的生命周期，因为一旦代码编译之后该注解就没用了。
2. CLASS：java虚拟机通过类加载器向内存中加载字节码的时候，就将相应的注解去掉，因此无法通过反射获取相应的注解。
3. RUNTIME：注解保留在内存中的字节码上面了，虚拟机在运行字节码的时候，仍然可以使用的注解。例如Deprecated，类被别人使用的时候，加载到内存，扫描，从二进制代码去看是否过时，而不是检查源代码。

为注解增加属性

注解参数的可支持数据类型：

1. 所有基本数据类型（int,float,boolean,byte,double,char,long,short)
2. String类型
3. Class类型
4. enum类型
5. Annotation类型
6. 以上所有类型的数组

例子：

@Retention(RetentionPolicy.RUNTIME)//注解保留在哪个声明周期
@Target({ElementType.METHOD, ElementType.TYPE})//作用于什么元素身上
public @interface A {

    String stringAttr();

    Class value() default Object.class;

    int[] arrAttr();

    Deprecated annoAttr() default @Deprecated;
}

在使用注解的时候注意点：

1. 当只有value需要设置值的时候（即只有value属性或者其他属性已经制定了default的时候），可以直接不写value，直接在括号里面写值，例如：

   @SuppressWarnings("deprecation")

2. 当类型是数组的时候，如果元素只有一个，那么可以省略大括号，直接写一个元素即可。

通过反射获得注解之后，就可以随心去使用了：

Class c = AnnotationTest.class;
if (c.isAnnotationPresent(A.class)) {
    A a = c.getAnnotation(A.class);
    //获得stringAttr属性的值
    System.out.println(a.stringAttr());
}

泛型

概念

集合，反射等等地方都使用到了泛型，免去了强制类型转换的不安全性问题，包括code阶段以及运行阶段。泛型是给编译器看的，让编译器拦截源程序中的非法输入，编译完以后就会去掉类型信息，保证程序的运行效率。对于参数化的泛型类型，getClass方法的返回值和原始类型完全一样。

所以编译完以后，跳过编译器，通过反射就可以向集合添加其他类型的数据，例子如下：

List list = new ArrayList<>();
//通过反射的方式取添加“非法类型”到集合当中
list.getClass().getMethod("add", Object.class).invoke(list, "abc");
System.out.println(list.get(0));

关于泛型的一些术语：

ArrayList                        泛型类型
ArrayList中的E                 类型变量或者类型参数
ArrayList                   参数化的类型
ArrayList中的String           实际类型参数
ArrayList中的<>读作type of

1. 用不用泛型，程序最终的运行结果都一样，用了有好处而已
2. 参数化类型，不考虑类型参数的继承关系

例如，下面的这行代码是错误的，因为不考虑父子关系：

List