Java 泛型

package org.jeecg.modules.caiji.CaijiUtils;

import java.lang.reflect.Field;
import java.util.Random;

/**
 * @Description: 泛型
 * @author: 小邯
 * @date: 2021/03/26 11:03
 */
public class demo {
    //java 的泛型
    /**
     *  泛型，即“参数化类型”，顾名思义，就是将类型由原来的类型参数化，类似方法中的变量参数，此时类型也定义成参数形式,然后具体调用传入实参。
     */
    /**
     * 泛型的使用 分别为：泛型类，泛型接口，泛型方法
     */
    /**
     * 泛型类
     */
    public static class Fx<T>{

        //key这个成员变量的类型为T，T的类型由外部指定
        private T key;

        //泛型无参构造方法
        public Fx(){

        }
        //泛型构造方法形参key的类型为T,T的类型由外部指定
        public Fx(T key){
            this.key = key;
        }

        public T getKey(){
            return  key;
        }
    }

    /**
     * 泛型接口
     * @param
     */
    public interface Generator<T>{
        public T kk();
    }
    //实现泛型接口的类，未传入泛型实参时：
    public  class FxGenerator<T> implements Generator<T>{
        @Override
        public T kk(){
            return  null;
        }
    }
    //实现泛型接口的类，传入泛型实参时：
    public  class FxGenerator2 implements Generator<String>{

        private String[] aa = new String[]{"ak", "bv", "cs"};

        @Override
        public String kk(){
            Random rand = new Random();
            return aa[rand.nextInt(3)];
        }
    }

    /**
     * 泛型通配符
     * @param
     */
    public void shouKey(Fx<?> obj){
         System.out.println("泛型测试：key value is " + obj.getKey());
    }

     /**
     * 泛型方法
     * @param
     */


    //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
    public static <T> T  fxMethod(T t) {
        T o = null;
        try{
            Class<?> cc =  t.getClass();
            Object object =  cc.newInstance();
            Field field = cc.getDeclaredField("name");
            //id是private类型的,如果没有下面的设置,会抛出IllegalAccessException
            field.setAccessible(true);
            field.set(object,"小花");
            System.out.println(object);
            return (T)object;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;

    }

    public static <T> T fxMethod2(Class<?> clazz) {

        T o = null;
        System.out.println(clazz.getClass());
        System.out.println(clazz.getDeclaredFields());
        System.out.println(clazz.getName());
        System.out.println(clazz.getFields());
        try{
            Object object =  clazz.newInstance();
            Field field = clazz.getDeclaredField("color");
            //id是private类型的,如果没有下面的设置,会抛出IllegalAccessException
            field.setAccessible(true);
            field.set(object,"red");
            System.out.println(object);
            return (T)object;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;

    }

    public static class Peos{
        private String name;
        public String getName(){
            return name;
        }
    }

    public static class Appl{
        private String name;
        public String getName(){
            return name;
        }
        private String color;
        public String getColor(){
            return color;
        }
    }

    /**
     * 测试
     * @param
     */
    public static void main(String[] args) {
        //测试泛型类
        Fx<Integer> fxInteger = new Fx<Integer>();
        fxInteger.key = 123456;

        //传入的实参类型需与泛型的类型参数类型相同，即为String.
        Fx<String> boxString = new Fx<String>("key_vlaue");

        System.out.println("泛型测试: key is " + fxInteger.getKey());
        System.out.println("泛型测试: key is " + boxString.getKey());


        //测试泛型通配符
        Fx<Integer> kkInt = new Fx<Integer>(1);
        System.out.println("泛型测试: key is " + kkInt.getKey());
        Fx<String> kkStr = new Fx<String>("abc");
        System.out.println("泛型测试: key is " + kkStr.getKey());


        //测试泛型方法
        Peos peos = new Peos();
        Appl appl = new Appl();
        peos = fxMethod(peos);
        appl = fxMethod(appl);
        System.out.println("泛型方法:" + peos.name);
        System.out.println("泛型方法:" + appl.name);

        //泛型类，通配符
        Appl apps = new Appl();
        Class<?> cc = apps.getClass();
        apps = fxMethod2(cc);
        System.out.println("泛型类，通配符:" + apps.color);
    }




}