java 泛型详解

最新推荐文章于 2021-04-20 09:11:37 发布
最新推荐文章于 2021-04-20 09:11:37 发布
阅读量975 收藏
点赞数
分类专栏： java 文章标签： java 泛型

转载自：http://blog.csdn.net/wangjian223344/article/details/16846165


1.泛型的引入： 
为什么要用泛型？
比如现在要设计一个坐标的方法
坐标有几种表示方法：
1.整数：x=20,y=20
2.小数：x=20.2,y=20.2
3.字符串：x=东京180，y="北纬210"


看到这里我们是不是在想，要建立一个point类是，里面定义一个方法，来接收这三种数据，但是数据有三种，那么就只有用Object来接收了。因为Object可以接收任何数据，发生向上转型。。。
实现的思路：
代码：
//字符转接收
class Point{
      private Object x;
      private Object y;
      public Object getX() {
           return x ;
     }
      public void setX(Object x) {
           this .x = x;
     }
      public Object getY() {
           return y ;
     }
      public void setY(Object y) {
           this .y = y;
     }
}


public class PointTest {
      public static void main(String[] args ) {
          Point point= new Point();
           //整数接收
          point.setX( "东经120" );
          point.setY( "北纬60" );
          String x=(String)point.getX();
          String y=(String)point.getY();
          System. out .println("x坐标：" +x);
          System. out .println("y坐标：" +y);
     }
}
结果：
x坐标：东经120
y坐标：北纬60
好像这样是实现了我们想要的结果，那么来看看这段代码：


class Point{
      private Object x;
      private Object y;
      public Object getX() {
           return x ;
     }
      public void setX(Object x) {
           this .x = x;
     }
      public Object getY() {
           return y ;
     }
      public void setY(Object y) {
           this .y = y;
     }
}
public class PointTest {
      public static void main(String[] args) {
          Point point= new Point();
           //整数接收
          point.setX(123);
          point.setY( "北纬60" );//这里是用Object来接收的，所以可以接收任何类型
           int x=(Integer)point.getX();
           int y=(Integer)point.getY();
          System. out .println("x坐标：" +x);
          System. out .println("y坐标：" +y);
     }
}
结果：
Exception in thread "main" java.lang.ClassCastException : java.lang.String cannot be cast to java.lang.Integer
     at test.PointTest.main( PointTest.java:42 )
所以，这样为们才有了现在的泛型
泛型代码：
class Point1<T>{//声明一个泛型类
      private  T  var; //声明一个泛型变量
      private T  Yar;
      public T getVar() {
           return var ;
     }
      public void setVar(T var) {
           this .var = var;
     }
      public T getYar() {
           return Yar ;
     }
      public void setYar(T yar) {
           Yar = yar;
     }
}


public class PointTest1 {
   public static void main(String[] args) {
 Point1<Object> point= new Point1<Object>();
 point.setVar(20);
 point.setYar( "北纬" );
  System. out .println("x坐标" +point.getVar());
  System. out .println("y坐标" +point.getYar());
  }
}
结果：
x坐标20
y坐标北纬


2.泛型的构造方法
class Point1<T>{//声明一个泛型类
      private  T  var; //声明一个泛型变量
      private T  Yar;
      public T getVar() {
           return var ;
     }
      public Point1(T var, T yar) {
           this .var = var;
           Yar = yar;
     }
      public void setVar(T var) {
           this .var = var;
     }
      public T getYar() {
           return Yar ;
     }
      public void setYar(T yar) {
           Yar = yar;
     }
}
public class PointTest1 {
   public static void main(String[] args) {
Point1<Object> point= new Point1<Object>(20,"北纬" );
System. out .println("x坐标" +point.getVar());
System. out .println("y坐标" +point.getYar());
  }
}
结果：
x坐标20
y坐标北纬


3.指定多个泛型
class Point1<T,K>{//声明一个泛型类
      private  T  var; //声明一个泛型变量
      private K Yar;
      public T getVar() {
           return var ;
     }
      public void setVar(T var) {
           this .var = var;
     }
      public K getYar() {
           return Yar ;
     }
      public void setYar(K yar) {
           Yar = yar;
     }
      public Point1(T var, K yar) {
           this .var = var;
           Yar = yar;
     }
}
public class PointTest1 {
           public static void main(String[] args) {
              Point1<Integer,String> point= new Point1<Integer,String>(20,"北纬" );
                   System. out .println("x坐标" +point.getVar());
                   System. out .println("y坐标" +point.getYar());
          }
}
结果：
x坐标20
y坐标北纬


4.泛型的安全警告
class Point1<T,K>{//声明一个泛型类
      private  T  var; //声明一个泛型变量
      private K Yar;
      public T getVar() {
           return var ;
     }
      public void setVar(T var) {
           this .var = var;
     }
      public K getYar() {
           return Yar ;
     }
      public void setYar(K yar) {
           Yar = yar;
     }
      public Point1(T var, K yar) {
           this .var = var;
           Yar = yar;
     }
}
public class PointTest1 {
           public static void main(String[] args) {
               Point1 point= new Point1(20, "北纬" );//这里如果不指定泛型，那么系统就会擦除泛型，变为Object类型来接收
/**
警告消息：
Multiple markers at this line
     - Point1 is a raw type. References to generic type Point1<T,K> should be parameterized
     - Point1 is a raw type. References to generic type Point1<T,K> should be parameterized
     - Type safety: The constructor Point1(Object, Object) belongs to the raw type Point1. References to generic type Point1<T,K> 
     should be parameterized
*/
               //point.setVar(20);
           //   Point1<String> point1=new Point1<String>();
           //   point.setYar("北纬");
                   System. out .println("x坐标" +point.getVar());
                   System. out .println("y坐标" +point.getYar());
          }
}
结果：
x坐标20
y坐标北纬



5.通配符
class Info<T>{
      private T var;
      public T getVar() {
           return var ;
     }
      public void setVar(T var) {
           this .var = var;
     }
}
public class TypeTest {
      public static void main(String[] args) {
          Info<String>i= new Info<String>();
          i.setVar( "like" );
           fun(i); //这里出现错误，无法传递
     }
      public static void fun(Info<Object> temp){
          System. out .println("内容" +temp);
     }
}


这样肯定是不行的，如果把代码改为这样：
class Info<T>{
      private T var;
      public T getVar() {
           return var ;
     }
      public void setVar(T var) {
           this .var = var;
     }
}
public class TypeTest {
      public static void main(String[] args) {
          Info<String>i= new Info<String>();
          i.setVar( "like" );
           fun(i);
     }
      public static void fun(Info temp){
          System. out .println("内容" +temp.getVar());
     }
}
结果：
内容like



但是这样有出现安全警告，那到底怎样才好喃？那就是要用泛型的通配符了
定义：表示可以使用任意的泛型对象
代码：
public class TypeTest {
      public static void main(String[] args) {
          Info<String>i= new Info<String>();
          i.setVar( "like" );
           fun(i);
     }
      public static void fun(Info<?> temp){//这里使用了统配符
          System. out .println("内容" +temp.getVar());
     }
}
结果：
内容like



6.受限泛型
受限泛型是指在泛型的操作过程中，可以指定一个泛型对象的范围上限和范围下限
格式：
    上限：
          声明对象：  类名称<? extends 类>对象名称
          声明类：访问权限 类名称<泛型标识 extends 类>
     下限：
            声明对象：  类名称<? super 类>对象名称
代码：
声明泛型对象
public class TypeTest {
      public static void main(String[] args) {
          Info<String>i= new Info<String>();
          i.setVar( "like" );
           fun(i); //这里出现错误，无法传递
     }
      public static void fun(Info<? extends Number > temp){
          System. out .println("内容" +temp.getVar());
     }
}
上面出现错误，是因为，泛型只能接收数字类型


改下代码：
class Info<T>{
      private T var;
      public T getVar() {
           return var ;
     }
      public void setVar(T var) {
           this .var = var;
     }
}
public class TypeTest {
      public static void main(String[] args) {
          Info< Integer>i= new Info< Integer>();
          i.setVar(20);
           fun(i);
     }
      public static void fun(Info<? extends Number> temp){
          System. out .println("内容" +temp.getVar());
     }
}
结果：
内容20


也可以接收其他类型的数字
看代码：
//接收Double
public class TypeTest {
      public static void main(String[] args) {
          Info<Double>i= new Info<Double>();
          i.setVar(20.28);
           fun(i); //这里出现错误，无法传递
     }
      public static void fun(Info<? extends Number> temp){
          System. out .println("内容" +temp.getVar());
     }
}
结果：
内容20.28

其他的数字类型就不一一例举了



声明受限泛型类：
代码：
class Info<T extends Number>{//这里声明了受限泛型类
      private T var;
      public T getVar() {
           return var ;
     }
      public void setVar(T var) {
           this .var = var;
     }
}
public class TypeTest {
      public static void main(String[] args) {
          Info<Double>i= new Info<Double>();
          i.setVar(20.28);
           fun(i);
     }
      public static void fun(Info<? extends Number> temp){//这里声明受限泛型方法
          System. out .println("内容" +temp.getVar());
     }
}
结果：
内容20.28


泛型下限：
声明受限泛型下限对象：
public class TypeTest {
      public static void main(String[] args) {
          Info<Double>i= new Info<Double>();
          i.setVar(20.28);
           fun(i);
     }
      public static void fun(Info<? super Double> temp){//这里声明泛型下限对象
      //这里就说明最低接收Double,还可以接收比Double 更高的 Number,Object
      System. out .println("内容" +temp.getVar());
     }
}
结果：
内容20.28



代码：
class Info<T  extends Double >{//这里声明泛型上限
      private T var;
      public T getVar() {
           return var ;
     }
      public void setVar(T var) {
           this .var = var;
     }
}
public class TypeTest {
      public static void main(String[] args) {
          Info<Double>i= new Info<Double>();
          i.setVar(20.28);
           fun(i);
     }
      public static void fun(Info<? super Double> temp){
          System. out .println("内容" +temp.getVar());
     }
}
结果：
内容20.28
这段代码就是说明 怎样声明上限和下限一起使用



7.泛型与子类继承的限制

子类作为参数的泛型和父类作为参数的泛型是不同的类型


一个类的子类可以通过对象多态性来实例化父类对象，但是在泛型类中，子类无法为父类实例化对象
代码：
public class TypeTest {
      public static void main(String[] args) {
          Info<Double>i= new Info<Double>();
          Info<Object>j= new Info<Object>();
          j= i; //这里会报错
          i.setVar(20.28);
     }
      public static void fun(Info<? super Double> temp){
          System. out .println("内容" +temp.getVar());
     }
}

子类不能实例化父类



8.泛型接口
泛型接口和普通接口也差不多，下面看代码就明白了
interface Info<T>{
      public T getVar();
}
实现泛型接口有两种方式
interface Info<T>{
      public T getVar();
}


public class TypeTest<T> implements Info<T>{
     private T var;
     public T getVar() {
        return var ;
     }
     public void setVar(T var) {
        this .var = var;
     }
     public static void main(String[] args) {
TypeTest<String> test= new TypeTest<String>();
test.setVar( "like" );
System. out .println(test.getVar());
     }
}
结果：
like



还有一种
interface Info<T>{
      public T getVar();
}
public class TypeTest implements Info<String>{
      private String var;
      public String getVar() {
           return var ;
     }
      public void setVar(String var) {
           this .var = var;
     }
      public static void main(String[] args) {
            TypeTest test= new TypeTest();
            test.setVar( "like" );
            System. out .println(test.getVar());
     }
}
结果：
like



9.泛型数组
public class TypeTest {
public static void main(String[] args) {
   //Integer i[]={1,2,3,4,5};//静态初始化数组
  Integer i[]= fun1(1,2,3,4,5);
   fun2(i);
}
public static <T> T[] fun1(T...arg){ //可变参数和泛型数组
   return arg;
}
public static <T> void fun2(T param[]){
   for (T t: param){
  System. out .print(t+"," );
  }
}
}
结果：
1,2,3,4,5,



附：

java中的<?><T><E>详解Jdk5.0新特性Generic Types (泛型)


我们不必给一个泛型方法传递一个真正的类型参数,编译器会推断类型参数.一个问题出现了,什么时候使用泛型方法,什么时候使通配符类型,为了回答这些问题,我们从Colleciton库中看一下几个方法： 
    interface Collection<E>{ 
           public boolean containsAll(Collection<?> c); 
           public boolean addAll(Collection<? extends E> c); 
    } 
    使用泛型方法的形式为： 
    interface Collection<E>{ 
           public <T> boolean containsAll(Collection<T> c); 
           public <T extends E> boolean addAll(Collection<T> c); 
    }  
   无论如何，在ContainAll和addAll中，类型参数T仅被使用一次。返回类型不依赖于类型参数，也不依赖方法中的任何参数。这告诉我 类型参数正被用于多态，它的影响仅仅是允许不同的实参在不同的调用点被使用。 
   泛型方法允许类型参数被用于表达在一个或更多参数之间或者方法中的参数、返回类型的依赖。如果没有如此依赖，泛型方法就不能被使用。可能一前一后来联合使用泛型和通配符，这里有个例子： 
    class Collections{ 
      public static <T> void copy(List<T> dest,List<? extends T> src){ 
    } 
 } 
    注意两个参数之间的依赖，任何从原list的对象复制，必须分配一个目标LIST元素的类型T,于是Src的元素类型可能是任何T的子类型。我们不必在意在COPY的表达中，表示依赖使用一个类型参数，但是是使用一个通配符。 
    下面我们不使用通配符来重写上面的方法： 
     class Collections{ 
      public static <T，S extends T> 
      void copy(List<T> dest,List<S> src){ 
    } 
 }  
    这非常好，但是第一个类型参数既在dst中使用，也在第二个类型参数中使用，S本身就被使用了一次。在类型src中,没有什么类型依赖它。这是一个标志我们可以用通配符来替换它。使用通配符比显示的声明类型参数更加清楚和精确。所以有可能推荐使用通配符。 
   通配符也有优势，可以在方法之外来使用，作为字段类型、局部变量和数组。 
这里有一个例子。 
   返回到我们画图的例子，假设我们要保持一个画图请求的历史，我们可以在Shape类内部用一个静态变量来保持历史。用drawAll()存储它到来的参数到历史字段。 
   static List<List<? extends Shape>> history = new ArrayList<List<? extends Shape>>(); 
   public void drawAll(List<? extends Shape> shapes){ 
    history.addLast(shapes); 
    for (Shape s : shapes){ 
           s.draw(this); 
         } 
   }



ycpanda
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【java】java 类型安全 与 unchecked warning
九师兄
11-23 741
我的总结：从概念上来说，Type Safety，最本质上，就是对于内存（Memory）的“正确访问”。假如说，在内存的一块区域上存储着一个String类型的对象；按照正常的逻辑，这块内存区域就应该被当作String来进行处理，这就是所谓的“正确访问”；但是，如果将这块内存区域当成Integer来进行处理，就会产生错误，这就是不正确的访问。从实现方法上来说，也就是JVM是怎么实现Type Safety的呢？要理解这个问题，就需要先知道compile time和runtime两个概念。
java 泛型警告_关于java：如何在使用没有泛型的遗留代码时避免Eclipse警告？
weixin_26908317的博客
03-05 623
我使用JSON.Simple从Java生成JSON输出。但是每次我调用jsonobj.put("this"，"that")，我都会在Eclipse中看到一个警告：Type safety: The method put(Object, Object) belongs to the raw type HashMap. References to generic type HashMap should ...
java 5.0 Type safety
shangye的专栏
04-08 1689
Type safety: The method add(Object) belongs to the raw type List. References to generic type List should be parameterized exampleList    treenode = new ArrayListtreenode.add(node); javadoc  中L
java 类型转换 安全,在某些Java泛型类型转换中类型安全警告的含义是什么？
weixin_42118161的博客
02-16 128
What is the meaning of the Java warning?Type safety: The cast from Object to List is actually checking against the erased type ListI get this warning when I try to cast an Object to a type with generi...
Type safety: The method add(Object) belongs to the raw type ArrayList
nicknailo博客
08-12 6575
Type safety: The method add(Object) belongs to the raw type ArrayList. References to generic type ArrayList should be parameterized Eclipse中以下代码在.add方法被调用时会出现警告（warnings）         Vector     v =
java泛型详解
08-31
Java 泛型详解 Java 泛型是 Java 语言中的一种重要机制，它可以帮助开发者编写更加安全、灵活和可重用的代码。在本文中，我们将详细介绍 Java 泛型的相关知识，包括泛型的概念、类型擦除、泛型的应用场景等内容。 ...
Java 泛型详解
09-18
Java泛型详解，Java泛型详解，Java泛型详解，Java泛型详解
Java泛型详解
09-02
Java泛型是Java 5版本引入的一个重要特性，它的出现主要解决了两个问题：类型安全性和编译时的类型检查。泛型允许我们在编程时指定容器（如集合）中存储的数据类型，确保在运行时不会发生类型转换异常，同时提供了一...
深入理解java泛型详解
08-30
让我们深入探讨一下Java泛型的各个方面。 首先，泛型（Generic type）是一种在定义类、接口或方法时，使用类型参数的方式。类型参数就像是方法的形参，但用于类型而非值。例如，当我们创建一个泛型列表`List<T>`，`...
java泛型详解.pdf
10-02
java泛型详解.pdf
去除java泛型警告
abckingaa的博客
04-03 1882
去除警告: Type safety: The method add(Object) belongs to the raw type Set. References to generic type Set<E> should be parameterized 在方法添加: @SuppressWarnings("unchecked") 去除警告: Set is a r...
java list类型参数_java – List是一个原始类型.引用通用类型List应该参数化
weixin_26779013的博客
02-28 1080
List is a raw type. References to generic type List should be parameterized不是错误,而是一个警告.理解泛型是一个基石,如果你打算使用Java,所以我建议你应该检查java的教程页面：所以如果你知道在publiesdList中包含什么类型的对象,你可以这样做：List synchronizedpubliesdList = C...
JAVA定义栈告警提示：“Stack is a raw type. References to generic type Stack<E> should be parameterized”
wh445306
12-05 2228
JAVA定义栈（该栈为String类型栈） Stack stack = new Stack(); 告警提示：“Stack is a raw type. References to generic type Stack<E> should be parameterized” 显示黄色提示，但并不影响程序正常工作和执行结果。 导致原因：集合类型没有明确定义泛型数据类型 也就是&...
Type safety: The method add(Object) belongs to the raw type List. References to generic type List＜E＞
l_degege的专栏
04-20 1302
1 java 报错如下 Type safety: The method add(Object) belongs to the raw type List. References to generic type List<E> should be parameterized 处理方法：List 应使用泛型 https://www.cnblogs.com/vonk/p/3824205.html
Java rowtypes告警
触动人生的博客
10-29 695
告警信息： Collection is a raw type. References to generic type Collection should be parameterized 解决方法： 这种集合类型 都会提示你 需要明确的定义泛型类 也就是这个内容 。。你可以加上 @SuppressWarnings("rawtypes") 注解就可以去掉警告
Java -- 泛型类型的继承规则（四）
To be or not to be, it's a question
09-17 6785
Java -- 泛型类型的继承规则（四） 使用泛型类时，我们有必要了解一些泛型类之间有关继承和子类型的准则。先看要使用的代码示例： class Basic { public void f() { System.out.println("f() int Basic"); } public void g() { System.out.println("g() int Ba...
去除警告 ArrayList is a raw type
qq_37248820的博客
08-26 4879
Eclipse里出现的警告： ArrayList is a raw type. References to generic type ArrayList should be parameterized 经查阅资料，和泛型有关。 原先的代码： ArrayList list1 = new ArrayList(); 会出现黄色的警告标志，内容如上所示。 正确的代码格式： ArrayList<String> list1 = new ArrayList<String>(); ...
The type List is not generic; it cannot be parameterized with arguments<T>
This Is Why We Coding
08-31 4443
今天写一个返回list的接口，出现了如下报错信息， The type List is not generic; it cannot be parameterized with arguments 原来是List的包导错了， 把awt改成util，问题解决。
java基础(十二 )-----Java泛型详解
最新发布
05-16
Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。 一、泛型的基本语法 在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值