java 泛型详解

最新推荐文章于 2023-07-25 14:00:00 发布
最新推荐文章于 2023-07-25 14:00:00 发布
阅读量7.7k 收藏 8
点赞数
分类专栏： java 文章标签： java 多态 泛型
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(20);
          
          point.setY(20);
          
            int  x=(Integer)point.getX();
          
            int  y=(Integer)point.getY();
          
          System.  out  .println( "x坐标："  +x);
          
          System.  out  .println( "y坐标："  +y);
     }
}

结果：
x坐标：20
y坐标：20


//小数接收

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(20.2);
          
          point.setY(20.2);
          
            double  x=(Double)point.getX();
          
            double  y=(Double)point.getY();
          
          System.  out  .println( "x坐标："  +x);
          
          System.  out  .println( "y坐标："  +y);
     }
}

结果：

x坐标：20.2
y坐标：20.2


//字符转接收

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, "北纬"  );
                //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坐标北纬


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, "北纬"  );
                //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坐标北纬

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,
魔都
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java 泛型详解
09-18
Java泛型详解，Java泛型详解，Java泛型详解，Java泛型详解
Java泛型详解
09-02
本文给大家汇总介绍了下java中的泛型的相关资料，包括引入泛型机制的原因，泛型类，泛型方法，泛型的实现以及泛型的注意事项，非常的详细，有需要的小伙伴可以参考下
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 5万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
模糊查询like两种使用方式
骑大马挎大刀
11-11 1717
1.Java中组装好 在Java中,把like的内容组装好,把这个内容传入sql语句. public List<Student> quaryByName1(String uname) { String name = "%" + uname +"%";//Java中组装好 return crudDao.quaryByName1(name); } <select id="quaryByName1" resultType="com.exa
Java泛型详解 | 最新、全面、详细和深入 | 2万字超全
xwshappy的博客
05-19 2838
深度记录Java后端开发，对Java的泛型特性进行详细的整理并且分享，最新版，本文参考了Java泛型详解，JVM相关内容，以及其他博主的优秀思想和个人实战理解而成，希望对大家有帮助！！！
java泛型详解
08-31
本文主要介绍了java泛型的相关知识。具有很好的参考价值。下面跟着小编一起来看下吧
深入理解java泛型详解
08-30
主要介绍了Java中的泛型详解，什么是泛型，作用以及基础实例等，喜欢的朋友可以参考
java泛型详解.pdf
10-02
java泛型详解.pdf
Java泛型详解（史上最全泛型知识详解）
最新发布
m0_70325779的博客
07-25 3009
泛型是在JDK5之后引入的一个新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式为用大白话来说，泛型就好比是给一个标签，通常情况下我们会在开发过程中或者个人学习或练习的过程中使用到泛型；就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就只能放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器(数组)写上什么泛型，就只能存放什么数据；这样就不会导致我们存取数据的混乱。这样就解决了我们引言中提到的问题，也就解释了什么是泛型。
java 之泛型详解
用键盘与世界交流
12-05 1736
关于泛型的详细介绍
PreparedStatement 使用like 模糊查询
Jason分享，共同进步
03-03 696
PreparedStatement 使用like 在使用PreparedStatement进行模糊查询的时候废了一番周折，以前一直都没有注意这个问题。一般情况下我们进行精确查询，sql语句类似：select * from table where name =?，然后调用 PreparedStatement的setString等方法给？指定值。那么模糊查询的时候应该怎么写呢？我首先尝试了：sele...
Java的泛型详解
peng的博客
05-30 7521
Java泛型是一种编程语言的特性，它允许类、接口和方法在定义时使用一个或多个类型参数，这些类型参数在调用时会被实际类型替换，从而增强了代码的重用性和类型安全性。通过使用泛型，我们可以编写出更加通用的代码，同时也可以减少代码中的强制类型转换操作，提高代码的可读性和可维护性。比如，我们可以使用泛型实现一个通用的容器类，该容器类可以存储任意类型的数据，并且在使用时可以保证数据类型的安全性。
Java之MySQL模糊查询（like）
江南好
04-03 5542
在Java中进行MySQL模糊查询有两种方式（通配符百分号%匹配0~n个任何字母。）： 第一种方式：直接在SQL语句中进行拼接,此时需要注意的是parm在SQL语句中需要用单引号拼接起来，注意前后单引号之间不能空格。 String sql = "select * from tb_user where uname like '%" + parm + "%'"; 第二种方式: 使用占位符，在占位符赋值时进行拼接。 String sql = "select * from tb_user where uname
Java泛型详细内容讲解
weixin_45428910的博客
01-05 521
Java泛型详细内容讲解
java基础(十二 )-----Java泛型详解
05-16
Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。 一、泛型的基本语法 在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值