从初面到终面JAVA面试系列（六）

目录

一、面试问题

二、参考答案

---

一、面试问题

51.反射机制的优缺点有哪些？

52.如何获取反射中的Class对象？

53.Java反射API有几类？

54.反射使用的步骤？

55.为什么引入反射概念？反射机制的应用有哪些？

56.反射机制的原理是什么？

57.Java中的泛型是什么?

58.使用泛型的好处是什么?

59.类型擦除是什么？

60.什么是泛型中的限定通配符和非限定通配符?

二、参考答案

51.反射机制的优缺点有哪些？

优点：能够运行时动态获取类的实例，提高灵活性；可与动态编译结合Class.forName('com.mysql.jdbc.Driver.class');，加载MySQL的驱动类。

缺点：使用反射性能较低，需要解析字节码，将内存中的对象进行解析。其解决方案是：通过setAccessible(true)关闭JDK的安全检查来提升反射速度；多次创建一个类的实例时，有缓存会快很多；ReflflectASM工具类，通过字节码生成的方式加快反射速度。

52.如何获取反射中的Class对象？

Class.forName(“类的路径”)；当你知道该类的全路径名时，你可以使用该方法获取Class类对象。

Class clz=Class.forName("java.lang.String");

类名.class。这种方法只适合在编译前就知道操作的Class。

Class clz=String.class;

对象名.getClass()。

String str=new String("Hello");

Class clz=str.getClass();

如果是基本类型的包装类，可以调用包装类的Type属性来获得该包装类的Class对象。

53.Java反射API有几类？

反射API用来生成JVM中的类、接口或则对象的信息。

Class类：反射的核心类，可以获取类的属性，方法等信息。

Field类：Java.lang.reflec包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。

Method类：Java.lang.reflec包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。

Constructor类：Java.lang.reflec包中的类，表示类的构造方法。

54.反射使用的步骤？

获取想要操作的类的Class对象，这是反射的核心，通过Class对象我们可以任意调用类的方法。

调用Class类中的方法，既就是反射的使用阶段。

使用反射API来操作这些信息。

具体可以看下面的例子：

public class Apple{

private int price;

public int getPrice(){

return price;

}

public void setPrice(int price){

this.price=price;

}

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

//正常的调用

Apple apple=new Apple();

apple.setPrice(5);

System.out.println("Apple Price:"+apple.getPrice());

//使用反射调用

Class clz=Class.forName("com.chenshuyi.api.Apple");

Method setPriceMethod=clz.getMethod("setPrice",int.class);

Constructor appleConstructor=clz.getConstructor();

Object appleObj=appleConstructor.newInstance();

setPriceMethod.invoke(appleObj,14);

Method getPriceMethod=clz.getMethod("getPrice");

System.out.println("Apple Price:"+getPriceMethod.invoke(appleObj));

}

}

从代码中可以看到我们使用反射调用了setPrice方法，并传递了14的值。之后使用反射调用了getPrice方法，输出其价格。上面的代码整个的输出结果是：

Apple Price:5

Apple Price:14

从这个简单的例子可以看出，一般情况下我们使用反射获取一个对象的步骤：

获取类的Class对象实例

Class clz=Class.forName("com.zhenai.api.Apple");

根据Class对象实例获取Constructor对象

Constructor appleConstructor=clz.getConstructor();

使用Constructor对象的newInstance方法获取反射类对象

Object appleObj=appleConstructor.newInstance();

而如果要调用某一个方法，则需要经过下面的步骤：

获取方法的Method对象

Method setPriceMethod=clz.getMethod("setPrice",int.class);

利用invoke方法调用方法

setPriceMethod.invoke(appleObj,14);

55.为什么引入反射概念？反射机制的应用有哪些？

我们来看一下Oracle官方文档中对反射的描述：

从Oracle官方文档中可以看出，反射主要应用在以下几方面：

反射让开发人员可以通过外部类的全路径名创建对象，并使用这些类，实现一些扩展的功能。

反射让开发人员可以枚举出类的全部成员，包括构造函数、属性、方法。以帮助开发者写出正确的代码。

测试时可以利用反射API访问类的私有成员，以保证测试代码覆盖率。

也就是说，Oracle希望开发者将反射作为一个工具，用来帮助程序员实现本不可能实现的功能。

举两个最常见使用反射的例子，来说明反射机制的强大之处：

第一种：JDBC的数据库的连接

在JDBC的操作中，如果要想进行数据库的连接，则必须按照以上的几步完成

通过Class.forName()加载数据库的驱动程序（通过反射加载，前提是引入相关了Jar包）；

通过DriverManager类进行数据库的连接，连接的时候要输入数据库的连接地址、用户名、密码；

通过Connection接口接收连接。

public class ConnectionJDBC{

/**

*@param args

*/

//驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR包中

public static final String DBDRIVER="com.mysql.jdbc.Driver";

//连接地址是由各个数据库生产商单独提供的，所以需要单独记住

public static final String DBURL="jdbc:mysql://localhost:3306/test";

//连接数据库的用户名

public static final String DBUSER="root";

//连接数据库的密码

public static final String DBPASS="";

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

Connection con=null;//表示数据库的连接对象

Class.forName(DBDRIVER);//1、使用CLASS类加载驱动程序,反射机制的体现

con=DriverManager.getConnection(DBURL,DBUSER,DBPASS);//2、连接数据库

System.out.println(con);

con.close();//3、关闭数据库

}

第二种：Spring框架的使用，最经典的就是xml的配置模式。

Spring通过XML配置模式装载Bean的过程：

将程序内所有XML或Properties配置文件加载入内存中；

Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息；

使用反射机制，根据这个字符串获得某个类的Class实例；

动态配置实例的属性。

Spring这样做的好处是：

不用每一次都要在代码里面去new或者做其他的事情；

以后要改的话直接改配置文件，代码维护起来就很方便了；

有时为了适应某些需求，Java类里面不一定能直接调用另外的方法，可以通过反射机制来实现。

模拟Spring加载XML配置文件：

public class BeanFactory{

private Map<String,Object>beanMap=new HashMap<String,Object>();

/**

*bean工厂的初始化.

*@param xml xml配置文件

*/

public void init(String xml){

try{

//读取指定的配置文件

SAXReader reader=new SAXReader();

ClassLoader classLoader=Thread.currentThread().getContextClassLoader();

//从class目录下获取指定的xml文件

InputStream ins=classLoader.getResourceAsStream(xml);

Document doc=reader.read(ins);

Element root=doc.getRootElement();

Element foo;

//遍历bean

for(Iterator i=root.elementIterator("bean");i.hasNext();){

foo=(Element)i.next();

//获取bean的属性id和class

Attribute id=foo.attribute("id");

Attribute cls=foo.attribute("class");

//利用Java反射机制，通过class的名称获取Class对象

Class bean=Class.forName(cls.getText());

//获取对应class的信息

java.beans.BeanInfo info=java.beans.Introspector.getBeanInfo(bean);

//获取其属性描述

java.beans.PropertyDescriptor pd[]=info.getPropertyDescriptors();

//设置值的方法

Method mSet=null;

//创建一个对象

Object obj=bean.newInstance();

//遍历该bean的property属性

for(Iterator ite=foo.elementIterator("property");ite.hasNext();){

Element foo2=(Element)ite.next();

//获取该property的name属性

Attribute name=foo2.attribute("name");

String value=null;

//获取该property的子元素value的值

for(Iterator ite1=foo2.elementIterator("value");ite1.hasNext();){

Element node=(Element)ite1.next();

value=node.getText();

break;

}

for(int k=0;k<pd.length;k++){

if(pd[k].getName().equalsIgnoreCase(name.getText())){

mSet=pd[k].getWriteMethod();

//利用Java的反射极致调用对象的某个set方法，并将值设置进去

mSet.invoke(obj,value);

}

}

}

//将对象放入beanMap中，其中key为id值，value为对象

beanMap.put(id.getText(),obj);

}

}catch(Exception e){

System.out.println(e.toString());

}

}

//other codes

}

56.反射机制的原理是什么？

Class actionClass=Class.forName(“MyClass”);

Object action=actionClass.newInstance();

Method method=actionClass.getMethod(“myMethod”,null);

method.invoke(action,null);

上面就是最常见的反射使用的例子，前两行实现了类的装载、链接和初始化（newInstance方法实际上也是使用反射调用了方法），后两行实现了从class对象中获取到method对象然后执行反射调用。

反射获取类实例Class.forName()，并没有将实现留给了java,而是交给了jvm去加载！主要是先获取ClassLoader,然后调用native方法，获取信息，加载类则是回调java.lang.ClassLoader。最后，jvm又会回调ClassLoader进类加载！

newInstance()主要做了三件事：

权限检测，如果不通过直接抛出异常；

查找无参构造器，并将其缓存起来；

调用具体方法的无参构造方法，生成实例并返回。

获取Method对象，

上面的Class对象是在加载类时由JVM构造的，JVM为每个类管理一个独一无二的Class对象，这份Class对象里维护着该类的所有Method，Field，Constructor的cache，这份cache也可以被称作根对象。

每次getMethod获取到的Method对象都持有对根对象的引用，因为一些重量级的Method的成员变量（主要是MethodAccessor），我们不希望每次创建Method对象都要重新初始化，于是所有代表同一个方法的Method对象都共享着根对象的MethodAccessor，每一次创建都会调用根对象的copy方法复制一份：

Method copy(){

Method res=new Method(clazz,name,parameterTypes,returnType,

exceptionTypes,modifiers,slot,signature,

annotations,parameterAnnotations,annotationDefault);

res.root=this;

res.methodAccessor=methodAccessor;

return res;

}

调用invoke()方法。调用invoke方法的流程如下：

调用Method.invoke之后，会直接去调MethodAccessor.invoke。MethodAccessor就是上面提到的所有同名method共享的一个实例，由ReflectionFactory创建。

创建机制采用了一种名为inflation的方式（JDK1.4之后）：如果该方法的累计调用次数<=15，会创建出NativeMethodAccessorImpl，它的实现就是直接调用native方法实现反射；如果该方法的累计调用次数>15，会由java代码创建出字节码组装而成的MethodAccessorImpl。（是否采用inflation和15这个数字都可以在jvm参数中调整）以调用MyClass.myMethod(String s)为例，生成出的MethodAccessorImpl字节码翻译成Java代码大致如下：

public class GeneratedMethodAccessor1 extends MethodAccessorImpl{

public Object invoke(Object obj,Object[]args)throws Exception{

try{

MyClass target=(MyClass)obj;

String arg0=(String)args[0];

target.myMethod(arg0);

}catch(Throwable t){

throw new InvocationTargetException(t);

}

}

}

57.Java中的泛型是什么?

泛型是JDK1.5的一个新特性，泛型就是将类型参数化，其在编译时才确定具体的参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

58.使用泛型的好处是什么?

远在JDK 1.4版本的时候，那时候是没有泛型的概念的，如果使用Object来实现通用、不同类型的处理，有这么两个缺点：

每次使用时都需要强制转换成想要的类型

在编译时编译器并不知道类型转换是否正常，运行时才知道，不安全。

如这个例子：

List list=new ArrayList();

list.add("www.cnblogs.com");

list.add(23);

String name=(String)list.get(0);

String number=(String)list.get(1);//ClassCastException

上面的代码在运行时会发生强制类型转换异常。这是因为我们在存入的时候，第二个是一个Integer类型，但是取出来的时候却将其强制转换为String类型了。Sun公司为了使Java语言更加安全，减少运行时异常的发生。于是在JDK 1.5之后推出了泛型的概念。

根据《Java编程思想》中的描述，泛型出现的动机在于：有许多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。

使用泛型的好处有以下几点：

类型安全

泛型的主要目标是提高Java程序的类型安全

编译时期就可以检查出因Java类型不正确导致的ClassCastException异常

符合越早出错代价越小原则

消除强制类型转换

泛型的一个附带好处是，使用时直接得到目标类型，消除许多强制类型转换

所得即所需，这使得代码更加可读，并且减少了出错机会

潜在的性能收益

由于泛型的实现方式，支持泛型（几乎）不需要JVM或类文件更改

所有工作都在编译器中完成

编译器生成的代码跟不使用泛型（和强制类型转换）时所写的代码几乎一致，只是更能确保类型安全而已

59.类型擦除是什么？

泛型是一种语法糖，泛型这种语法糖的基本原理是类型擦除。Java中的泛型基本上都是在编译器这个层次来实现的，也就是说：泛型只存在于编译阶段，而不存在于运行阶段。在编译后的class文件中，是没有泛型这个概念的。

类型擦除：使用泛型的时候加上的类型参数，编译器在编译的时候去掉类型参数。

例如：

public class Caculate<T>{

private T num;

}

我们定义了一个泛型类，定义了一个属性成员，该成员的类型是一个泛型类型，这个T具体是什么类型，我们也不知道，它只是用于限定类型的。反编译一下这个Caculate类：

public class Caculate{

public Caculate(){}

private Object num;

}

发现编译器擦除Caculate类后面的两个尖括号，并且将num的类型定义为Object类型。

那么是不是所有的泛型类型都以Object进行擦除呢？大部分情况下，泛型类型都会以Object进行替换，而有一种情况则不是。那就是使用到了extends和super语法的有界类型，如：

public class Caculate<T extends String>{

private T num;

}

这种情况的泛型类型，num会被替换为String而不再是Object。这是一个类型限定的语法，它限定T是String或者String的子类，也就是你构建Caculate实例的时候只能限定T为String或者String的子类，所以无论你限定T为什么类型，String都是父类，不会出现类型不匹配的问题，于是可以使用String进行类型擦除。

实际上编译器会正常的将使用泛型的地方编译并进行类型擦除，然后返回实例。但是除此之外的是，如果构建泛型实例时使用了泛型语法，那么编译器将标记该实例并关注该实例后续所有方法的调用，每次调用前都进行安全检查，非指定类型的方法都不能调用成功。

实际上编译器不仅关注一个泛型方法的调用，它还会为某些返回值为限定的泛型类型的方法进行强制类型转换，由于类型擦除，返回值为泛型类型的方法都会擦除成Object类型，当这些方法被调用后，编译器会额外插入一行checkcast指令用于强制类型转换。这一个过程就叫做『泛型翻译』。

60.什么是泛型中的限定通配符和非限定通配符?

限定通配符对类型进行了限制。有两种限定通配符，一种是<?extends T>它通过确保类型必须是T的子类来设定类型的上界，另一种是<?super T>它通过确保类型必须是T的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。

非限定通配符？,可以用任意类型来替代。如List<?>的意思是这个集合是一个可以持有任意类型的集合，它可以是List<A>，也可以是List<B>,或者List<C>等等。

 从初面到终面：JAVA面试系列之java基础面试题及答案：

https://download.csdn.net/download/qq_29633789/88405523