正文 

当前位置： 首页 > IT > java教程

java泛型(代码片段)

wangyuyang1016 wangyuyang1016     2022-12-13     674

关键词：

Java 泛型技术产生的原因：

package cn.mldn.utli;

class Point 
    private Object x ;
    private Object y ;
    public void setX( Object x ) 
        this.x = x ;
    
    public void setY( Object y ) 
        this.y = y ;
    
    public Object getX() 
        return x ;
    
    public Object getY() 
        return y ;
    


public class TestDemo 

    public static void main(String[] args) 
        Point p = new Point() ;
        p.setX(10);
        p.setY(20);
        
        int x = (Integer) p.getX();
        int y = (Integer) p.getY();
        System.out.println(x + y) ;

 

　上述的程序中，利用Point类存储整型数据，利用Object对象进行存储，向下转型为int型

public class TestDemo 

    public static void main(String[] args) 
        Point p = new Point() ;
        p.setX(10.1);
        p.setY(20.2);
        
        double x = (Double) p.getX();
        double y = (Double) p.getY();
        System.out.println(x + y) ;

 

　上述代码则是利用Point类存储小数，利用Object对象进行存储，向下转型为Double型

public class TestDemo 

    public static void main(String[] args) 
        Point p = new Point() ;
        p.setX("上海");
        p.setY("南京");
        
        String x = (String) p.getX();
        String y = (String) p.getY();
        System.out.println(x + y) ;

 

  上述代码则是利用Point类存储String数据内容，利用Object对象进行存储，向下转型为String型

————————————————

上述的三段代码，均利用Point类进行三种不同类型的多类型同对象的存储，而Point类中是利用Object进行存储的，于是可以在调用处通过向下转型的方式将Object转为int/double/String等类型数据（装箱/拆箱）。

 

泛型技术：类在定义的时候可以只用一个标记，此标记表示类中属性或方法参数的类型标记，在使用的时候才动态的设置：

package cn.mldn.utli;
// 此时设置的T在Point定义上只表示一个标记，在使用的时候需要为其设置具体额类型
class Point<T>   // Type = T , 是一个类型
    private T x ; // x的属性类型不明，有Point在使用时动态使用
    private T y ;
    public void setX( T x ) 
        this.x = x ;
    
    public void setY( T y ) 
        this.y = y ;
    
    public T getX() 
        return x ;
    
    public T getY() 
        return y ;

 

　　在使用Point类的时候才取设置的内容，也就是设置了类中属性的类型；

public class TestDemo 

    public static void main(String[] args) 
        Point<String> p = new Point<String>() ;
　　　　　// 利用的就是包装类的自动装箱功能
        p.setX("上海");
        p.setY("南京");
        // 由于泛型的特性，使用的时候动态的设置Point接收的类型为String类型，所以返回的也是String类型就不用在转型了
        String x = p.getX();
        String y = p.getY();
        System.out.println(x + y) ;

 

  使用泛型之后，所有类中属性的类型都是动态设置的，而所有使用泛型标记的方法参数类型也都是会发生改变。由此避免了向下转型的安全问题隐患。

  如果是采用泛型，那么它能够接受的数据类型只能是基本数据类型的包装类表示，不可以引用类型！

 

#  在使用泛型类或者接口的时候，没有设置泛型的具体类型，会报错。（如果在没有设置泛型的具体类型的时候，所有泛型使用Object描述泛型的数据类型）

#  在JDK1.7后可以简化泛型：可以将实例化的泛型具体类型的定义省略

 

——————————

泛型通配符：

package cn.mldn.utli;

class Message<T>   
    private T msg ;
    public void setMsg(T msg) 
        this.msg = msg ;
    
    public T getMsg() 
        return msg ;
    


public class TestDemo 

    public static void main(String[] args) 
        Message<String> m = new Message<> ();
        m.setMsg("Hello World!");
        fun(m) ;  // 引用传递
    
    public static void fun(Message<String> temp) 
        System.out.println(temp.getMsg()) ;

 

  上述代码为Message类设置的是一个String的泛型对象；

　　如果我们需要一个可以接收任何类型的泛型数据，则可以使用 “？” 符号代替 "<>" 定义类型；如此以来则可以接收任何的泛型，但是不可以更改，只可以取出。

public class TestDemo 

    public static void main(String[] args) 
        Message<String> m = new Message<> ();
        m.setMsg("Hello World!");
        fun(m) ;  // 引用传递
    
    public static void fun(Message<?> temp) 
        System.out.println(temp.getMsg()) ;

 

　　在 “？”的通配符上 还有两个子通配符：

　　　　~ ？ extends 类：设置泛型上限，可以在泛型声明上和方法参数上使用；

　　　　　　　　|-- ？ extends  Number ： 意味着可以设置Number或者子类的泛型

　　　　~ ？ super 类： 设置泛型的下限，方法参数上使用；

　　　　　　　　|-- ？super String ： 意味只能设置String或者它的父类（Object）

 

泛型接口：

　定义泛型接口

interface Message<T>  //设置泛型接口
    public void print(T t) ;

 

在接口上定义其相应的子类，定义子类主要有两种形式：

形式一：在子类上继续设置泛型

package cn.mldn.utli;

interface Message<T>  //设置泛型接口
    public void print(T t) ;

class MessageImpl<T> implements Message<T> 
    public void print(T t) 
        System.out.println(t) ;
    


public class TestDemo 

    public static void main(String[] args) 
        Message<String> msg = new MessageImpl<String>() ; // 向上转型实例化
        msg.print("Hello World!");

形式二：在子类不设置泛型，而父接口明确定义一个泛型类型

package cn.mldn.utli;

interface Message<T>  //设置泛型接口
    public void print(T t) ;

class MessageImpl implements Message<String> 
// 接口泛型的第二种定义方法，直接在实现接口的接口处明确一个泛型类型；由此实例化的时候不用设置泛型的具体类型
    public void print(String t) 
        System.out.println(t);        
    
    


public class TestDemo 

    public static void main(String[] args) 
        Message msg = new MessageImpl() ; // 向上转型实例化
        msg.print("Hello World!");

 

-------------------------------

泛型方法：

　　泛型方法不一定定义在支持泛型的类中。

泛型方法的定义：

package cn.mldn.utli;

public class TestDemo 

    public static void main(String[] args) 
        String str = fun("Hello,World!") ;
        System.out.println(str);
        
    // T 泛型类型由传入的参数类型决定
    public static <T> T fun(T t) 
        return t;

 

————————

泛型总结：

　　泛型特性解决的是向下转型所带来的安全隐患，其核心的组成就是在声明类或接口中不用设置具体的参数类型；

　　？ 符号可以接收任意的泛型类型，但是只能够取出，不能够修改

~~~~

java泛型(代码片段)

查看详情

java泛型介绍(代码片段)

查看详情

java_泛型笔记(代码片段)

文章目录Java_泛型简介Java_泛型的概念Java_为什么存在泛型Java_自定义泛型结构Java_泛型的声明Java_泛型的实例化Java_泛型类Java_泛型方法Java_泛型在继承上的体现Java_通配符的使用Java_泛型简介集合容器类在设计阶段/声明阶段不能确... 查看详情

java泛型(代码片段)

文章目录前言一、泛型1.泛型的好处2.泛型的本质3.泛型类4.泛型接口5.泛型方法5.限定类型变量6.泛型的约束和局限性7.通配符类型总结前言提示：以下是本篇文章正文内容，下面案例可供参考一、泛型1.泛型的好处1.适用于... 查看详情

java泛型(代码片段)

Java泛型技术产生的原因：packagecn.mldn.utli;classPointprivateObjectx;privateObjecty;publicvoidsetX(Objectx)this.x=x;publicvoidsetY(Objecty)this.y=y;publicObjectgetX()returnx;publicObjectgetY()returny; 查看详情

java泛型(代码片段)

泛型01:packageCharTest;importjava.util.ArrayList;@SuppressWarnings("all")publicclassGeneric02publicstaticvoidmain(String[]args)ArrayList<Dog>arrayList=newArrayList<Dog>();a 查看详情

java泛型是什么？一文带你吃透泛型(代码片段)

文章目录1.Java泛型2.泛型类3.泛型接口4.泛型方法5.泛型集合Java编程基础教程系列1.Java泛型Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。其主要的形式有泛型类，泛型接口和泛型方法。泛型概... 查看详情

java-泛型-3(代码片段)

泛型类publicclassTest<TextendsNumber>privateTkey;publicTest(Tkey)this.key=key;publicTgetKey()returnkey;publicvoidsetKey(Tkey)this.key=key;泛型接口publicinterfaceGenerator<T>publi 查看详情

java-----泛型(代码片段)

泛型1.泛型前言2.泛型接口3.泛型方法1.泛型前言泛型的本质是参数化类型，参数化类型：所操作的数据类型被指定为一个参数，将类型由原来的具体的类型参数化//泛型中：T\\E\\K\\Vimportjava.util.Arrays;//可存在多个泛... 查看详情

java-泛型-3(代码片段)

泛型类publicclassTest<TextendsNumber>privateTkey;publicTest(Tkey)this.key=key;publicTgetKey()returnkey;publicvoidsetKey(Tkey)this.key=key;泛型接口publicinterfaceGenerator<T>publicTfun();泛 查看详情

java基础总结三（泛型异常）(代码片段)

文章目录Java基础总结三（泛型、异常）泛型泛型的创建泛型类泛型接口泛型方法类型擦除泛型的协变与逆变异常异常体系异常处理Java基础总结三（泛型、异常）泛型泛型的创建泛型类我们最常用泛型的地方就是... 查看详情

java泛型(代码片段)

E-Element(在集合中使用,因为集合中存放的是元素)示例:publicclass泛型Epublicstaticvoidmain(String[]args)Integer[]stringArray=1,2,3,4,5,6,7;printArray(stringArray);/****/publicstatic<E>voidprintArray(E[]inputArray)/ 查看详情

java--泛型--泛型接口&泛型方法(代码片段)

泛型接口  packagecom.model.fanxing;/***@Description:测试类*@Author:张紫韩*@Crete2021/6/3022:14*泛型接口和实现类*1.泛型接口的实现类，是一个泛型类，那么要保证实现接口的泛型类的反省表示中要包含泛型接口的泛型标识*2.泛型接口... 查看详情

java--泛型复习(代码片段)

泛型复习泛型的生命周期泛型类泛型接口泛型方法关于泛型方法的总结泛型通配符有限制的通配符泛型的生命周期Java中的泛型，只在编译阶段有效，在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除... 查看详情

java泛型概述与应用(代码片段)

文章目录泛型1.1泛型概述1.2泛型类1.2.1示例代码1.3泛型方法1.3.1示例代码1.4泛型接口1.4.1示例代码1.5类型通配符1.5.1类型通配符:<?>1.5.2类型通配符上限:<?extends类型>1.5.3类型通配符下限:<?super类型>1.5.4泛型通配符的使用... 查看详情

java泛型总结(代码片段)

一：什么是泛型？泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的... 查看详情

java重点--泛型(代码片段)

文章目录💖泛型的概念✨使用泛型的好处与弊端✨定义和使用含有泛型的类✨定义和使用含有泛型的方法✨定义和使用含有泛型的接口✨泛型的通配符✨通配符的高级使用--受限泛型✨斗地主小案例💖泛型的概念泛型是... 查看详情

java-泛型-2(代码片段)

什么是泛型泛型是在jdk1.5后引入的一种特性，用于规定限制一种类型的。例如List,publicvoidTgetMethod()这种就是泛型适用范围适用于规定返回值类型，参数类型，不确定继承类型等常常用于抽象封装类，例如常用CRUD封... 查看详情