泛型


package com.java.Generic;
/*
  泛型概念
  1、泛型可以理解为在类上面贴了个标签,作用是编辑器通过标签来确定类型
  2、所谓泛型:就是允许在定义类、接口时指定类型形参,这个类型形参将在声明变量、创建对象时确定(即传入实际的类型参数,也可称为类型实参)。从而把原来程序运行时可能发生的问题,转变为编译时的问题。

* 泛型在底层运行时会执行一个擦除操作。
* 泛型不支持继承
* 泛型中声明的类型可以支持通配符
*
*
* */

import com.java.javaClass.common.User;

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

public class runGeneric {

    public static void main(String[] args) {
           /*
             擦除
            * */
        List<User> list = new ArrayList<>();
        list.add(new User("loginName", "password", 20));
        list.add(new User("loginName1", "password1", 31));
        list.add(new User("loginName1", "password1", 33));
        //list.add("123123");//报错

        System.out.println("长度:" + list.size());//3
        for (User user : list) {

            System.out.println(user.getAge());
            System.out.println(user.getLoginname());
            System.out.println(user.getPassword());
        }

        Class<?> listClass = list.getClass();
        try {

            Method method = listClass.getDeclaredMethod("add", Object.class);
            method.invoke(list, "张三");
            //通过打印长度可以看出数据插入成功,这种现象称之为擦除机制。
            System.out.println("list.size():" + list.size()); //4

            List<String> list1 = new ArrayList<>();
            List<Integer> list2 = new ArrayList<>();
            System.out.println(list1.getClass() == list2.getClass());//true
            /*
             *  这表示在运行过程中任何和类型有关的信息都会被擦除,所有在运行中 ArrayList和ArrayList的具体信息都被擦除成它们的原生类型即ArrayList类型。由于擦除机制,泛型不能用于显示地引用运行时类型的操作之中,例如转型、new表达式和instanceof操作。若在泛型内部必须使用类型操作时,可以在运行时采用反射的方法将正在运行的类信息添加到泛型内部,这种方法称为补偿

             * */
        } catch (Exception e) {

            e.printStackTrace();
        }


        /*
         * 泛型不支持继承
         * List<String>不能被当成List<Object>对象使用,也就是说List<String>不是List<Object>的子类,String是继承Object
         * 的,但是泛型String并不是继承泛型Object
         * */

        List<String> names = new ArrayList<>();
        //调用play方法  泛型不支持继承关系

        // play(names);

      /*
          * public  static  void play(List<Object> params){}
            *  */


        /*
         * 泛型中的类型支持通配符
         *  假设现在需要定义一个方法,该方法里有一个结合形参,但是集合形参的元素并不确定的。
         *为了解决类型被限制死了不能动态根据实例来确定的缺点,引入了类型通配符(?),将?作为类型的实参传给List结合,写
         * 做List<?>意思是未知类型元素的List,它的元素类型可以匹配任何类型。
         * 通配符上限List<? extends Number>类型必须继承Number
         * 通配符下限List<? super Integer> 类型必须是Integer或者Integer的父类
         * */
        /*
         * public static void play(List<?> params) {}
         * */

        List<Integer> ages=new ArrayList<>();
        play(names);
        play(ages);


        List<Byd> byds=new ArrayList<>();
        List<BWM> bwms=new ArrayList<>();
        List<Dog> dogs=new ArrayList<>();
        playGame(byds);
        playGame(bwms);
      // playGame(dogs);


        MyList<String> myList=new MyList<>();
        myList.add("张三");
        myList.add("李四");
        myList.add("王五");

        MyList2 my=new MyList2();
        my.add("www");
        my.get(0);

    }

    public static void play(List<?> params) {

    }

public  static  void playGame(List<? extends Car>cars)
{

}

}
class Car
{
    public void run()
    {

    }
}
class  Byd extends  Car
{
    @Override
    public void  run()
    {

    }
}
class  BWM extends  Car
{
    @Override
    public void  run()
    {

    }
}
class Dog
{
    public void run()
    {

    }


}
/*
 * 定义泛型类
 * 在定义累的时候可以声明泛型类,以及泛型的方法等。泛型一般建议使用E或者T
 * 两种方法
 * */

class MyList<T>
{
    Object [] objs=new Object[10];
    int index=0;
    public void add(T t)
    {
        objs[index++]=t;

    }

    public  T get(int index)
    {
        return (T)objs[index];
    }
}

class  MyList2
        {
            public <T>void add(T t)
            {

            }
            public <T> T get(int index)
            {
          
            }

        }







原文地址:https://www.cnblogs.com/lilihai/p/10220496.html