Reflection, Java에 대한 기본 소개

오늘은 자바 기초 중 안티리플렉션에 대해 알아봤습니다. 공부 후 개인적으로 이해한 바에 따르면, 리플렉션은 클래스, 속성, 메서드 등을 얻기 위한 도구 집합입니다. (사실 성찰을 배우고 나면 약간 찬물을 마셔서 갈증을 해소하는 듯한 느낌이 듭니다. 그런데 무슨 맛인지 정말 모르겠습니다. 본질을 배우지 못한 것인지도 모르겠습니다. 뭔가 허전하다는 느낌이 듭니다. 이것이 제가 Java를 기반으로 배운 내용입니다. 다시 복습하고 다른 것도 배우고 싶습니다. JVM과 컴퓨터 시스템에 대한 책도 읽어보고 싶습니다. 프로페셔널하고 생각이 좀 부족한 편이에요 )

성찰을 배우기에 앞서 가변 매개변수를 먼저 떠올렸어요.

public static void main(String[] args) {
            test();//调用方法1test("JAVA");//调用方法2test("JAVA","工程师");//调用方法3test(new String[]{"水果","电器"});//调用方法4        }    static void test(String ... array){  //直接打印：System.out.println(array);for(String str:array){  //利用增强for遍历            System.out.println(str);
            }
        }

변수 매개변수를 기억하는 이유는 반사의 적용과 다소 유사하기 때문입니다. 메소드를 가변 매개변수로 정의하면 호출 시 매개변수 전달에 대한 제한이 크게 줄어듭니다. 리플렉션에서는 몇 가지 메소드를 사용하여 클래스의 인스턴스 객체를 가져온 다음 클래스의 메소드, 속성 등을 한눈에 볼 수 있습니다. 이전 연구에서 배운 것처럼 메서드, 속성 등은 정적과 비정적, 비공개와 비공개로 구분됩니다. 따라서 호출할 때 어떤 부분을 얻고 싶은지, 어떤 부분만 원하는지 확인합니다. 얻을 수 있는 방법을 생각해 볼 수 있나요? 이때 반성이 나타났고 이제는 이것이 내가 이해하는 전부입니다. 계속해라.

1. 반사의 개념

JAVA 반사 메커니즘은 실행 중입니다(컴파일할 때는 아님). 모든 클래스에 대해 이 클래스의 모든 속성과 메서드를 알 수 있습니다. 동적으로 얻은 정보와 객체의 메소드를 동적으로 호출하는 기능을 Java 언어의 반사 메커니즘이라고 합니다.

Java 리플렉션 메커니즘은 주로 다음 기능을 제공합니다.

--런타임에 모든 객체가 속한 클래스를 판단합니다.

--런타임에 모든 클래스의 객체를 구성합니다.

--런타임에 모든 클래스를 판단합니다. 클래스가 소유한 변수 및 메소드

-- 런타임 시 모든 객체의 메소드를 호출합니다.

-- 동적 프록시를 생성합니다.

JDK에서 리플렉션과 관련된 클래스는 주로 다음과 같습니다.

//java.lang 패키지

Class 클래스

Class 클래스의 인스턴스는 실행 중인 Java 애플리케이션의 클래스와 인터페이스를 나타냅니다. 열거형은 클래스이고 주석은 인터페이스입니다. 각 배열은 요소 유형과 차원이 동일한 모든 배열에서 공유되는 Class 개체에 매핑되는 클래스에 속합니다. 기본 Java 유형(boolean, byte, char, short, int, long, float 및 double)과 키워드 void도 Class 객체로 표시됩니다.

Class 클래스 JDK의 설명에 대해:

public finalclass Class<T> implements java.io.Serializable,
                              java.lang.reflect.GenericDeclaration,
                              java.lang.reflect.Type,
                              java.lang.reflect.AnnotatedElement {private static final int ANNOTATION= 0x00002000;private static final int ENUM      = 0x00004000;private static final int SYNTHETIC = 0x00001000;private static native void registerNatives();static {
        registerNatives();
    }/* * Constructor. Only the Java Virtual Machine creates Class
     * objects.     */private Class() {}

Class 클래스 JDK의 일부 메서드(개인적으로 읽기가 매우 편하다고 느껴 녹음하고 싶습니다.)

public String toString() {return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))+ getName();
    }//应该是三元表达式

public static Class<?> forName(String className)throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

public static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)throws ClassNotFoundException
    {
        Class<?> caller = null;
        SecurityManager sm = System.getSecurityManager();if (sm != null) {// Reflective call to get caller class is only needed if a security manager// is present.  Avoid the overhead of making this call otherwise.caller = Reflection.getCallerClass();if (loader == null) {
                ClassLoader ccl = ClassLoader.getClassLoader(caller);if (ccl != null) {
                    sm.checkPermission(
                        SecurityConstants.GET_CLASSLOADER_PERMISSION);
                }
            }
        }return forName0(name, initialize, loader, caller);
    }

private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)throws ClassNotFoundException;

public T newInstance()throws InstantiationException, IllegalAccessException
    {if (System.getSecurityManager() != null) {
            checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
        }// NOTE: the following code may not be strictly correct under// the current Java memory model.// Constructor lookupif (cachedConstructor == null) {if (this == Class.class) {throw new IllegalAccessException("Can not call newInstance() on the Class for java.lang.Class");
            }try {
                Class<?>[] empty = {};final Constructor<T> c = getConstructor0(empty, Member.DECLARED);// Disable accessibility checks on the constructor// since we have to do the security check here anyway// (the stack depth is wrong for the Constructor's// security check to work)                java.security.AccessController.doPrivileged(new java.security.PrivilegedAction<Void>() {public Void run() {
                                c.setAccessible(true);return null;
                            }
                        });
                cachedConstructor = c;
            } catch (NoSuchMethodException e) {throw new InstantiationException(getName());
            }
        }
        Constructor<T> tmpConstructor = cachedConstructor;// Security check (same as in java.lang.reflect.Constructor)int modifiers = tmpConstructor.getModifiers();if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();if (newInstanceCallerCache != caller) {
                Reflection.ensureMemberAccess(caller, this, null, modifiers);
                newInstanceCallerCache = caller;
            }
        }// Run constructortry {return tmpConstructor.newInstance((Object[])null);
        } catch (InvocationTargetException e) {
            Unsafe.getUnsafe().throwException(e.getTargetException());// Not reachedreturn null;
        }
    }

public String getName() {
        String name = this.name;if (name == null)this.name = name = getName0();return name;
    }

// cache the name to reduce the number of calls into the VMprivate transient String name;private native String getName0();

이 외에도 더 많아서 지금은 녹음하지 않겠습니다. . . . .

//java.lang.reflect  包下
Constructor 代表构造函数
Method 代表方法
Field 代表字段
Array 与数组相关

2. 클래스 클래스에 대한 설명

常用的得到Class类的方法 // Class c=new Class(); 不可以，因为它被私有化了1) Class c=Student.class;   //用类名.class 就可以得到Class类的实例2) Student stu=new Student();
Class c=stu.getClass();   //用对象名.getClass();3) Class c=Class.forName("com.mysql.jdbc.Driver");

//例一  通过调用无参的构造函数,创建类对象public class Test {public static void main(String[] args) throws InstantiationException, IllegalAccessException {
    Class clazz=Dog.class;
    Dog dog=(Dog)clazz.newInstance();
    dog.shout();
    }
}            
class Dog{void shout(){
    System.out.println("汪汪");
    }
}

예제 1에서는 리플렉션을 사용해서 얻는 이점을 못봤네요, 어~~

//例二 上例的改写Class clazz=Class.forName("com.weiboo.Dog"); //注意,必须是类的全部Dog dog=(Dog)clazz.newInstance();
dog.shout();

//例三  (运行本类,Dog 和 Cat 类,必须有一个无参的构造函数)public class Test {public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    Dog dog=(Dog)createObj(Dog.class);
    dog.shout();
                
    Cat cat=(Cat)createObj(Cat.class);
    cat.speak();
    }                    
static Object createObj(Class clazz) throws InstantiationException, IllegalAccessException{return clazz.newInstance();  //调用的是newInstance() 方法创建的类对象,它调用的是类中无参的构造方法}
    }        
class Dog{void shout(){
    System.out.println("汪汪");
    }
}        
class  Cat{void speak(){
    System.out.println("喵~~~");        
    }
}

Three . Reflection

의 다른 클래스에 대한 설명1) Constructor

는 클래스의 생성자를 나타냅니다. Class 클래스는 다음 네 가지 메서드를 제공합니다.

public Constructor[] getConstructors() //Constructor 클래스의 모든 public을 반환합니다. set, 기본 생성자 하위 스크립트는 0

public Constructor getConstructor(Class... 매개변수 유형) //지정된 공개 생성자를 반환하며 매개변수는 생성자 매개변수 유형입니다. set

public Constructor< ;?> ;[] getDeclaredConstructors() //private

public Constructor getDeclaredConstructor(Class... 매개변수 유형)을 포함하여 클래스의 모든 생성자를 반환합니다. //private

import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;//例子 得到某个类中指定的某个构造函数所对应的 Constructor对象class Test2 {public static void main(String[] args) throws InstantiationException,
            IllegalAccessException, ClassNotFoundException,
            NoSuchMethodException, SecurityException, IllegalArgumentException,
            InvocationTargetException {
        Class<Cat> clazz = Cat.class;

        Constructor<Cat> c = clazz.getConstructor(int.class, String.class);
        Cat cat = (Cat) c.newInstance(20, "加飞猫");
        cat.speak();
    }class Cat {private String name;private int age;public Cat(int age, String name) {this.age = age;this.name = name;
        }public Cat(String content) {
            System.out.println("这是构造函数得到的参数" + content);
        }void speak() {
            System.out.println("喵~~~");
            System.out.println("我的名字是" + this.name + "我的年龄是" + this.age);
        }
    }
}

을 포함하여 지정된 생성자를 반환합니다.

/例子 访问类中的私有构造函数
Class clazz=Cat.class;
Constructor c=clazz.getDeclaredConstructor();
c.setAccessible(true);  //让私有成员可以对外访问Cat cat=(Cat) c.newInstance();  //对于私有的来说,能不能行?cat.speak();

2) 메소드는 클래스 내의 메소드를 나타냅니다.

클래스 클래스는 다음과 같은 4가지 메소드를 제공합니다.

public Method[] getMethods() //모든 공개 메소드의 컬렉션을 가져옵니다.

Inherited

public 메소드 getMethod (String name,Class...parameterTypes) // 지정된 공용 메소드 가져오기 매개변수 1: 메소드 이름 매개변수 2: 매개변수 유형 집합

public Method[] getDeclaredMethods() / /모든 메소드 가져오기(확장 전용 포함) ), 상속된

public Method getDeclaredMethod(String name,Class...parameterTypes) //상속된

//调用类中的私有方法main 函数
Class  clazz=Cat.class;//调用一个不带参数的方法Method m=clazz.getDeclaredMethod("speak");
m.setAccessible(true);
Cat c=new Cat();
m.invoke(c);  //让方法执行                
                    
//调用一个带参数的方法Method m=clazz.getDeclaredMethod("eat", int.class,String.class);
m.setAccessible(true);
Cat c=new Cat();
m.invoke(c, 20,"鱼");    

class  Cat{private String name;private int age;
                        
Cat(){    
}public Cat(int age,String name){this.age=age;this. name=name;
    }                        
public Cat(String content){
    System.out.println("这是构造函数得到的参数"+content);
    }                        private void speak(){
    System.out.println("喵~~~");        
    System.out.println("我的名字是"+this.name+"我的年龄是"+this.age);
    }                        private void eat(int time,String something){
    System.out.println("我在"+time +"分钟内吃了一个"+something);
    }
}

🎜

例子 查看一个类中的所有的方法名public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
    Class  clazz=Cat.class;                        /*Method []  methodList=clazz.getMethods() ; //查看所有的公有方法,包扩继承的
    for(Method m:methodList){
    System.out.println(m.getName());
    }*/Method []  methodList=clazz.getDeclaredMethods(); //查看所有的方法,包扩私有的,但不包扩继承的for(Method m:methodList){
    System.out.println(m.getName());
    }
}

🎜을 제외하고 지정된 메소드 가져오기

3) Field 代表字段

public Field getDeclaredField(String name)  // 获取任意指定名字的成员

public Field[] getDeclaredFields()  // 获取所有的成员变量,除了继承来的

public Field getField(String name)  // 获取任意public成员变量,包含继承来的

public Field[] getFields() // 获取所有的public成员变量

//例子 访问字段public class Test {public static void main(String[] args) throws Exception {
    Class clazz=Cat.class;                         /* Field field= clazz.getField("home");
    Cat c=new Cat();
    Object obj=field.get(c);
    System.out.println(obj); // 家*/ 
    Cat cat=new Cat();
    Field  [] fieldList= clazz.getDeclaredFields();for(Field f:fieldList){  //访问所有字段f.setAccessible(true);
    System.out.println(f.get(cat)); 
                                   }
        }
}                            
class  Cat{private String name="黑猫";private int age=2;public String home="家";
}

四、反射的应用

用一个例子来说明一下，比较两个同类对象中的所有字段,不同的并把它输出来。

import java.lang.reflect.Field;import java.util.HashMap;import java.util.Map;public class Test {public static void main(String[] args) throws Exception {
        Student stu1 = new Student(24, "李磊", "工程大学", "女");
        Student stu2 = new Student(20, "王一", "师大", "男");
        Map<String, String> map = compare(stu1, stu2);for (Map.Entry<String, String> item : map.entrySet()) {
            System.out.println(item.getKey() + ":" + item.getValue());
        }
    }static Map<String, String> compare(Student stu1, Student stu2) {
        Map<String, String> resultMap = new HashMap<String, String>();

        Field[] fieldLis = stu1.getClass().getDeclaredFields(); // 得到stu1所有的字段对象try {for (Field f : fieldLis) {
                f.setAccessible(true); // 别忘了，让私有成员可以对外访问Object v1 = f.get(stu1);
                Object v2 = f.get(stu2);if (!(v1.equals(v2))) {
                    resultMap.put(f.getName(), "stu1的值是" + v1 + "   stu2的值是"
                            + v2);
                }
            }

        } catch (Exception ex) {
            ex.printStackTrace();
        }return resultMap;

    }

}class Student {private String name;private String school;private String sex;public Student(int age, String name, String school, String sex) {this.age = age;this.name = name;this.school = school;this.sex = sex;
    }private int age;public int getAge() {return age;
    }public void setAge(int age) {this.age = age;
    }public String getName() {return name;
    }public void setName(String name) {this.name = name;
    }public String getSchool() {return school;
    }public void setSchool(String school) {this.school = school;
    }public String getSex() {return sex;
    }public void setSex(String sex) {this.sex = sex;
    }
}

위 내용은 Reflection, Java에 대한 기본 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!