Java泛型和反射

1、简介

依照实例的方式说明泛型 反射是做什么的，是个什么。

2、泛型

package myapplication.lum.com.lib;

import java.util.ArrayList;


public class MyClass {
    public static void main(String[] args){
        ArrayList arrayListA  = new ArrayList(); //w我们创建一个 ArrayList 列表
        arrayListA.add("name");  //列表里面 放入 String 类型的对象
        arrayListA.add("age");
        arrayListA.add("sex");

        System.out.println("arrayListA length: " + arrayListA.size());
         String strA = (String) arrayListA.get(0); //我们看到我们必须在取出的对象前面添加对应的 类型 String 强转  ，不然会出错
        System.out.println("arrayListA[0]: " + strA);

        //````````````````````````````

        System.out.println();

        **ArrayList arrayListB  = new ArrayList(); //我们创建一个 ArrayList 列表,同时说明列表里的对象类型 ，这就是泛型的使用**
        arrayListB.add("name");  //列表里面 放入 String 类型的对象
        arrayListB.add("age");
        arrayListB.add("sex");

        System.out.println("arrayListB length: " + arrayListB.size());
        String str =  arrayListB.get(1); //我们看到我们取出来里面数据的时候，不需要加类型强转，也不会报错
        System.out.println("arrayListB[0]: " + str);


    }
}

运行结果：
arrayListA length: 3
arrayListA[0]: name

arrayListB length: 3
arrayListB[0]: age

3、反射

就是我们可以通过一种方法，自己封装一个类，来实现对另一个类内部信息的获取，比如变量名，方法等

package myapplication.lum.com.lib;

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

public class MyClass {
    public static  void main(String[] args){
    FanShe people = new FanShe(new People()); //我们通过自己定义的反射类来解析 自己i当以的people 类
    people.showObjectInformation(); //显示 自己定义的people 类的信息
    }


     //我们封装的 反射类 ，用于查找 别的类里面的信息，比如变量，方法等
     static class FanShe{
        private  T object;
        FanShe(T t){
            this.object = t;
        }

        public void showObjectInformation(){
        System.out.println("object style is: " + object.getClass().getName());//取类类型
            Method [] method = object.getClass().getDeclaredMethods(); //取出类里里面所有方法
            System.out.println("method num: " + method.length); //总共有几个方法
            for (int i = 0; i< method.length;i++){
                System.out.println("method name: " + method[i].getName());//每个方法的名字
            }
            Field[] field = object.getClass().getDeclaredFields();//获取变量
            System.out.println("field num: " + field.length); //总共有几个变量
            for (int i = 0; i< field.length;i++){
                System.out.println("field name: " + field[i].getName());//每个变量的名字
            }

        }
    }

    //这是我们自定义的一个 类 people
    static class People{
        private String  name ;
        private int age ;
        public String sex;

        public  People(){

        }
        public void setName(int age) {
        }

        public void getName() {
        }

        public void setAge(int age) {
        }

        public void getAge() {
        }

    }
}

打印：
object style is: myapplication.lum.com.lib.MyClass$People
method num: 4
method name: getName
method name: setName
method name: getAge
method name: setAge

field num: 3
field name: name
field name: age
field name: sex

当然我们也可以通过反射对解析的类及逆行修改，里面的变量值，以及里面方法执行逻辑

文章参考：

泛型 T 和 通配符 ？
https://blog.csdn.net/qq_18581651/article/details/81942221