百木园-与人分享，
就是让自己快乐。
当前位置：百木园 > 野生技术 > 正文

java面试——反射与泛型

2022-05-20 分类：野生技术 阅读(233) 评论(0)

一、反射

　　《java核心技术》

　　官方套话：能够分析类能力的程序成为反射。

　　又通过网上搜索有这句话：反射指程序可以访问、检测和修改它本身状态或行为的一种能力。

　反射是用来干什么的呢？

　　“明明我自己能直接new一个对象，为什么它要绕一个圈子，先拿到Class对象，再调用Class对象的方法来创建对象呢，这不是多余吗？”

　　说不出来，大体作用就是方便，以前只在JDBC用过，看了这边文章后发现springMVC也用。。。。。。我学个寂寞

　　https://www.cnblogs.com/Java3y/p/12320363.html　

　说说你对 Java 中反射的理解

　　Java中的反射首先是能够获取到Java中要反射类的字节码，获取字节码有三种方法，

  • 　　Class.forName(className)
  • 　　类名.class。
  • 　　obj.getClass()

　　然后将字节码中的方法，变量，构造函数等映射成相应的Method、Filed、Constructor等类，这些类提供了丰富的方法可以被我们所使用。

1、反射机制

　反射是一种功能强大且复杂的机制，反射机制可以用来：

  • 在运行时分析类的能力
  • 在运行时查看对象
  • 实现通用的数组操作代码
  • 利用Method对象，这个对象很像C++中的函数指针

　　　这个method对象找了很多资料，还是没太搞明白

2、Class类

获取Class类对象的三种方法：

  • 　　常用的有getClass()方法将返回一个Class类型的实例，getName()方法将返回类的名字。
  • 　　可以调用静态方法forName()获取类名对应的Class对象。
  • 　　如果T是任意java类型（或者void关键字），T.class将代表匹配的类对象。
1 package Reflect;
2 
3 public class Person {}

　　Student和Teacher都是Person类的子类

package Reflect;

public class test {
    public static void main(String[] args) throws ClassNotFoundException {
        Person student = new Student();
        Person teacher = new Teacher();
        Object obj=new Object();
        System.out.println(student.getClass());
        System.out.println(teacher.getClass());
        System.out.println(obj.getClass());
//        class Reflect.Student
//        class Reflect.Teacher
//        class java.lang.Object
        System.out.println(student.getClass().getName());
        System.out.println(teacher.getClass().getName());
        System.out.println(obj.getClass().getName());
//        Reflect.Student
//        Reflect.Teacher
//        java.lang.Object
        Class c1=Class.forName(\"Reflect.Person\");
        System.out.println(c1);
//        class Reflect.Person
        Class c2= Person.class;
        System.out.println(c2);
//        class Reflect.Person
 　　　　Class c3=int.class;
　　　　System.out.println(c3);
//     int,注意，一个Class对象实际上表示的是一个类型，而这个类型未必一定是一种类，比如这里的int不是类，但int.class是一个Class类型的对象
    }
}

　　获取类对象可以搭配newInstance动态的创建一个类的实例！（调用的是类的默认无参构造器，如果没有会抛出异常）

3、检查类的结构

　　在java.lang.reflect包中有三个类Field，Method，Constructor分别用于描述类的域，方法，构造器。这三个类都有一个getName的方法，用来返回项目的名称。

　　常用的方法有：

　　　　　　　　Field类：getType() ：返回描述域所属类型的Class对象

　　　　　　　　　　　　getModifiers()：返回一个整形数值，用不同的位开关描述public和static这样的修饰符使用情况

　　　　　　　　Method类：getReturnType()：方法的返回类型

　　　　　　　　　　　　　getParameterTypes()：参数的类型

　　　　　　　　Constructors类：getParameterTypes()：参数的类型

　　　　　　　　Class类：getFileds()，getMethods()和getConstructors()返回类提供的public域，方法，构造器，其中包括超类的公有成员

　　　　　　　　　　　　getDeclareFields()，getDeclareMethods()，getDeclareConstructors()将返回类中声明的全部域，方法和构造器，其中包括私有和受保护，但不包括超类成员

package Reflect;

import sun.management.MethodInfo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;

public class ClassConstruct {
    public static void main(String[] args) {
        String name;
        if (args.length > 0){
            name=args[0];
        }else {
            Scanner in = new Scanner(System.in);
            System.out.println(\"输入类名(eg:java.util.Date)\");
            name=in.next();
        }

        try {
            Class c1=Class.forName(name);
            Class superc1=c1.getSuperclass();//获得父类的对象
            String modifiers= Modifier.toString(c1.getModifiers());//返回一个整形数值，用不同的位开关描述public和static这样的修饰符使用状况
            if (modifiers.length()>0){
                System.out.print(modifiers+\" \");
            }
            System.out.print(\"class：\"+name);
            if (superc1 !=null && superc1 !=Object.class ){
                System.out.print(\" extends \"+superc1.getName());
            }
            System.out.print(\"\\n{\\n\");
            printConstructors(c1);//打印出c1的构造器
            System.out.println();
            printMethods(c1);//打印出c1的方法
            System.out.println();
            printFields(c1);//打印出c1的域
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
        System.out.println(\"}\");
        System.exit(0);
    }

    /**
     * 打印出c1类的全部构造器
     * @param c1
     */
    private static void printConstructors(Class c1) {
        Constructor[] constructors=c1.getDeclaredConstructors();//返回类的全部构造器

        for (Constructor c:constructors) {
            String name=c.getName();
            System.out.print(\"   \");
            String modifiers=Modifier.toString(c.getModifiers());
            if (modifiers.length()>0){
                System.out.print(modifiers+\" \");
            }
            System.out.print(name+\" (\");

            //打印参数类型
            Class[] paramTypes=c.getExceptionTypes();
            for (int i=0;i<paramTypes.length;i++){
                if (i>0){
                    System.out.print(paramTypes[i].getName());
                }
            }
            System.out.print(\" );\");
        }
    }

    /**
     * 打印出c1类的全部方法
     * @param c1
     */
    private static void printMethods(Class c1) {
        Method[] methods=c1.getDeclaredMethods();

        for (Method m:methods){
            Class retType=m.getReturnType();//方法的返回类型
            String name=m.getName();//获得方法名

            System.out.print(\"  \");
            //打印public或static，返回类型和方法名
            String modifiers=Modifier.toString(m.getModifiers());
            if (modifiers.length()>0){
                System.out.print(modifiers+\" \");
            }
            System.out.print(retType.getName()+\" \"+name+\" (\");
            //打印参数类型
            Class[] paramType=m.getParameterTypes();
            for (int i = 0; i <paramType.length ; i++) {
                if (i>0){
                    System.out.print(\",\");
                }
                System.out.print(paramType[i].getName());
            }
            System.out.println(\");\");
        }
    }

    /**
     * 打印出c1类的全部域
     * @param c1
     */
    private static void printFields(Class c1) {
        Field[] fields=c1.getDeclaredFields();

        for (Field f:fields) {
            Class type=f.getType();//得到域的类型
            String name=f.getName();
            System.out.print(\" \");
            String modifiers=Modifier.toString(f.getModifiers());
            if (modifiers.length()>0){
                System.out.print(modifiers+\" \");
            }
            System.out.println(type.getName()+ \" \"+name+\" ;\");
        }
    }
}

控制台输入一个类：eg：java.lang.Double，输出：

public final class：java.lang.Double extends java.lang.Number
{
   public java.lang.Double ( );   public java.lang.Double ( );
  public boolean equals (java.lang.Object);
  public static java.lang.String toString (double);
  public java.lang.String toString ();
  public int hashCode ();
  public static int hashCode (double);
  public static double min (double,double);
  public static double max (double,double);
  public static native long doubleToRawLongBits (double);
  public static long doubleToLongBits (double);
  public static native double longBitsToDouble (long);
  public volatile int compareTo (java.lang.Object);
  public int compareTo (java.lang.Double);
  public byte byteValue ();
  public short shortValue ();
  public int intValue ();
  public long longValue ();
  public float floatValue ();
  public double doubleValue ();
  public static java.lang.Double valueOf (java.lang.String);
  public static java.lang.Double valueOf (double);
  public static java.lang.String toHexString (double);
  public static int compare (double,double);
  public static boolean isNaN (double);
  public boolean isNaN ();
  public static boolean isFinite (double);
  public static boolean isInfinite (double);
  public boolean isInfinite ();
  public static double sum (double,double);
  public static double parseDouble (java.lang.String);

 public static final double POSITIVE_INFINITY ;
 public static final double NEGATIVE_INFINITY ;
 public static final double NaN ;
 public static final double MAX_VALUE ;
 public static final double MIN_NORMAL ;
 public static final double MIN_VALUE ;
 public static final int MAX_EXPONENT ;
 public static final int MIN_EXPONENT ;
 public static final int SIZE ;
 public static final int BYTES ;
 public static final java.lang.Class TYPE ;
 private final double value ;
 private static final long serialVersionUID ;
}

Process finished with exit code 0

　在运行时使用反射分析对象

　　查看对象域的关键方法是Field类中的get方法，如果f是Field类型的对象，obj是某个包含f域的类的抽象，f.get(obj)将返回一个对象，其值为obj域的当前值。

public class Person {
    public String name;
    public int val;
    public Person(String name,int val){
        this.name=name;
        this.val=val;
    }
}
public class ReflectTest {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Person person=new Person(\"Curry\",1000);
        Class c1=person.getClass();
        Field f=c1.getDeclaredField(\"val\");//获取它对象的某个域
        Object v=f.get(person);//
        System.out.println(v);
　　　　　 //1000
    }
}

　　这里Person类中如果域的访问权限是private，则将会出错

Exception in thread \"main\" java.lang.IllegalAccessException: Class Reflect.ReflectTest can not access a member of class Reflect.Person with modifiers \"private\"
    at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
    at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296)
    at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288)
    at java.lang.reflect.Field.get(Field.java:390)
    at Reflect.ReflectTest.main(ReflectTest.java:10)

 

　　get()方法只能得到可访问域的值，除非拥有权限，否则java的安全机制只允许查看任意对象有哪些域，而不允许读取他们的值。

　　反射机制的默认行为受限于java的访问控制，然而如果一个java程序没有受到安全管理器的控制，就可以覆盖访问控制。为了达成目的，需要调用Field，Method或Constructors对象的setAccessible()

public class ReflectTest {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Person person=new Person(\"Curry\",1000);
        Class c1=person.getClass();
        Field f=c1.getDeclaredField(\"val\");
        f.setAccessible(true);
        Object v=f.get(person);
        System.out.println(v);
　　　　　//1000
    }
}

　　发现现在可以访问了

　　  f.set(person,1900); 设置新值　　　　　　　　　　　

4、反射机制的动态代理

　　摘自于https://www.cnblogs.com/lzq198754/p/5780331.html

　　

public interface Subject {
    public String say(String name, int age);
}

class RealSubject implements Subject {
    public String say(String name, int age) {
        return name + \"  \" + age;
    }
}
//如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。
class MyInvocationHandler implements InvocationHandler {
    private Object obj = null;
    public Object bind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object temp = method.invoke(this.obj, args);
        return temp;
    }
}
public class ProxyTest {
    public static void main(String[] args) throws Exception {
        MyInvocationHandler demo = new MyInvocationHandler();
        Subject sub = (Subject) demo.bind(new RealSubject());
        String info = sub.say(\"Rollen\", 20);
        System.out.println(info);
　　　　 //Rollen  20

    }
}

 

二、泛型

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　

 

来源：https://www.cnblogs.com/peixinyu/p/16290161.html
本站部分图文来源于网络，如有侵权请联系删除。

未经允许不得转载：百木园 » java面试——反射与泛型
标签：

相关推荐

  • 暂无文章

热门文章