javaSE每天练程序——20反射,类的加载,反射获取构造方法,成员变量,成员方法,配置文件,泛型

最新推荐文章于 2024-02-29 20:53:11 发布

@李小白

最新推荐文章于 2024-02-29 20:53:11 发布

阅读量155

点赞数

本文链接：https://blog.csdn.net/lalaMarry/article/details/98247806

版权

学习目的

类加载器
反射
动态代理
JDK1.5以及1.7的新特性

反射(类的加载概述和加载时机)(了解)

类的加载:

当程序要使用某个类时，如果该类还未被加载到内存中，
则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

加载:
创建一个字节码文件对象
连接
验证 : 是否有正确的内部结构，并和其他类协调一致
准备 : 负责为类的静态成员分配内存，并设置默认初始化值
解析：把类中的符号引用转换为直接引用
初始化: 就是我们以前讲过的初始化步骤

类的加载时机

创建类的实例
访问类的静态变量,或者为静态变量赋值
调用类的静态方法
使用反射的方式来强制建某个类或接口对应java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

反射(类加载器的概述和分类)(了解)

Extension ClassLoader 扩展类加载器

将.class文件加载在内在中,并为之生成对Class对象

类加载器的分类

Booststrap ClassLoader 根类加载器
负责java核心类的加载,如System,String等,在JDK中JRE的lib目录下rt.jar文件中
Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载,在JDK中JRE的lib目录下ext目录
System ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件,以及calsspath环境变量所指定的jar包和类路径

反射(反射概述以及获取class文件对象的三种方式)(掌握)

反射概念

获取该类字节码文件对象反向解剖改类的成员变量,成员方法,构造方法

获取class文件对象的三种方式

a:Object类的getClass()方法
b:静态属性class
c:Class类中静态方法forName()
public static Class forName(String className):
className: 这个表示的是一个类对应的全类名(就是需要加上包名)

成员变量 Field
构造方法 Constructor
成员方法 Method

反射(通过反射获取构造方法)(掌握)

用到的方法:

获取所有构造方法
public Constructor<?>[] getConstructors() 获取所有的构造方法不包含私有的
public Constructor<?>[] getConstructors() 获取所有的构造方法包括私有的
获取单个构造方法
public Constructor getConstructor(Class<?>… parameterTypes) 获取单个的构造方法不包含私有的
public Constructor getDeclaredConstructor(Class<?>… parameterTypes) 获取单个的构造方法包含私有的
通过反射获取私有构造方法并使用
// 获取字节码文件对象
Class clazz = Class.forName(“com.click369.Student”) ;
Constructor con = clazz.getDeclaredConstructor(String.class , int.class) ;//获取所有的对象
// 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
con.setAccessible(true) ; 取消语法检查不然会报错因为私有的外界不能直接访问
Object obj = con.newInstance(“张三” , 23) ;
System.out.println(obj);
步骤:
步骤一: Class.forName(“完整路径”) ;
步骤二:getConstructors(类型的.class) /getConstructors(类型的.class) / getConstructor(类型的.class)/ getDeclaredConstructor(类型的.class)
步骤三:私有的话有这一步con.setAccessible(true) 取消权限校验
步骤四:.newInstance(“张三” , 23) ;输出值

案例:
构造方法:

package javaSEreview20190802.反射.构造方法;

/**
 * @Author: ShenMouMou
 * @CreateTime: 2019-08-02 09:19
 * @Description:西部开源教育科技有限公司
 */
public class Student {
    public Student() {
        System.out.println("空参构造执行了");
    }

    public Student(String name) {
        System.out.println("一个参数的构造执行了,名字是"+name);
    }

    public Student(String name,int age) {
        System.out.println("两个个参数的构造执行了"+name+"=="+age);

    }

    private Student(String name,char ch) {
        System.out.println("私有构造执行了,名字和性别是"+name+"=="+ch);
    }
}

package javaSEreview20190802.反射.构造方法;

import java.lang.reflect.Constructor;

/**
 * @Description:TODO
 * @Author:@李小白
 * @Date:2019/8/2 22:52
 */
public class 构造方法 {
    public static void main(String[] args) throws Exception {
        //创建字节码对象+完整路径
        Class<?> aClass = Class.forName("javaSEreview20190802.反射.构造方法.Student");
        System.out.println("-----------------------------------------------");
        //获取所有的公共构造方法
        Constructor<?>[] constructors = aClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("-----------------------------------------------");
        //获取所有私有+公共构造方法
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        System.out.println("-----------------------------------------------");
        //获取单个的公共构造方法
        Constructor<?> constructor = aClass.getConstructor();//构造方法
        Object o = constructor.newInstance();
        System.out.println(o);

        Constructor<?> constructor1 = aClass.getConstructor(String.class);//一个参数类型
        Object name = constructor1.newInstance("李强娜");//传入参数值
        System.out.println(name);

        Constructor<?> constructor2 = aClass.getConstructor(String.class, int.class);//两个参数类型
        Object name2 = constructor2.newInstance("李强娜", 23);
        System.out.println(name2);

//        System.out.println(constructor);
//        System.out.println(constructor1);
//        System.out.println(constructor2);
        System.out.println("-----------------------------------------------");
        //获取单个私有的构造方法
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class,char.class);//输入参数类型
        declaredConstructor.setAccessible(true);//取消权限校验
        Object o1 = declaredConstructor.newInstance("李强娜", '男');
        System.out.println(o1);
        
//        System.out.println(declaredConstructor);
    }
}

反射(通过反射获取成员变量并使用)(掌握)

用到的方法

获取所有成员变量
public Field[] getFields() 获取所有的成员变量包含从父类继承过来的
public Field[] getDeclaredFields() 获取所有的成员变量包含私有的也包含从父类继承过
获取单个成员变量
public Field getField(String name)
public Field getDeclaredField(String name)
案例:
获取成员变量

package javaSEreview20190802.反射.成员变量;

/**
 * @Description:TODO
 * @Author:@李小白
 * @Date:2019/8/2 23:43
 */
public class Student {
    public String name;
    public int age;
    private double money;

    public Student() {
    }
}

package javaSEreview20190802.反射.成员变量;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**
 * @Description:TODO
 * @Author:@李小白
 * @Date:2019/8/2 23:41
 */
public class 成员变量 {
    public static void main(String[] args) throws Exception {
        //先获取构造方法
        Class<?> aClass = Class.forName("javaSEreview20190802.反射.成员变量.Student");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Object obj = declaredConstructor.newInstance();

        System.out.println("-----------------------------------");
        //公有变量名字
        Field field = aClass.getField("name");//变量的名字
        field.set(obj,"李小白");
        Object name = (Object) field.get(obj);
        System.out.println(name);
        System.out.println("-----------------------------------");
        Field age = aClass.getField("age");
        age.setInt(obj,18);
        Object o = age.get(obj);
        System.out.println(o);
        System.out.println("-----------------------------------");
        //私有变量
        Field money = aClass.getField("money");
        money.setAccessible(true);//私有变量去掉权限检验
        money.setDouble(obj,1.34);
        Double name2 = (Double) money.get(obj);
        System.out.println(name2);


    }
}

反射(通过反射获取成员方法并使用)(掌握)

用到的方法

获取所有成员方法
public Method[] getMethods() //获取所有的公共的成员方法不包含私有的包含从父类继承过来的过来的公共方法
public Method[] getDeclaredMethods()//获取自己的所有成员方法包含私有的
获取单个成员方法
//参数1: 方法名称参数2:方法行参的class 对象
public Method getMethod(String name,Class<?>… parameterTypes) //获取单个的方法不包含私有的
public Method getDeclaredMethod(String name,Class<?>… parameterTypes) 获取单个方法包括私有的

案例:
获取成员方法:

package javaSEreview20190802.反射.成员方法;

public class Student {
    private Student() {
    }

    public void show(){
        System.out.println("空参数的show方法执行了");
    }

    public void test(String name,int age) {
        System.out.println("两个参数的 test方法执行了"+name+"==="+age);
    }

    public String hehe(double num) {
        System.out.println("有返回值的方法执行了"+num);
        return "呵呵";
    }

    private String haha(){
        System.out.println("私有的方法执行了");
        return "哈哈";
    }
}

package javaSEreview20190802.反射.成员方法;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * @Description:TODO
 * @Author:@李小白
 * @Date:2019/8/3 0:05
 */
public class 成员方法 {
    public static void main(String[] args) throws Exception {
        //先获取构造方法
        Class<?> aClass = Class.forName("javaSEreview20190802.反射.成员方法.Student");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Object obj = declaredConstructor.newInstance();

        System.out.println("-----------------------------------");
        //获取所有的公共方法
        Method[] methods = aClass.getMethods();
        System.out.println(methods);
        //获取所有的私有方法
        Method[] declaredMethods = aClass.getDeclaredMethods();
        declaredConstructor.setAccessible(true);//取消权限校验
        System.out.println(declaredConstructor);

        System.out.println("-----------------------------------");
        //获取公共的单个方法
        Method method = aClass.getMethod("show");//方法名字
        method.invoke(obj);

        Method method1 = aClass.getMethod("test", String.class, int.class);
        method1.invoke(obj,"李小白",18);

        Method hehe = aClass.getMethod("hehe", double.class);
        Object invoke = hehe.invoke(obj,1.23);
        System.out.println(invoke);

        System.out.println("-----------------------------------");
        //私有的方法
        Method haha = aClass.getDeclaredMethod("haha");
        haha.setAccessible(true);
        Object invoke1 = haha.invoke(obj);
        System.out.println(invoke1);

    }
}

反射(通过反射运行配置文件内容)

peizhi.properties
classname=org.westos.demo.Dog
methodname=sleep


public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void sleep() {
        System.out.println("猫白天睡觉");
    }
}



public class Dog {
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void sleep() {
        System.out.println("狗睡觉");
    }
}


public class MyTest {
    public static void main(String[] args) throws Exception {
        //反射机制：
        //基于狗类做开发
        //Dog dog = new Dog();
        //dog.eat();
        //dog.sleep();

        //Cat cat = new Cat();
        //cat.eat();
        //cat.sleep();
        //采用反射
        //读取配置文件
        Properties properties = new Properties();
        properties.load(new FileReader("peizhi.properties"));

        Class<?> classname = Class.forName(properties.getProperty("classname"));
        Object o = classname.getDeclaredConstructor().newInstance();

        Method eat = classname.getMethod(properties.getProperty("methodname"));
        eat.invoke(o);


    }
}

反射(通过反射越过泛型检查)(了解)

案例演示: 我给你ArrayList的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？

public class MyTest {
    public static void main(String[] args) throws Exception {
       // 我给你ArrayList<Integer> 的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？
        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        //list.add("abc");
        //泛型：泛型只在编译期有效，运行期就擦除了。
        Class<? extends ArrayList> aClass = list.getClass();
        //获取add方法对象
        Method add = aClass.getDeclaredMethod("add", Object.class);
        //让add方法执行
        add.invoke(list,"abc");
        System.out.println(list);
    }
}

@李小白

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
javaSE每天练程序——20反射,类的加载,反射获取构造方法,成员变量,成员方法,配置文件,泛型

学习目的类加载器反射动态代理JDK1.5以及1.7的新特性反射(类的加载概述和加载时机)(了解)类的加载:当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。加载:创建一个字节码文件对象连接验证 : 是否有正确的内部结构，并和其他类协调一致准备 : 负责为类的静态成员分配内存，并设置默认初始化值解析：把类中的...
复制链接

扫一扫