java根据class获取类型在强制转换

转载

代码探险家 2024-12-19 13:15:39

文章标签 Java基础反射基本概念获取Class对象三种方式包信息和方法 idea添加Junit4 文章分类 Java 后端开发

1、什么是反射
2、Class类
3、通过Class类取得类信息
4、通过Class类调用属性或方法
5、动态代理
6、JavaBean的概念
7、内省基本概念
8、 Introspector 相关API
9、单例模式优化

1、什么是反射

反射： Reflection

java根据class获取类型在强制转换_包信息和方法

2、Class类
Class类是一切的反射根源。
Class类表示什么？
很多的人——可以定义一个Person类（有年龄，性别，姓名等）
很多的车——可以定义一个Car类（有发动机，颜色，车轮等）
很多的类——Class类（类名，构造方法，属性，方法）

得到Class类的对象有三种方式：
第一种形式：Object类中的getClass()方法
第二种形式：类.class
第三种形式：通过Class类的forName方法

java根据class获取类型在强制转换_包信息和方法_02

使用Class类进行对象的实例化操作

调用无参构造进行实例化

public T newInstance() throws InstantiationException,IllegalAccessException

java根据class获取类型在强制转换_反射基本概念_03

调用有参构造进行实例化 不是通过具体的名字来创建的

public Constructor<?>[] getConstructors() throws SecurityException

3、通过Class类取得类信息
取得一个类中的全部属性

public Field[] getFields()
public Field[] getDeclaredFields()
public Class<?> getType()
public int getModifiers()
public String getName()

getFileds获得属性只能获得公有的私有的不能获取

java根据class获取类型在强制转换_包信息和方法_04

java根据class获取类型在强制转换_反射基本概念_05

java根据class获取类型在强制转换_Java基础_06

java根据class获取类型在强制转换_idea添加Junit4_07

取得类所在的包

public Package getPackage() //得到一个类所在的包
public String getName() //得到名字

取得一个类中的全部方法
public Method[] getMethods()
public int getModifiers() //Modifier.toString(mod); // 还原修饰符
public Class<?> getReturnType()
public Class<?>[] getParameterTypes()
public Class<?>[] getExceptionTypes()
public static String toString(int mod)

//获取公共的方法，包括继承的公有方法

java根据class获取类型在强制转换_包信息和方法_08

java根据class获取类型在强制转换_反射基本概念_09

4、通过Class类调用属性或方法
调用类中的方法
调用类中的方法，传入实例化对象，以及具体的参数内容
public Object invoke(Object obj,Object… args)
直接调用属性
取得属性
public Object get(Object obj)
//设置属性，等同于使用“=”完成操作
public void set(Object obj,Object value)
//让属性对外部可见
public void setAccessible(boolean flag)

invoke 调用的意思

java根据class获取类型在强制转换_Java基础_10

java根据class获取类型在强制转换_idea添加Junit4_11

getDeclaredMethods()获取私有方法不包括父类方法

java根据class获取类型在强制转换_反射基本概念_12

java根据class获取类型在强制转换_获取Class对象三种方式_13

那么能不能调用呢

java根据class获取类型在强制转换_Java基础_14

不能因为set方法修饰符是private 不能直接调用

java根据class获取类型在强制转换_idea添加Junit4_15

需要加上一句话 setAccessible

java根据class获取类型在强制转换_包信息和方法_16

结果就是set方法被调用打印出set字符串

java根据class获取类型在强制转换_Java基础_17

package com.vince;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import org.junit.Test;

import java.lang.reflect.*;

/**
 * Created by vince on 2017/6/9.
 */
public class ReflectionDemo {


    @Test
    public void test5(){
        Dog dog = new Dog("wangwang",4,"白色");
        Class<Dog> dogClass = Dog.class;
        //获取类的包名
        Package aPackage = dogClass.getPackage();
        //System.out.println(aPackage.getName());
        //获取公共的方法，包括继承的公有方法
        Method[] methods = dogClass.getMethods();
        for (int i = 0; i < methods.length; i++) {
            System.out.println(methods[i]);
            if (methods[i].getName().equals("toString")){
                try {
                    String s = (String)methods[i].invoke(dog);
                    System.out.println(s);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("---------------");
        //访问私有方法,获取到本类中定义的所有方法（不包括父类）
        Method[] declaredMethods = dogClass.getDeclaredMethods();
        for (int i = 0; i < declaredMethods.length; i++) {
            System.out.println(declaredMethods[i]);
            if (declaredMethods[i].getName().equals("set")){
                //设置 私有方法可以被访问（去除访问修饰符的检查）
                declaredMethods[i].setAccessible(true);
                try {
                    declaredMethods[i].invoke(dog);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //获取所有的属性
    @Test
    public void test4(){

        Class<Dog> dogClass = Dog.class;
        //获取非私有属性
        Field[] fields = dogClass.getFields();
        //System.out.println(fields.length);

        //获取所有属性（包括私有属性）
        Field[] declaredFields = dogClass.getDeclaredFields();
        //System.out.println(declaredFields.length);
        for (int i = 0; i < declaredFields.length; i++) {
            int modifiers = declaredFields[i].getModifiers();
            System.out.println(Modifier.toString(modifiers)+ " "+declaredFields[i].getType()+" "+declaredFields[i].getName());
        }
    }

    //获取所有构造方法
    @Test
    public void test3(){
        Class<Dog> dogClass = Dog.class;
        Constructor<?>[] constructors = dogClass.getConstructors();
        for (int i = 0; i < constructors.length; i++) {
            System.out.println(constructors[i].getName());
            System.out.println(constructors[i].getParameterCount());

        }
        try {
            //获取一个指定的构造方法
            Constructor<Dog> constructor = dogClass.getConstructor(String.class, int.class, String.class);
            //调用带参数的构造器来实例化对象
            Dog dog = constructor.newInstance("小白", 5, "白色");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    /**
     * 通过反射来实例化对象
     */
    public void test2(){
        Class<Dog> dogClass = Dog.class;
        try {
            //通过Class对象实例化类对象，调用了默认无参的构造方法
            Dog dog = (Dog) dogClass.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取Class对象的三种形式
     */
    @Test
    public void test1(){
        //通过对象的getClass()方法
        Dog dog = new Dog("wangwang",4,"白色");
        Class aClass = dog.getClass();

        //通过类.class
        Class dogClass = Dog.class;

        //通过Class.forName方法
        try {
            Class aClass1 = Class.forName("com.vince.Dog");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

package com.vince;

/**
 * Created by vince on 2017/6/12.
 */
public class Dog {
    public int type;
    private String name;
    private int age;
    private String color;

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

    protected void get(){
        System.out.println("get");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }

    public Dog() {
    }

    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
}

在idea下加入Junit4的包进行测试

①右击项目 Open Module Settings

java根据class获取类型在强制转换_Java基础_18