Java 泛型全面总结

来源：互联网发布：修合无人见存心天地知编辑：程序博客网时间：2024/05/22 02:10

普通泛型

class Point<T>{       // 此处可以随便写标识符号，T是type的简称      private T var ; // var的类型由T指定，即：由外部指定          public T getVar(){  // 返回值的类型由外部决定          return var ;      }      public void setVar(T var){  // 设置的类型也由外部决定          this.var = var ;      }  }public class GenericsDemo1{      public static void main(String args[]){          Point<String> p = new Point<String>() ; // 里面的var类型为String类型          p.setVar("ieddcsdfafsdgbv") ;        // 设置字符串          System.out.println(p.getVar().length()) ;   // 取得字符串的长度      }  }

多个泛型

class Notepad<K,V>{       // 此处指定了两个泛型类型      private K key ;     // 此变量的类型由外部决定      private V value ;   // 此变量的类型由外部决定      public K getKey(){          return this.key ;      }      public V getValue(){          return this.value ;      }      public void setKey(K key){          this.key = key ;      }      public void setValue(V value){          this.value = value ;      }  };  public class GenericsDemo2{      public static void main(String args[]){              Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象          t = new Notepad<String,Integer>() ;       // 里面的key为String，value为Integer          t.setKey("汤姆") ;        // 设置第一个内容          t.setValue(20) ;            // 设置第二个内容          System.out.print("姓名；" + t.getKey()) ;      // 取得信息          System.out.print("，年龄；" + t.getValue()) ;       // 取得信息        }  };

通配符

class Info< T>{   private T var ;  // 定义泛型变量   public void setVar(T var){    this.var = var ;   }   public T getVar(){    return this.var ;   }   public String toString(){ // 直接打印    return this.var.toString() ;   }  };  public class GenericsDemo14{   public static void main(String args[]){    Info< String> i = new Info< String>() ;  // 使用String为泛型类型    i.setVar("it") ;       // 设置内容    fun(i) ;   }   public static void fun(Info< ?> temp){  // 可以接收任意的泛型对象    System.out.println("内容：" + temp) ;   }  };

受限泛型

    class Info<T>{          private T var ;     // 定义泛型变量          public void setVar(T var){              this.var = var ;          }          public T getVar(){              return this.var ;          }          public String toString(){   // 直接打印              return this.var.toString() ;          }      };      public class GenericsDemo17{          public static void main(String args[]){              Info<Integer> i1 = new Info<Integer>() ;        // 声明Integer的泛型对象              Info<Float> i2 = new Info<Float>() ;            // 声明Float的泛型对象              i1.setVar(30) ;                                 // 设置整数，自动装箱              i2.setVar(30.1f) ;                              // 设置小数，自动装箱              fun(i1) ;              fun(i2) ;          }          public static void fun(Info<? extends Number> temp){  // 只能接收Number及其Number的子类              System.out.print(temp + "、") ;          }      };      ----------------------------------------------------------      class Info<T>{          private T var ;     // 定义泛型变量          public void setVar(T var){              this.var = var ;          }          public T getVar(){              return this.var ;          }          public String toString(){   // 直接打印              return this.var.toString() ;          }      };      public class GenericsDemo21{          public static void main(String args[]){              Info<String> i1 = new Info<String>() ;      // 声明String的泛型对象              Info<Object> i2 = new Info<Object>() ;      // 声明Object的泛型对象              i1.setVar("hello") ;              i2.setVar(new Object()) ;              fun(i1) ;              fun(i2) ;          }          public static void fun(Info<? super String> temp){    // 只能接收String或Object类型的泛型              System.out.print(temp + "、") ;          }      };

Java泛型接口

interface Info<T>{        // 在接口上定义泛型      public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型  }  class InfoImpl<T> implements Info<T>{   // 定义泛型接口的子类      private T var ;             // 定义属性      public InfoImpl(T var){     // 通过构造方法设置属性内容          this.setVar(var) ;        }      public void setVar(T var){          this.var = var ;      }      public T getVar(){          return this.var ;      }  };  public class GenericsDemo24{      public static void main(String arsg[]){          Info<String> i = null;        // 声明接口对象          i = new InfoImpl<String>("汤姆") ;  // 通过子类实例化对象          System.out.println("内容：" + i.getVar()) ;      }  };

通过泛型方法返回泛型类型实例

class Info<T extends Number>{ // 指定上限，只能是数字类型      private T var ;     // 此类型由外部决定      public T getVar(){          return this.var ;         }      public void setVar(T var){          this.var = var ;      }      public String toString(){       // 覆写Object类中的toString()方法          return this.var.toString() ;          }  };  public class GenericsDemo27{      public static void main(String args[]){          Info<Integer> i = fun(30) ;          System.out.println(i.getVar()) ;      }      public static <T extends Number> Info<T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定          Info<T> temp = new Info<T>() ;      // 根据传入的数据类型实例化Info          temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中          return temp ;   // 返回实例化对象      }  };

使用泛型统一传入的参数类型

    class Info<T>{    // 指定上限，只能是数字类型          private T var ;     // 此类型由外部决定          public T getVar(){              return this.var ;             }          public void setVar(T var){              this.var = var ;          }          public String toString(){       // 覆写Object类中的toString()方法              return this.var.toString() ;              }      };      public class GenericsDemo28{          public static void main(String args[]){              Info<String> i1 = new Info<String>() ;              Info<String> i2 = new Info<String>() ;              i1.setVar("HELLO") ;        // 设置内容              i2.setVar("汤姆") ;       // 设置内容              add(i1,i2) ;          }          public static <T> void add(Info<T> i1,Info<T> i2){              System.out.println(i1.getVar() + " " + i2.getVar()) ;          }      };

泛型数组

    public class GenericsDemo30{          public static void main(String args[]){              Integer i[] = fun1(1,2,3,4,5,6) ;   // 返回泛型数组              fun2(i) ;          }          public static <T> T[] fun1(T...arg){  // 接收可变参数              return arg ;            // 返回泛型数组          }          public static <T> void fun2(T param[]){   // 输出              System.out.print("接收泛型数组：") ;              for(T t:param){                  System.out.print(t + "、") ;              }          }      };

泛型的嵌套设置

    class Info<T,V>{      // 接收两个泛型类型          private T var ;          private V value ;          public Info(T var,V value){              this.setVar(var) ;              this.setValue(value) ;          }          public void setVar(T var){              this.var = var ;          }          public void setValue(V value){              this.value = value ;          }          public T getVar(){              return this.var ;          }          public V getValue(){              return this.value ;          }      };      class Demo<S>{          private S info ;          public Demo(S info){              this.setInfo(info) ;          }          public void setInfo(S info){              this.info = info ;          }          public S getInfo(){              return this.info ;          }      };      public class GenericsDemo31{          public static void main(String args[]){              Demo<Info<String,Integer>> d = null ;       // 将Info作为Demo的泛型类型              Info<String,Integer> i = null ;   // Info指定两个泛型类型              i = new Info<String,Integer>("汤姆",30) ;    // 实例化Info对象              d = new Demo<Info<String,Integer>>(i) ; // 在Demo类中设置Info类的对象              System.out.println("内容一：" + d.getInfo().getVar()) ;              System.out.println("内容二：" + d.getInfo().getValue()) ;          }      };

0 0