反射

Class类的使用:

  在面向对象的世界里,万事万物皆对象

  java语言中,静态成员,普通数据类型不是对象

  类也是对象,是java.lang.Class类的实例对象

    基本的数据类型  void关键字  都存在类类型

  获取类类型的三种方式:

    01.类名.class

    02.对象名.getClass();

    03.Class.forName("完整的限定名");    =》常用

  

package com.ltc;
/**
 * Class类的使用
 */
public class ClassDemo1 {

  class Foo{
    void print(){
        System.out.println("foo");
    }
public static void main(String[] args) { //Foo的实例对象如何表示 Foo foo1 = new Foo(); //Foo这个类 也是一个实例对象,Class类的实例对象,如何表示出来 //任何一个类都是Class的实例对象,这个实例对象有三种表达方式 //第一种表示方式==》实际再告诉我们任何一个类都有一个隐含的静态成员变量class Class c1 = Foo.class; //第二种表达方式 已经知道该类的对象通过getClass方法 Class c2 = foo1.getClass(); /** * 官网c1和c2表示了Foo类的类类型(class type) * 万事万物皆对象 * 类也是对象,是Class类的实例对象 * 这个对象我们称之为该类的类类型 */ //不管c1 or c2都代表了Foo类的类类型,一个类只可能是Class类的一个实例对象 System.out.println(c1==c2); //第三种表达方式 Class c3 = null; try { c3 = Class.forName("com.ltc.Foo"); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(c2==c3); //我们完全可以通过类的类类型创建该类的对象示例==》通过c1 or c2 or c3创建Foo的实例对象 Foo foo; try { foo = (Foo)c1.newInstance(); foo.print(); } catch (InstantiationException | IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } }

 

Java动态加载类

  Class.forName("类的全称");

  不仅表示了类类型,还代表了动态加载类

  区分编译、运行

  编译时刻加载类是静态加载类,运行时刻加载类是动态加载类

  new 创建对象 是静态加载类,在编译时刻就需要加载所有的可能使用到的类

  通过动态加载类可以解决该问题,有效防止一个类对象加载错误导致整个程序不能运行

  功能性的类最好是进行动态加载类

反射:

  在运行期间,对于任意一个类,我们都能知道这类中所有的属性和方法(包括私有的)!

  这种动态获取类的信息和动态调用对象的方法或者属性 的功能====》java反射机制

  但是破坏了封装的安全性!

创建一个对象Student

package com.ltc;

import java.util.Date;

public class Student {

    public int age; // 年龄
    protected String name; // 姓名
    private char sex = '男'; // 性别
    Date birthday = new Date();// 出生日期

    static {
        System.out.println("这是Student类中的静态代码块!");
    }

    {
        System.out.println("这是Student类中的普通代码块!");
    }

    public Student() {
        System.out.println("这是Student类中的无参构造!");
    }

    // 私有的方法
    private double getSum(double num) {
        return num + 10;
    }

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

01.利用反射获取该类的包名、限定名和修饰符

@org.junit.Test
    public void test01(){
        
        try {
       //动态加载类 Class c
= Class.forName("com.ltc.Student"); System.out.println("所在的包名:"+c.getPackage().getName()); System.out.println("完整限定名:"+c.getName()); System.out.println("简写的类名:"+c.getSimpleName());
       //获取修饰符会返回一个int类型的数字,Modifier.toString(int num);方法把数字解析成对应的修饰符
int num = c.getModifiers(); String result = Modifier.toString(num); System.out.println("获取该类的修饰符:"+result); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }

02.获取类的属性

/**
     * getFileds():只能获取public修饰的属性
     * getDeclaredFields():所有属性字段的集合
     */
    @org.junit.Test
    public void test02(){
        try {
            Class c = Class.forName("com.ltc.Student");
            Field[] fields = c.getFields();
            for (int i = 0; i < fields.length; i++) {
                System.out.println(fields[i].getName());
                System.out.println("对应的修饰符是==》"+Modifier.toString(fields[i].getModifiers()));
            }
            System.out.println("**********************************************************");
            Field[] fields2 = c.getDeclaredFields();
            for (int i = 0; i < fields2.length; i++) {
                System.out.println(fields2[i].getName());
                System.out.println("对应的修饰符是==》"+Modifier.toString(fields2[i].getModifiers()));
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

03.获取类的方法

/**
     *  c.getMethods()  :获取所有public修饰的方法
     *  c.getDeclaredMethods():获取所有的方法
     */
    @org.junit.Test
    public void test03(){
        try {
            Class c = Class.forName("com.ltc.Student");
            Method[] methods = c.getDeclaredMethods();
            for (int i = 0; i < methods.length; i++) {
                System.out.println("方法的名称==》"+methods[i].getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

04.获取类的私有属性值

@org.junit.Test
    public void test04(){
        try {
            Class c = Class.forName("com.ltc.Student");
            Student stu = (Student)c.newInstance();
            //stu.sex 获取不到私有的属性和私有方法
            Field field = c.getDeclaredField("sex");
            //打开访问私有属性或者方法的开关
            field.setAccessible(true);
            System.out.println(field.get(stu));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

05.获取类的私有方法

   方法反射的操作
   method.invoke(对象,参数列表)

@org.junit.Test
    public void test05(){
        
        try {
            Class c = Class.forName("com.ltc.Student");
            Student stu = (Student)c.newInstance();
            Method methods = c.getDeclaredMethod("getSum", double.class);
            methods.setAccessible(true);
            double result = (double) methods.invoke(stu, 50.0);
            System.out.println(result);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

升华

@org.junit.Test
    public void test06(){
        ArrayList list = new ArrayList();
        
        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("hello");
        //list1.add(20);错误的
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        System.out.println(c1 == c2);
        //反射的操作都是编译之后的操作
        
        /*
         * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
         * Java中集合的泛型,是防止错误输入的,只在编译阶段有效,
         * 绕过编译就无效了
         * 验证:我们可以通过方法的反射来操作,绕过编译
         */
        try {
            Method m = c2.getMethod("add", Object.class);
            m.invoke(list1, 20);//绕过编译操作就绕过了泛型
            System.out.println(list1.size());
            System.out.println(list1);
            /*for (String string : list1) {
                System.out.println(string);
            }*///现在不能这样遍历
        } catch (Exception e) {
          e.printStackTrace();
        }
    }

posted on 2018-01-17 17:40  天天xiangshang  阅读(145)  评论(0编辑  收藏  举报

导航