java中的泛型

泛型

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

含有泛型的方法：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

含有泛型的接口：

修饰符 interface接口名<代表泛型的变量> {  }

自定义泛型



public class Generics {

     //T 是由外部使用类的时候来调用
    //声明成员变量  生成get/set 构造方法 toString
    private  T key;

    public Generics() {

    }

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    public Generics(T key) {
        this.key = key;
    }
    @Override
    public String toString() {
        return "Generics{" +
                "key=" + key +
                '}';
    }
}

public class MainClass {
    //泛型类，不支持基本数据类型
    public static void main(String[] args) {
        //泛型类在创建对象时，来指定具体数据类型
        Generics g1 = new Generics("abc");
        String key1 = g1.getKey();
        System.out.println("key1:"+key1);
        System.out.println("---------------------------------");
        Generics g2 = new Generics(11);
        Integer key2 = g2.getKey();
        System.out.println("key2:"+key2);
        System.out.println("---------------------------------");
        //泛型类在创建对象时，没有来指定具体数据类型，将按照object类型来操作
        Generics g3= new Generics("abc");
        Object key3 = g3.getKey();
        System.out.println("key3:"+key3);


        System.out.println("---------------------------------");
        //同一泛型类，根据不同数据类型创建任务，本质是同一类型
        System.out.println(g1.getClass());
        System.out.println(g2.getClass());
        System.out.println(g3.getClass());
    }

泛型注意

从泛型类派生子类
 1.子类也是泛型类，子类要求和父类泛型类型一致
 2.子类不是泛型类，父类的泛型类型要明确

 从泛型接口派生子类
  1.子类也是泛型类，子类要求和父类泛型类型一致
 2.子类不是泛型类，父类的泛型类型要明确

可变参数&静态泛型方法

import java.util.ArrayList;
//泛型类中成员方法不能为static
//泛型方法能使方法独立于类而产生变化
//如果static方法要使用泛型能力，就必须使其成为泛型方法
public class Test {
    public static void main(String[] args) {

        ProudctGetter p1= new ProudctGetter<>();
        ArrayList sl=new ArrayList<>();
        sl.add("aaa");
        sl.add("bbb");
        sl.add("ccc");
        //泛型方法的调用，类型是通过调用方法的时候来指定
        String roudct = p1.getRoudct(sl);
        System.out.println(roudct+"t"+roudct.getClass().getSimpleName());
        System.out.println("-------------------");
        //静态泛型调用
        ProudctGetter.pr(100,true,"sss");
        System.out.println("-------------------");
        //泛型可变参数调用
        ProudctGetter.pr2(1,true,"ss");
    }

}

import java.util.ArrayList;
import java.util.Random;

public class ProudctGetter {
    Random random=new Random();
    //奖品
    private  T proudct;
    //奖品集合
    ArrayList list=new ArrayList<>();
    //添加奖品
    public  void addProudct(T t) {
        list.add(t);
    }
    //抽奖
    public T getRoudct(){
        proudct= list.get(random.nextInt(list.size()));
        return proudct;
    }
    //泛型方法  list 参数  E 泛型参数

   

   public   T getRoudct(ArrayList list){
       return  list.get(random.nextInt(list.size()));
   }
   //静态泛型方法
    public static   void pr(T t,E e,K k){
        System.out.println(t+"t"+t.getClass().getSimpleName());
        System.out.println(e+"t"+e.getClass().getSimpleName());
        System.out.println(k+"t"+k.getClass().getSimpleName());

    }

    //泛型可变参数
    public static   void pr2(E... e){

        for (int i = 0; i  
类型通配符 



public class Test {
    public static void main(String[] args) {
        Box box=new Box<>();
        box.setE(1000);
        showbox(box);
        Box box1=new Box<>();
        box.setE(2000);
        showbox(box1);
    }

    public static void showbox(Box box){
        Object first=box.getE();
        System.out.println(first);
    }
}

 
public class Box {
    private  E e;

    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }
}
 
类型通配符上限&下限 
import java.util.ArrayList;



public class Test {
    public static void main(String[] args) {
        ArrayList animal=new ArrayList<>();
        ArrayList cat=new ArrayList<>();
        ArrayList min=new ArrayList<>();
        
      
    }

    
    public static void showAnimal(ArrayList list){
        for (int i = 0; i  list){
        for (Object o:list) {
            System.out.println(o);
        }

    }
}

 
public class Min  extends  Cat{
    public int lave;

    @Override
    public String toString() {
        return "Min{" +
                "lave=" + lave +
                '}';
    }

    public Min(String name, int age, int lave) {
        super(name, age);
        this.lave = lave;
    }
}

 
public class Cat  extends  Animal{
    public int age;

    public Cat(String name, int age) {
        super(name);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + ''' +
                '}';
    }
}
 
public class Animal{

    public String name;

    public Animal(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + ''' +
                '}';
    }
}
 
import java.util.Comparator;
import java.util.TreeSet;

public class Test2 {
    public static void main(String[] args) {

        TreeSet tc=new TreeSet<>(new Comparatorl2());
        //TreeSet tc=new TreeSet<>(new Comparatorl());

        tc.add(new Cat("aa",31));
        tc.add(new Cat("ab",1));
        tc.add(new Cat("ac",33));
        for (Cat cat : tc) {
            System.out.println(cat);
        }

    }
}
class Comparatorl implements Comparator {
    @Override
    public int compare(Animal o1, Animal o2) {
        return o1.name.compareTo(o2.name);
    }
}
class Comparatorl2 implements Comparator {
    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.age-o2.age;
    }
}
class Comparatorl3 implements Comparator {
    @Override
    public int compare(Min o1, Min o2) {
        return o1.lave-o2.lave;
    }
}
 
泛型擦除 
import java.util.List;

public class Earsure {
    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    
    public   T ss(T t){
        return t;
    }
}

 
public interface Info {
    T info(T var);


}
 
public class InfoImpl implements  Info {

    @Override
    public Integer info(Integer var) {
        return var;
    }
}

 
public class Test {
    public static void main(String[] args) {
        ArrayList integerArrayList=new ArrayList<>();
        ArrayList StringArrayList=new ArrayList<>();
        System.out.println(integerArrayList.getClass().getSimpleName());
        System.out.println(StringArrayList.getClass().getSimpleName());
    }
}
 





public class Test2 {
    public static void main(String[] args) {
      Earsure earsure=new Earsure();
        //利用反射，获取Earsure的字节码文件的所有class对象
        Class c=earsure.getClass();
        //获取所有对象
        Field[] declaredFields = c.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField.getName()+"    >>"+declaredField.getType().getSimpleName());
        }
        System.out.println("------------------------------------------");
      //利用反射获取方法
        Method[] declaredMethods = c.getDeclaredMethods();
        System.out.println("方法名"+" "+"返回值类型");
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName()+"      >>"+declaredMethod.getReturnType().getSimpleName());
        }
        System.out.println("------------------------------------------");

        
        Class infoClass = InfoImpl.class;
        Method[] declaredMethods1 = infoClass.getDeclaredMethods();
        System.out.println("方法名"+" "+"返回值类型");
        for (Method method : declaredMethods1) {
            System.out.println(method.getName()+"  >>"+method.getReturnType().getSimpleName());
        }
    }
}

 
创建泛型的数组 

public class Test {
    public static void main(String[] args) {
        //1.0可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
      //  ArrayList [] list=new ArrayList[5];
        //不安全的
     //        ArrayList [] list=new ArrayList[5];    //不安全的
     //        ArrayList [] listArr=list;    //不安全的
        ArrayList [] list=new ArrayList[5];
        ArrayList  integerArrayList=new ArrayList<>();
        integerArrayList.add(100);

        ArrayListlist1=new ArrayList<>();
        list1.add("adc");
        list[0]=list1;
       
        System.out.println(list[0].get(0));
        System.out.println("----------------------------");
        //通过import java.lang.reflect.Array的newInstance(Class clz,int length) 创建T数组
        FruIt fruIt=new FruIt<>(String.class,3);
        fruIt.put(0,"水果");
        fruIt.put(1,"手雷");
        fruIt.put(2,"海洋");
       //遍历
        System.out.println(Arrays.toString(fruIt.getArry()));
        String s = fruIt.get(2);
        System.out.println(s);
    }
}

 
import java.lang.reflect.Array;

public class FruIt{
  // 1.0 创建一个T类型的数组
    private  T[] arry;

    public FruIt(Class clz,int length) {
        //2.0通过Array.newInstance 创建泛型数组
          arry= (T[]) Array.newInstance(clz,length);
    }
    //3.0填充数组
    public  void  put(int index,T item){
        arry[index]=item;
    }
    //4.0获取数组
    public T get(int index){
        return arry[index];
    }
    public T[] getArry(){
        return arry;
    }
}

java中的泛型

Java相关栏目本月热门文章