Java应用一（java的运行机制，反射的应用）

一、java运行图

• new 对象创建的对象底层用到的都是反射
• 每个类只有一个类对象，可以有多个类的对象
• Class是所有类对象的底层，所有的类对象都是Class的对象，包括它本身
• Object是所有类的对象的基类，Object的类对象也是Class的对象。

二、反射的应用

1.类对象只能有一个，获得类对象的方式有三种

代码演示

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //三种方式获取的类对象方法不同，泛型的给值也不同，可以不给尖括号
        //方法一：通过class.forname()获取类对象
        //由于参数为字符串不知道类对象的类型，故泛型为？，也可以不给
        Class<?> aClass1 = Class.forName("com.hehe.reflect.Student");
        //Class aClass1 = Class.forName("com.hehe.reflect.Student");

        /**
         * 方法二：通过类名获取类对象,知道类的类型，故泛型为Student
         */
        Class<Student> aClass2 = Student.class;
        //Class aclass1 = Student.class;
        /**
         * 方法三：通过类的对象获取类对象,该类对象可能是Studnet的子类，故泛型为? extends Student
         */
        Student student=new Student();
        Class<? extends Student> aClass3 = student.getClass();
        //Class aClass3 = student.getClass();
        /**
         * 判断三种方式获取的类对象是否是同一个
         */
        System.out.println(aClass1==aClass2);//true
        System.out.println(aClass1==aClass3);//true


    }
}

2.类对象的使用--------通过类对象创建类的对象

package com.hehe.reflect;

import java.lang.reflect.Constructor;

public class Demo2 {
    public static void main(String[] args) throws Exception {
        Class<?> aClass = Class.forName("com.hehe.reflect.Student");
        /**
         * 创建无参对象,由于不知道类的对象的类型，这里给出最大的基类
         */
        Object o = aClass.newInstance();
        System.out.println(o);
        /**
         * 创建有参对象
         */
        Constructor<?> constructor = aClass.getConstructor(String.class, Integer.class);
        Object o1 = constructor.newInstance("张三", 23);
        System.out.println(o1);
    }
}
/*结果：
Student{name='null', age=null}
Student{name='张三', age=23}
 */

3.类对象的使用--------通过类对象获取类的属性，方法，注解

注解：给代码看
注释：给人看
这里不演示获取注解

获取属性

import java.lang.reflect.Field;

public class Demo3 {
    public static void main(String[] args) throws Exception {
        Class<Student> aClass = Student.class;
        /**
         * 获取所有公有属性
         */
        Field[] fields = aClass.getFields();
        for(Field f:fields){
            System.out.println(f);
        }
        /**
         * 通过属性名获取指定公有属性
         */
        Field name = aClass.getField("name");
        System.out.println(name);
        System.out.println("===============");
        /**
         * 获取所有属性
         */
        Field[] declaredFields = aClass.getDeclaredFields();
        for(Field f1:declaredFields){
            System.out.println(f1);
        }
        /**
         * 通过属性名获取私有属性
         */
        Field age = aClass.getDeclaredField("age");
        System.out.println(age);
        
    }
}
/*
public java.lang.String com.hehe.reflect.Student.name
public java.lang.String com.hehe.reflect.Student.name
===============
public java.lang.String com.hehe.reflect.Student.name
private java.lang.Integer com.hehe.reflect.Student.age
private java.lang.Integer com.hehe.reflect.Student.age
 */

获取方法

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

public class Demo4 {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        Class<? extends Student> aClass = student.getClass();
        /**
         * 获取方法对象，传入方法名和参数类型
         */
        Method method = aClass.getDeclaredMethod("setName", String.class);
        /**
         * 执行方法
         */
        method.invoke(student,"张飒");
        System.out.println(student);
    }
}
/*结果
Student{name='张飒', age=null}
 */

4.通过反射会绕过对泛型对象类型的限制

import java.lang.reflect.Method;
import java.util.ArrayList;

public class Demo5 {
    public static void main(String[] args) throws Exception {
        ArrayList<String> list = new ArrayList<String>();
        //加入int类型编译会报错
        list.add("张三");
        list.add("李四");
        //通过反射，获取add方法，会不受泛型的限制
        Class<? extends ArrayList> aClass = list.getClass();
        //因为不知道是什么类型，故可以给object类
        Method add = aClass.getMethod("add", Object.class);
        add.invoke(list,1000);
        System.out.println(list);

    }
}
/*结果
[张三, 李四, 1000]
 */

java
java入门基础学习（一）
java入门基础学习（二）
java入门基础学习（三）
java入门基础学习（四）
java入门基础学习（五）
java入门基础学习（六）
java入门基础学习（七）
java入门基础学习（八）
java入门基础学习（九）
java入门基础学习（十）
java入门基础学习（十一）
java入门基础学习（十二)
java入门基础学习（十三）
java入门基础学习（十四）Maven Git
java总结,题目+笔记
java进阶之常见对象（一）
java进阶之常见对象（二）
java进阶之冒泡排序
java进阶之选择排序
java进阶之面向对象（封装）
java进阶之面向对象（代码块、继承）
java进阶之面向对象（多态、抽象、接口）
java进阶之匿名内部类、访问修饰符、包
java进阶之io流（字节流，字符流）
Linux
Linux基础一
Linux基础二
Mysql
mysql一
mysql二
mysql三
mysql四
java连接数据库