1. 什么是反射？
 
反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。
 
2. 哪里用到反射机制？
 
JDBC中，利用反射动态加载了数据库驱动程序。
Web服务器中利用反射调用了Sevlet的服务方法。
Eclispe等开发工具利用反射动态刨析对象的类型与结构，动态提示对象的属性和方法。
很多框架都用到反射机制，注入属性，调用方法，如Spring。
 
3. 什么叫对象序列化，什么是反序列化，实现对象序列化需要做哪些工作？
 
对象序列化，将对象中的数据编码为字节序列的过程。
反序列化；将对象的编码字节重新反向解码为对象的过程。
JAVA提供了API实现了对象的序列化和反序列化的功能，使用这些API时需要遵守如下约定： 
  
被序列化的对象类型需要实现序列化接口，此接口是标志接口，没有声明任何的抽象方法，JAVA编译器识别这个接口，自动的为这个类添加序列化和反序列化方法。
为了保持序列化过程的稳定，建议在类中添加序列化版本号。
不想让字段放在硬盘上就加transient
 
以下情况需要使用 Java 序列化： 
  
想把的内存中的对象状态保存到一个文件中或者数据库中时候；
想用套接字在网络上传送对象的时候；
想通过RMI（远程方法调用）传输对象的时候。
 
 
4. 反射机制的优缺点？
 
优点：可以动态执行，在运行期间根据业务功能动态执行方法、访问属性，最大限度发挥了java的灵活性。
缺点：对性能有影响，这类操作总是慢于直接执行java代码。
 
5. 动态代理是什么？有哪些应用？
 
动态代理是运行时动态生成代理类。
动态代理的应用有 Spring AOP数据查询、测试框架的后端 mock、rpc，Java注解对象获取等。
 
6. 怎么实现动态代理？
 
JDK 原生动态代理和 cglib 动态代理。
JDK 原生动态代理是基于接口实现的，而 cglib 是基于继承当前类的子类实现的。
 
7. Java反射机制的作用
 
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法
 
8. 如何使用Java的反射?
 
通过一个全限类名创建一个对象 
  
Class.forName(“全限类名”); 例如：com.mysql.jdbc.Driver Driver类已经被加载到 jvm中，并且完成了类的初始化工作就行了
类名.class; 获取Class<？> clz 对象
对象.getClass();
 
获取构造器对象，通过构造器new出一个对象 
  
Clazz.getConstructor([String.class]);
Con.newInstance([参数]);
 
通过class对象创建一个实例对象（就相当与new类名（）无参构造器) 
  
Cls.newInstance();
 
通过class对象获得一个属性对象 
  
Field c=cls.getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。
Field c=cls.getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的声明字段
 
通过class对象获得一个方法对象 
  
Cls.getMethod(“方法名”,class……parameaType);（只能获取公共的）
Cls.getDeclareMethod(“方法名”);（获取任意修饰的方法，不能执行私有）
M.setAccessible(true);（让私有的方法可以执行）
 
让方法执行
 1）. Method.invoke(obj实例对象,obj可变参数);-----（是有返回值的）

什么是反射机制，反射机制是Java语言中一个非常重要的特性。它允许程序在运行时进行自我检查。他同时也允许对其内部的成员进行操作，虽然这个特性在实际开发时使用的不多。但是像C/C++等语言根本没有提供这样的特效，由于反射机制能够实现在运行时对力进行装载，因此能够增加程序的灵活性。但是不恰当的使用反射机制也会严重影响系统的性能。
 具体而言，反射机制提供的功能主要有得到一个对象所属的类，获取一个力的所有成员变量的方法。在运行时创建对象在运行时调用对象的方法。
 class Base{
 public void f(){
 System. out. println(“Base”);
 }
 }
 class Sub extennds Base {
 public void f(){
 System out println(“Sub”);
 }
 }
 public class Test {
 public static void main( String [ ] args){
 try{ //使用反射机制加载类
 Class e= Class forName(“Sub”)
 Base b=(Base)c. newInstance():
 b.f();
 } catch(Exception e){
 e. printstackTrace();
 }
 }
 }
 
程序运行结果为：
 Sub

反射机制是Java语言中一个非常重要的特性，它允许程序在运行时自我检查，同时也允许对其内部的成员进行操作。由于反射机制能够实现在运行时对类进行装载，因此能够增加程序的灵活性，但是不恰当地使用反射机制，也会严重影响系统的性能。
 
具体而言，反射机制提供的功能主要有：
 
得到一个对象所属的类；
获取一个类的所有成员变量和方法；
在运行时创建对象；
在运行时调用对象的方法；
 
其实，反射机制非常重要的一个作用就是可以在运行时动态地创建类的对象，示例如下：
 
class Base{
    public void f(){
        System.out.println("Base");
    }
}
class Sub extends Base{
    public void f(){
        System.out.println("Sub");
    }
}
public class Test{
    public static void main(String[] args){
        try{//使用反射机制加载类
            Class c = Class.forName("Sub");
            Base b = (Base)c.newInstance();
            b.f();
            }catch(Exception e){
                e.printStackTrace();
            }
    }
}

/* 程序运行结果为：Sub */
 
在反射机制中，Class是一个非常重要的类，那么如何才能获取Class类呢？总共有如下3种方法可以获取到Class类：
 
Class.forName (“类的路径”)，如上例所示。
类名.Class。
实例.getClass()。
 
Java中创建对象的方式有以下4种：
 
通过new语句实例化一个对象；
通过反射机制创建对象。
通过clone()方法创建一个对象；
通过反序列化的方式创建对象。

Java反射机制的大厂面试题
 
反射机制概念
 
Java 反射机制在程序运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。这种 动态的获取信息 以及 动态调用对象的方法 的功能称为 java 的反射机制。
 
为什么引入反射概念
 
 
 
相信你看上面的概念，心中没有泛起任何的波澜，动态的获取信息、动态调用对象方法黑人问号。下面一段简单代码作为i出发点，从java虚拟机角度阐述
 
 
写下如下代码
 
public class Main{
    public static int number = 1;
    public static void main(String args[]) {
    	System.out.println("hello World");
    }
}
 
调用javac Main.java命令将Main.java文件编译成Main.class文件
之后执行java Main命令后，java虚拟机启动，进行类加载过程，方法区中存储类的静态存储结构，同时在内存中生成一个代表该类的java.lang.Class对象，作为方法区中该类的各种数据的访问入口
 
上述过程表明，编译阶段，就已经明确java虚拟机要加载的类(Main类)，如果你的程序运行中，突然需要加载远程服务器的类(运行中加载)，这时候反射机制就粉墨登场
 
有一个很经典的场景就是加载数据库驱动类，只有运行的时候通过参数，才能确定是加载com.java.dbtest.myqlConnection(mysql驱动类），还是加载com.java.dbtest.oracleConnection
 
此时只需要简单调用Class.forName(com.java.dbtest.myqlConnection)即可动态得完成加载类的过程。
 
利用反射机制对类进行两次加载
 
import java.io.IOException;
import java.io.InputStream;
public class Main{
    public static void main(String args[]) throws Exception{
        //自定义类加载器
        ClassLoader myLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException{
                try{
                    String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                    InputStream is = getClass().getResourceAsStream(fileName);
                    if(is == null) {
                        return super.loadClass(name);
                    }
                    byte[] b = new byte[is.available()];
                    is.read(b);
                    return defineClass(name, b, 0,  b.length);
                }catch(IOException e) {
                    throw new ClassNotFoundException(name);
                }
            }
        };
        //使用反射机制加载并实例化
        Object obj = myLoader.loadClass("Main").newInstance();

        System.out.print(obj instanceof Main);

    }
}

//结果为false
 
由于开始阶段通过双亲委派模型，由系统应用程序类加载器已经加载过该类，运行阶段，使用自定义的类加载器，基于反射机制，又加载一遍类，分别由两个不同的类加载器，加载一遍，所以程序最后的结果是false.