>

J2SE-反射,

- 编辑:正版管家婆马报彩图 -

J2SE-反射,

J2SE-反射,

 

目录

  • 1 什么是反光?首要提供了如何职能?
  • 2 如何通过反射获取类的新闻?
  • 3 数组的独辟蹊径管理。
  • 4 反射的选取场景。
  • 5 其他。

正文

1 什么是反光?首要提供了什么样职能?
  1) Java的反光机制是指在程序运营时期,对于随便二个类,都得以清楚那一个类的属性和格局,并拓宽调用。
  2) 提供以下功效:
    ① 在运作时方可看清任性三个对象所属的类。
    ② 在运营时能够组织大肆二个类的目的。
    ③ 在运维时得以获得任性二个类的保有成员变量和章程。
    ④ 在运维时调用大肆一个目的的艺术。
    ⑤ 生成动态代理。
  3) 优缺点
    ① 优点:扩展灵活性。
    ② 劣点:使用不当会招致功效低、会破坏封装,且能够访谈类的村办方法,不安全。

2 如何通过反射获取类的音信?
  1) 首先获得类的Class对象:
    ① 每叁个类、接口、数组、基本类型都有独一的贰个应和的Class类对象。通过Class类对象可以获得类的一切音讯(富含成员变量、方法、父类、接口等)。
    ② 获得Class对象的两种格局。【参照他事他说加以考察TestLoadClass.java】
    ③ Class的常用方法:【参照他事他说加以考察TestClass.java】 

图片 1

package com.devway.j2se.reflect;

public class TestLoadClass {
    public static void main(String[] args) {
        try {
            // 获取Class对象的三种方法
            // 方法一,通过对象实例获取,
            A a = new A();
            Class<?> class1 = a.getClass();
            System.out.println("1:getClass " + class1);

            // 方法二,根据类名获取
            Class<?> class2 = B.class;
            System.out.println("2:.class " + class2);
            // 方法三,根据类的全名获取
            Class<?> class3 = Class.forName("com.devway.j2se.reflect.C");
            System.out.println("3:Class.forName " + class3);

        } catch (ClassNotFoundException e) {
            System.err.println(e);
        }

    }
}

class A {
    static {
        System.out.println("init A static");
    }
}

class B {
    static {
        System.out.println("init B static");
    }
}

class C {
    static {
        System.out.println("init C static");
    }
}

TestLoadClass.java 图片 2

package com.devway.j2se.reflect;

public class TestClass {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");
            System.out.println("1:" + class1);// true

            // Class类的常用方法
            // 判断是否是接口
            boolean isInterface = class1.isInterface();// false
            // 判断是否是数组
            boolean isArray = class1.isArray();// false
            // 判断是否是8种基本类型
            boolean isPrimitive = class1.isPrimitive();// false;
            System.out.println("2:" + isInterface + "," + isArray + "," + isPrimitive);

            // 获取父类的Class类对象
            Class<?> superClass = class1.getSuperclass();
            // 获取所有接口
            Class<?>[] interfaces = class1.getInterfaces();
            // 获取类型修饰符
            int modifiers = class1.getModifiers();
            System.out.println("3:" + superClass + "," + interfaces + "," + modifiers);

            // 获取数组的组件类型
            int[] ints = { 1, 2, 3 };
            Class<?> class4 = ints.getClass();
            Class<?> class5 = class4.getComponentType();// int
            System.out.println("4:" + class4);
            System.out.println("4:" + class5);

            // 返回声明这个的Class对象,如果不是嵌套类型,返回null
            Class<?> class6 = class1.getDeclaringClass();// null
            System.out.println("5:" + class6);

            // 获取包
            Package package1 = class1.getPackage();
            System.out.println("6:" + package1);

        } catch (ClassNotFoundException e) {
            System.err.println(e);
        }
    }
}

package com.devway.j2se.reflect;

public interface Interface1 {
    String iv1 = "a";
    String iv2 = "b";

    void f1();
}

package com.devway.j2se.reflect;

public class Parent {
    public String pv1;
    protected String pv2;

    public Parent() {

    }

    public String pf1(String s) {
        return s;
    }

    protected void pf2() {

    }

    void pf3() {

    }

    private void pf4() {

    }

}

package com.devway.j2se.reflect;

public class Child extends Parent implements Interface1 {
    public String cv1;
    protected String cv2;
    private String cv3;
    public static String scv1;

    public Child() {

    }

    public Child(String s, int i) {

    }

    protected Child(int i) {

    }

    private Child(String s) {

    }

    public String cf1(String s, int i) throws NullPointerException {
        return s + i;
    }

    protected void cf2() {
        System.out.println("protected method cf4()");
    }

    void cf3() {
        System.out.println("default method cf4()");
    }

    private void cf4() {
        System.out.println("private method cf4()");
    }

    @Override
    public void f1() {
        System.out.println("public method f1()");
    }

}

TestClass.java

  2) 对类的构造函数、方法、属性的拜访和调用:
    ① Constructor类:用于构造函数。【参谋TestConstrcutor.java】
    ② Method类:用于类的办法。【参谋TestMethod.java】
    ③ Field类:用于类的个性。【参谋TestField.java】
    ④ Modifer类:用于决断修饰符类型。【参谋TestModifier.java】
    ⑤ Field、Method、Constructor类都持续了AccessibleObject类(该类用于获取和修该访谈权限)【参谋TestAccessible.java】,同不常间也落到实处了Member接口。

图片 3

package com.devway.j2se.reflect;

import java.lang.reflect.Constructor;

public class TestConstrcutor {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");

            // 获取所有的public构造函数,包括父类和接口的
            Constructor<?>[] publicConstructors = class1.getConstructors();
            for (Constructor<?> constructor : publicConstructors) {
                System.out.println("1:" + constructor);
            }

            // 获取当前类的所有构造函数,不包括父类和接口的
            Constructor<?>[] declaredConstructors = class1.getDeclaredConstructors();
            for (Constructor<?> constructor : declaredConstructors) {
                System.out.println("2:" + constructor);
            }

            // 根据名称和参数获取方法
            Constructor<?> constructor1 = class1.getConstructor(String.class, int.class);
            System.out.println("3:" + constructor1);

            // 获取方法参数对应的Class对象
            Class<?>[] paramTypesClass = constructor1.getParameterTypes();
            for (Class<?> paramType : paramTypesClass) {
                System.out.println("4:" + paramType);
            }

            // 获取方法抛出的异常对应的Class对象
            Class<?>[] exceptionTypesClass = constructor1.getExceptionTypes();
            for (Class<?> exceptionType : exceptionTypesClass) {
                System.out.println("6:" + exceptionType);
            }

            // 创建实例并调用方法
            Interface1 inf = (Interface1) class1.newInstance();
            inf.f1();

        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException e) {
            System.err.println(e);
        }
    }
}

TestConstrcutor.java 图片 4

package com.devway.j2se.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestMethod {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");

            // 获取所有的public方法,包括父类和接口的
            Method[] publicMethods = class1.getMethods();
            for (Method method : publicMethods) {
                System.out.println("1:" + method);
            }

            // 获取当前类的所有方法,不包括父类和接口的
            Method[] declaredMethods = class1.getDeclaredMethods();
            for (Method method : declaredMethods) {
                System.out.println("2:" + method);
            }

            // 根据名称和参数获取方法
            Method method1 = class1.getMethod("cf1", String.class, int.class);
            System.out.println("3:" + method1);

            // 获取方法返回值类型对应的Class对象
            Class<?> returnTypeClass = method1.getReturnType();
            System.out.println("4:" + returnTypeClass);

            // 获取方法参数对应的Class对象
            Class<?>[] paramTypesClass = method1.getParameterTypes();
            for (Class<?> paramType : paramTypesClass) {
                System.out.println("5:" + paramType);
            }

            // 获取方法抛出的异常对应的Class对象
            Class<?>[] exceptionTypesClass = method1.getExceptionTypes();
            for (Class<?> exceptionType : exceptionTypesClass) {
                System.out.println("6:" + exceptionType);
            }

            // 方法调用
            Child child = (Child) class1.newInstance();
            String value = (String) method1.invoke(child, "abc", 123);
            System.out.println("7:" + value);
        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException e) {
            System.err.println(e);
        }
    }
}

TestMethod.java 图片 5

package com.devway.j2se.reflect;

import java.lang.reflect.Field;

public class TestField {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");

            // 获取所有的public域,包括父类和接口的
            Field[] publicFields = class1.getFields();
            for (Field field : publicFields) {
                System.out.println("1:" + field);
            }

            // 获取当前类的所有域,不包括父类和接口的
            Field[] declaredFields = class1.getDeclaredFields();
            for (Field field : declaredFields) {
                System.out.println("2:" + field);
            }

            // 根据名称获取域
            Field field1 = class1.getField("cv1");
            System.out.println("3:" + field1);

            // 获取域类型的Class对象
            Class<?> field1Class = field1.getType();
            System.out.println("4:" + field1Class);

            // 读取域的值
            Child child = (Child) class1.newInstance();
            child.cv1 = "abc";
            String field1Value = (String) field1.get(child);// abc
            System.out.println("5:" + field1Value);

            // 修改域的值
            field1.set(child, "def");
            System.out.println("6:" + child.cv1);

        } catch (ClassNotFoundException | NoSuchFieldException | SecurityException | InstantiationException | IllegalAccessException e) {
            System.err.println(e);
        }
    }
}

TestField.java 图片 6

package com.devway.j2se.reflect;

import java.lang.reflect.Modifier;

public class TestModifier {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");
            boolean isPrivate = Modifier.isPrivate(class1.getModifiers());// false;
            System.out.println("1:" + isPrivate);

            boolean isAbastract = Modifier.isAbstract(class1.getModifiers());// false
            System.out.println("2:" + isAbastract);
        } catch (ClassNotFoundException e) {
            System.err.println(e);
        }
    }
}

TestModifier.java 图片 7

package com.devway.j2se.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestAccessible {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");
            Method method1 = class1.getDeclaredMethod("cf4");

            Interface1 inf = (Interface1) class1.newInstance();
            // ! method1.invoke(inf,null);//cf4是private方法,不能访问
            System.out.println("1:" + method1.isAccessible());//false

            //取消访问限制
            method1.setAccessible(true);
            method1.invoke(inf,null);
            System.out.println("2:" + method1.isAccessible());//true
        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException e) {
            System.err.println(e);
        }

    }
}

TestAccessible.java

 

 3 数组的极其规管理。

  1) 数组是未有主意和属性的目的,所以不可能透过反射常用的的格局来得到或安装成员。
  2) 能够透过反射成立数组,使用二种new Instance的主意来创立。使用Array.set和Array.get来安装或获得数组元素的值。【参谋TestArray.java】  

图片 8

package com.devway.j2se.reflect;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class TestArray {
    public static void main(String[] args) {
        Integer[] arrays1 = { 1, 2, 3, 4 };
        Class<?> class1 = arrays1.getClass();

        // 数组是没有方法和域的对象,所以都返回null
        Method[] delcaredMethods = class1.getDeclaredMethods();
        for (Method method : delcaredMethods) {
            System.out.println("1:" + method);// null
        }

        Field[] delcaredFields = class1.getDeclaredFields();
        for (Field field : delcaredFields) {
            System.out.println("2:" + field);// null
        }

        // 创建数组方式1
        Integer[] arrays2 = (Integer[]) Array.newInstance(Integer.class, 5);

        // 创建数组方式2,返回多为数组
        int[] intval = { 2, 2 };
        Integer[][] arrays3 = (Integer[][]) Array.newInstance(Integer.class, intval);

        // 设置数组元素的值
        for (int i = 0; i < arrays2.length; i++) {
            Array.set(arrays2, i, i + 1);
        }

        // 获取数组元素的值
        for (int i = 0; i < arrays2.length; i++) {
            System.out.println("3:" + Array.get(arrays2, i));
        }

    }
}

TestArray.java

 

4 反射的采纳场景。

  1) 用于基础框架中,如Spring。
  2) JDBC,数据库恐怕采用Oracle,也恐怕使用Mysql,分裂的数据库有两样的驱动,在运转时,再经过Class.forName()运用反射动态加载。
  3) 应用开采中,尽量幸免使用反射。

5 其他。

  1) class.getName方法重返结果
    ① 数组类型以[为前缀,后边跟着成员的连串编码,基础项目则简写如下。
    (B:byte、C:char、D:double、F:float、I:int、J:long、S:short、Z:boolean)
    ② 嵌套类型应用$符号将品种名隔开分离:Outer$Inner
  2) 注意这种写法是荒唐的:Class<Parent> c = Child.class; 因为Child.class不是Parent的子类,精确写法是:Class<? extends Parent> c= Child.class。
  3) 向上转型和向下转型:
    ① 向上转型:子类转为父类,自动转变。
    ② 向下转型:父类转为子类,供给强制转变。

图片 9

目录 1 什么是反射?首要提供了哪些功能? 2 怎么样通过反射获取类的新闻? 3 数组的非正规管理。 4 反射的运用场景。 5 其余。...

 

目录

  • 1 什么是反射?首要提供了哪些功用?
  • 2 怎样通过反射获取类的新闻?
  • 3 数组的新鲜管理。
  • 4 反射的使用场景。
  • 5 其他。

正文

1 什么是反射?首要提供了怎么功用?
  1) Java的反射机制是指在程序运转时期,对于自由一个类,都能够知晓这一个类的天性和艺术,并实行调用。
  2) 提供以下职能:
    ① 在运作时方可决断大肆叁个对象所属的类。
    ② 在运营时得以组织任意二个类的靶子。
    ③ 在运转时方可获得放肆一个类的有所成员变量和措施。
    ④ 在运作时调用放肆贰个对象的诀窍。
    ⑤ 生成动态代理。
  3) 优缺点
    ① 优点:扩大灵活性。
    ② 瑕疵:使用不当会导致成效低、会毁掉封装,且能够访谈类的私人民居房方法,不安全。

2 如何通过反射获取类的消息?
  1) 首先获得类的Class对象:
    ① 每一个类、接口、数组、基本类型都有独一的八个心心相印的Class类对象。通过Class类对象足以博得类的漫天音讯(满含成员变量、方法、父类、接口等)。
    ② 获得Class对象的二种办法。【参照他事他说加以考察TestLoadClass.java】
    ③ Class的常用方法:【参谋TestClass.java】 

图片 10图片 11

package com.devway.j2se.reflect;

public class TestLoadClass {
    public static void main(String[] args) {
        try {
            // 获取Class对象的三种方法
            // 方法一,通过对象实例获取,
            A a = new A();
            Class<?> class1 = a.getClass();
            System.out.println("1:getClass " + class1);

            // 方法二,根据类名获取
            Class<?> class2 = B.class;
            System.out.println("2:.class " + class2);
            // 方法三,根据类的全名获取
            Class<?> class3 = Class.forName("com.devway.j2se.reflect.C");
            System.out.println("3:Class.forName " + class3);

        } catch (ClassNotFoundException e) {
            System.err.println(e);
        }

    }
}

class A {
    static {
        System.out.println("init A static");
    }
}

class B {
    static {
        System.out.println("init B static");
    }
}

class C {
    static {
        System.out.println("init C static");
    }
}

TestLoadClass.java

图片 12图片 13

package com.devway.j2se.reflect;

public class TestClass {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");
            System.out.println("1:" + class1);// true

            // Class类的常用方法
            // 判断是否是接口
            boolean isInterface = class1.isInterface();// false
            // 判断是否是数组
            boolean isArray = class1.isArray();// false
            // 判断是否是8种基本类型
            boolean isPrimitive = class1.isPrimitive();// false;
            System.out.println("2:" + isInterface + "," + isArray + "," + isPrimitive);

            // 获取父类的Class类对象
            Class<?> superClass = class1.getSuperclass();
            // 获取所有接口
            Class<?>[] interfaces = class1.getInterfaces();
            // 获取类型修饰符
            int modifiers = class1.getModifiers();
            System.out.println("3:" + superClass + "," + interfaces + "," + modifiers);

            // 获取数组的组件类型
            int[] ints = { 1, 2, 3 };
            Class<?> class4 = ints.getClass();
            Class<?> class5 = class4.getComponentType();// int
            System.out.println("4:" + class4);
            System.out.println("4:" + class5);

            // 返回声明这个的Class对象,如果不是嵌套类型,返回null
            Class<?> class6 = class1.getDeclaringClass();// null
            System.out.println("5:" + class6);

            // 获取包
            Package package1 = class1.getPackage();
            System.out.println("6:" + package1);

        } catch (ClassNotFoundException e) {
            System.err.println(e);
        }
    }
}

package com.devway.j2se.reflect;

public interface Interface1 {
    String iv1 = "a";
    String iv2 = "b";

    void f1();
}

package com.devway.j2se.reflect;

public class Parent {
    public String pv1;
    protected String pv2;

    public Parent() {

    }

    public String pf1(String s) {
        return s;
    }

    protected void pf2() {

    }

    void pf3() {

    }

    private void pf4() {

    }

}

package com.devway.j2se.reflect;

public class Child extends Parent implements Interface1 {
    public String cv1;
    protected String cv2;
    private String cv3;
    public static String scv1;

    public Child() {

    }

    public Child(String s, int i) {

    }

    protected Child(int i) {

    }

    private Child(String s) {

    }

    public String cf1(String s, int i) throws NullPointerException {
        return s + i;
    }

    protected void cf2() {
        System.out.println("protected method cf4()");
    }

    void cf3() {
        System.out.println("default method cf4()");
    }

    private void cf4() {
        System.out.println("private method cf4()");
    }

    @Override
    public void f1() {
        System.out.println("public method f1()");
    }

}

TestClass.java

  2) 对类的构造函数、方法、属性的拜见和调用:
    ① Constructor类:用于构造函数。【参谋TestConstrcutor.java】
    ② Method类:用于类的法子。【参谋TestMethod.java】
    ③ Field类:用于类的性质。【仿照效法TestField.java】
    ④ Modifer类:用于判定修饰符类型。【参照他事他说加以考察TestModifier.java】
    ⑤ Field、Method、Constructor类都继承了AccessibleObject类(该类用于获取和修该访谈权限)【参照他事他说加以考察TestAccessible.java】,同一时间也达成了Member接口。

图片 14图片 15

package com.devway.j2se.reflect;

import java.lang.reflect.Constructor;

public class TestConstrcutor {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");

            // 获取所有的public构造函数,包括父类和接口的
            Constructor<?>[] publicConstructors = class1.getConstructors();
            for (Constructor<?> constructor : publicConstructors) {
                System.out.println("1:" + constructor);
            }

            // 获取当前类的所有构造函数,不包括父类和接口的
            Constructor<?>[] declaredConstructors = class1.getDeclaredConstructors();
            for (Constructor<?> constructor : declaredConstructors) {
                System.out.println("2:" + constructor);
            }

            // 根据名称和参数获取方法
            Constructor<?> constructor1 = class1.getConstructor(String.class, int.class);
            System.out.println("3:" + constructor1);

            // 获取方法参数对应的Class对象
            Class<?>[] paramTypesClass = constructor1.getParameterTypes();
            for (Class<?> paramType : paramTypesClass) {
                System.out.println("4:" + paramType);
            }

            // 获取方法抛出的异常对应的Class对象
            Class<?>[] exceptionTypesClass = constructor1.getExceptionTypes();
            for (Class<?> exceptionType : exceptionTypesClass) {
                System.out.println("6:" + exceptionType);
            }

            // 创建实例并调用方法
            Interface1 inf = (Interface1) class1.newInstance();
            inf.f1();

        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException e) {
            System.err.println(e);
        }
    }
}

TestConstrcutor.java

图片 16图片 17

package com.devway.j2se.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestMethod {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");

            // 获取所有的public方法,包括父类和接口的
            Method[] publicMethods = class1.getMethods();
            for (Method method : publicMethods) {
                System.out.println("1:" + method);
            }

            // 获取当前类的所有方法,不包括父类和接口的
            Method[] declaredMethods = class1.getDeclaredMethods();
            for (Method method : declaredMethods) {
                System.out.println("2:" + method);
            }

            // 根据名称和参数获取方法
            Method method1 = class1.getMethod("cf1", String.class, int.class);
            System.out.println("3:" + method1);

            // 获取方法返回值类型对应的Class对象
            Class<?> returnTypeClass = method1.getReturnType();
            System.out.println("4:" + returnTypeClass);

            // 获取方法参数对应的Class对象
            Class<?>[] paramTypesClass = method1.getParameterTypes();
            for (Class<?> paramType : paramTypesClass) {
                System.out.println("5:" + paramType);
            }

            // 获取方法抛出的异常对应的Class对象
            Class<?>[] exceptionTypesClass = method1.getExceptionTypes();
            for (Class<?> exceptionType : exceptionTypesClass) {
                System.out.println("6:" + exceptionType);
            }

            // 方法调用
            Child child = (Child) class1.newInstance();
            String value = (String) method1.invoke(child, "abc", 123);
            System.out.println("7:" + value);
        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException e) {
            System.err.println(e);
        }
    }
}

TestMethod.java

图片 18图片 19

package com.devway.j2se.reflect;

import java.lang.reflect.Field;

public class TestField {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");

            // 获取所有的public域,包括父类和接口的
            Field[] publicFields = class1.getFields();
            for (Field field : publicFields) {
                System.out.println("1:" + field);
            }

            // 获取当前类的所有域,不包括父类和接口的
            Field[] declaredFields = class1.getDeclaredFields();
            for (Field field : declaredFields) {
                System.out.println("2:" + field);
            }

            // 根据名称获取域
            Field field1 = class1.getField("cv1");
            System.out.println("3:" + field1);

            // 获取域类型的Class对象
            Class<?> field1Class = field1.getType();
            System.out.println("4:" + field1Class);

            // 读取域的值
            Child child = (Child) class1.newInstance();
            child.cv1 = "abc";
            String field1Value = (String) field1.get(child);// abc
            System.out.println("5:" + field1Value);

            // 修改域的值
            field1.set(child, "def");
            System.out.println("6:" + child.cv1);

        } catch (ClassNotFoundException | NoSuchFieldException | SecurityException | InstantiationException | IllegalAccessException e) {
            System.err.println(e);
        }
    }
}

TestField.java

图片 20图片 21

package com.devway.j2se.reflect;

import java.lang.reflect.Modifier;

public class TestModifier {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");
            boolean isPrivate = Modifier.isPrivate(class1.getModifiers());// false;
            System.out.println("1:" + isPrivate);

            boolean isAbastract = Modifier.isAbstract(class1.getModifiers());// false
            System.out.println("2:" + isAbastract);
        } catch (ClassNotFoundException e) {
            System.err.println(e);
        }
    }
}

TestModifier.java

图片 22图片 23

package com.devway.j2se.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestAccessible {
    public static void main(String[] args) {
        try {
            Class<?> class1 = Class.forName("com.devway.j2se.reflect.Child");
            Method method1 = class1.getDeclaredMethod("cf4");

            Interface1 inf = (Interface1) class1.newInstance();
            // ! method1.invoke(inf,null);//cf4是private方法,不能访问
            System.out.println("1:" + method1.isAccessible());//false

            //取消访问限制
            method1.setAccessible(true);
            method1.invoke(inf,null);
            System.out.println("2:" + method1.isAccessible());//true
        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
                | IllegalArgumentException | InvocationTargetException e) {
            System.err.println(e);
        }

    }
}

TestAccessible.java

 

 3 数组的非正规管理。

  1) 数组是未有议程和特性的靶子,所以无法因此反射常用的的方式来获得或安装成员。
  2) 能够通过反射创设数组,使用二种new Instance的主意来创造。使用Array.set和Array.get来安装或猎取数组成分的值。【参照他事他说加以考察TestArray.java】  

图片 24图片 25

package com.devway.j2se.reflect;

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class TestArray {
    public static void main(String[] args) {
        Integer[] arrays1 = { 1, 2, 3, 4 };
        Class<?> class1 = arrays1.getClass();

        // 数组是没有方法和域的对象,所以都返回null
        Method[] delcaredMethods = class1.getDeclaredMethods();
        for (Method method : delcaredMethods) {
            System.out.println("1:" + method);// null
        }

        Field[] delcaredFields = class1.getDeclaredFields();
        for (Field field : delcaredFields) {
            System.out.println("2:" + field);// null
        }

        // 创建数组方式1
        Integer[] arrays2 = (Integer[]) Array.newInstance(Integer.class, 5);

        // 创建数组方式2,返回多为数组
        int[] intval = { 2, 2 };
        Integer[][] arrays3 = (Integer[][]) Array.newInstance(Integer.class, intval);

        // 设置数组元素的值
        for (int i = 0; i < arrays2.length; i++) {
            Array.set(arrays2, i, i + 1);
        }

        // 获取数组元素的值
        for (int i = 0; i < arrays2.length; i++) {
            System.out.println("3:" + Array.get(arrays2, i));
        }

    }
}

TestArray.java

 

4 反射的应用场景。

  1) 用于基础框架中,如Spring。
  2) JDBC,数据库大概选取Oracle,也可能行使Mysql,分歧的数据库有两样的驱动,在运作时,再经过Class.forName()运用反射动态加载。
  3) 应用开拓中,尽量幸免使用反射。

5 其他。

  1) class.getName方法重临结果
    ① 数组类型以[为前缀,前面跟着成员的种类编码,基础项目则简写如下。
    (B:byte、C:char、D:double、F:float、I:int、J:long、S:short、Z:boolean)
    ② 嵌套类型应用$符号将品种名隔绝:Outer$Inner
  2) 注意这种写法是一无是处的:Class<Parent> c = Child.class; 因为Child.class不是Parent的子类,正确写法是:Class<? extends Parent> c= Child.class。
  3) 向上转型和向下转型:
    ① 向上转型:子类转为父类,自动调换。
    ② 向下转型:父类转为子类,须要强制转变。

图片 26

本文由计算机操作发布,转载请注明来源:J2SE-反射,