精华内容
下载资源
问答
  • 泛型 java

    2013-06-22 14:17:25
    java泛型就记住一句话:"泛"就是不具体! public Class Generics{  ........ } T是不具体的类型。 完结。

    java的泛型就记住一句话:"泛"就是不具体!



    public Class Generics<T ob>{

     ........


    }


    T是不具体的类型。




    完结。

    展开全文
  • 在学习java的过程当中,我们就肯定会接触到java泛型,那么你知道java泛型是什么吗,有关java的使用方法又有哪些呢?今天小编就从java泛型的使用方法来了解一下java泛型这一知识。java泛型java泛型加通配符的用法...

    在学习java的过程当中,我们就肯定会接触到java泛型,那么你知道java泛型是什么吗,有关java的使用方法又有哪些呢?今天小编就从java泛型的使用方法来了解一下java泛型这一知识。

    java泛型—java泛型加通配符的用法

    泛型可以用””代表,任意类型的。

    解释:“”是泛型的默认值,可以被任意类型所代替,如:

    Listlist=newArayList();这个就定义了一个String类型的”泛型“集合,那么T的类型就是字符串。

    Listlist=newArayList();

    可以赋值给list:list.add(“StringBatch”);

    可以获取到list的值:list.get(0),结果就是”StringBatch“;

    这个时候T的类型也是String。也就是说T是动态的,可以被任意指定类型。

    3c5ca7799685fc80a8f0160373e2fe88.png

    java泛型引入方法

    java泛型的应用可以提高的代码的复用性,同时泛型提供了类型检查,减少了数据的类型转换,同时保证了类型安全。下面看一下,泛型如何保证了类型安全:

    Listlist=newArrayList();

    list.add(“abc”);

    list.add(newInteger(1));//可以通过编译

    for(Objectobject:list){

    System.out.println((String)object);//抛出ClassCastException异常

    }

    上面的代码会在运行时抛出ClassCastException,因为它尝试将一个Integer转换为String。接着,来看一下从java5开始,Collection的用法:

    Listlist=newArrayList<>();

    list.add(“abc”);

    //list.add(newInteger(1));//编译错误

    for(Stringstring:list){

    System.out.println(string);//无需任何强制类型转换

    }

    注意到,List的创建增加了类型参数String,因此只能向list添加String类型对象,添加其他对象会抛出编译异常;同样可以注意到,foreach循环不需要再添加任何强制类型转换,也就移除了运行时的ClassCastException异常。

    以上就是有关java泛型的所有内容,在学习java发型的过程当中,大家可以去网上搜索更多的视频,可以购买一些资料,当然大家也可以帮助我们

    推荐阅读

    在excel中移动和复制数据 excel中如何复制数据 | 文军营销如何快速收录 新站如何让百度快速收录 len函数的使用方法 excel表中如何用len函数 电脑快捷键使用大全 电脑常见快捷键有哪些 java泛型 Java泛型的入门知识产品...

    展开全文
  • 泛型Java”,一个美丽的hype

    千次阅读 2003-06-01 23:03:00
    泛型Java”,一个美丽的hype今天,Sun发布了J2SE 1.5新特性的一个原型实现版本。这个运行在J2SE 1.4上的插件提供了J2SE 1.5主要的几项新特性,例如类型安全的枚举、自动装箱/拆箱、增强的for循环等,当然还有最受...

    “泛型Java”,一个美丽的hype

    今天,Sun发布了J2SE 1.5新特性的一个原型实现版本。这个运行在J2SE 1.4上的插件提供了J2SE 1.5主要的几项新特性,例如类型安全的枚举、自动装箱/拆箱、增强的for循环等,当然还有最受关注的JSR-14,泛型。<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

    在试用了这些新特性之后,我终于对Java的泛型彻底失望了。首先,我们来看看泛型Java的经典用法:

    import java.util.*;

     

    public class UseGeneric

    {

        public static void main(String[] args)

        {

            Vector<Integer> vi = new Vector<Integer>();

            vi.add(new Integer(24));

            vi.add(35);

     

            for(Integer i : vi)

           {

               System.out.println(i);

           }

        }

    }

    上面的代码展示了泛型容器、自动装箱和增强for循环三项新特性。的确,从简化代码的角度来说,这些新特性有一定的帮助——当然,自动装箱其实不应该算一项很有意义的特性,只是因为Java固有的两套类型体制将intchar等原生类型与对象区分对待,所以在引入泛型容器时不得不采用自动装箱作为补救。

    将上面的代码编译后的class进行反编译,得到下列代码:

    import java.io.PrintStream;

    import java.util.Vector;

     

    public class UseGeneric

    {

     

        public UseGeneric()

        {

        }

     

        public static void main(String args[])

        {

            Vector vector = new Vector();

            vector.add(new Integer(24));

            vector.add(Integer.valueOf(35));

            Integer integer;

            for(SimpleIterator simpleiterator = vector.iterator(); simpleiterator.hasNext(); System.out.println(integer))

                integer = (Integer)simpleiterator.next();

     

        }

    }

    可以看到,所有的新特性都是在现有虚拟机的基础上实现的,没有任何新鲜感可言。的确如Joshua Bloch所说的,只不过是把以前由程序员写的一些代码转成由编译器来写。

    随后我试图实现一些略微高级的泛型技术,例如type traits。我写了下列代码:

    // General Traits

    class NumTraits<T>

    {

        public void doSomething()

        {

            System.out.println("General Traits");

        }

    }

     

    // Specialized Traits

    class NumTraits<Integer)

    {

        public void doSomething()

        {

            System.out.println("Traits for Integer");

        }

    }

    可惜,这段代码不能通过编译,编译器提示“duplicate class”。显然,编译器并没有把类型参数作为类名称的一部分,因此traits是不可能实现的了。当然,在成员方法中可以编写类似于模板特化(specialization)甚至偏特化(partial-specialization)的代码,但是下面的代码将证明这种东西毫无意义。

    public class Happy<T>

    {

        private T subject = new T();

     

        public <T> void happy()

        {

            subject.beHappy();

        }

     

        public static void main(String[] args)

        {

            Happy<Dog> o1 = new Happy<Dog>();

            o1.happy();

     

            Happy<Cat> o2 = new Happy<Cat>();

            o2.happy();

        }

    }

    这里的编译错误有两种。首先,“private T subject = new T();”这个语句不能编译,也许是我还没有找到实例化类型参数的正确方法吧。更重要的是,编译器提示“在java.lang.Object中找不到happy()方法”。由于Java采用“擦拭法”实现泛型,所有类型参数(除非显式声明超类或接口)都将被擦拭为Object,因此方法调用的契约仍然完全依赖对象系统来保证。换句话说,类似于模板特化之类的技巧不但在效率上毫无帮助,而且根本无法像C++那样依赖编译器进行比较高级的检查甚至编译期计算。TypelistSelect模板?还是不要想了吧。

    喏,这就是所谓的“泛型Java”。没有编译期动态绑定,没有type-traits,没有(真正的)模板特化,一切的问题依然扔给RTTI来完成。我更愿意把它叫做“Java with some type-safe containers”,而不是“Generic Java”。

    泛型Java,一个美丽的hype——如果你对它有太多期望的话。

    展开全文
  • java泛型

    2019-08-13 21:05:47
    java泛型泛型概述泛型的应用总结普通泛型通配符受限泛型Java泛型无法向上转型Java泛型接口Java泛型方法通过泛型方法返回泛型类型实例使用泛型统一传入的参数类型Java泛型数组Java泛型的嵌套设置 泛型概述 泛型的...

    泛型概述

    • 泛型的目的: 为了保证类型安全
    • “?” 是泛型的通配符
    • 我们用大写字母T、E、K、V等形式的参数常用于表示泛型形参,用以在实际使用中接受泛型的实参

    泛型的应用总结

    普通泛型

    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 GenericsDemo06 {
        public static void main(String[] args) {
            Point<String> p = new Point<String>(); // 里面的var类型为String类型
            p.setVar("it"); // 设置字符串
            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 GenericsDemo09 {
        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或String父类的泛型
            System.out.print(temp + "、");
        }
    }
    

    Java泛型无法向上转型

    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 GenericsDemo23 {
        public static void main(String[] args) {
            Info<String> i1 = new Info<String>(); // 泛型类型为String
            Info<Object> i2 = null;
            i2 = i1; // 这句会出错 incompatible types
        }
    }
    

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

    Java泛型方法

    class Demo {
        public <T> T fun(T t) { // 可以接收任意类型的数据
    
            return t; // 直接把参数返回
        }
    }
    
    public class GenericsDemo26 {
        public static void main(String[] args) {
            Demo d = new Demo(); // 实例化Demo对象
            String str = d.fun("汤姆"); // 传递字符串
            int i = d.fun(30); // 传递数字,自动装箱
            System.out.println(str); // 输出内容
            System.out.println(i); // 输出内容
        }
    }
    

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

    	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());
        }
    }
    

    Java泛型数组

    	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 + "、");
    	        }
    	    }
    	}
    

    Java泛型的嵌套设置

    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());
        }
    }
    
    展开全文
  • Java泛型

    2019-05-28 09:10:11
    Java泛型 Java泛型 Java泛型方法和泛型类支持程序员使用一个方法指定一组相关方法,或者使用一个类指定一组相关的类型。Java泛型(generics)是JDK 5 中引入的一个新特性,泛型提供了编译时类型安全检测机制,该机制...
  • Java 泛型

    千次阅读 2020-09-08 12:46:35
    Java 泛型 Java 泛型(generics)是 JDK 5 中引入的一个新特性,泛型提供了编译时类型安全检测机制,该机制允许程序在编译时检测到非法的类型。 泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数...
  • Java泛型深入理解

    万次阅读 多人点赞 2016-07-21 23:24:28
    Java泛型,包括Java泛型的实现,泛型擦除以及相关面试题,通配符理解
  • 一文搞定 Java泛型

    万次阅读 热门讨论 2019-11-12 14:08:09
    Java在1.5之后加入了泛型的概念。泛型,即“参数化类型”。泛型的本质是为了参数化类型(将类型参数化传递)(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程...
  • java泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型java中有很重要的地位...
  • java泛型详解

    万次阅读 多人点赞 2016-04-29 01:02:17
    1、什么是java泛型泛型Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。 2、...
  • Java 泛型Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。...
  • java泛型类指定多个泛型 从作为Java程序员的早期开始,我们都知道如何实例化和使用Collection对象。 实例化为具体类的List接口将如下所示。 List myArrayList = new ArrayList(); 如果myArrayList应该仅保存...
  • Java泛型基础

    2013-06-06 11:23:50
    什么是Java泛型 Java泛型的目的 使用Java泛型的好处 什么叫类型安全
  • 一、泛型的概念及作用1、泛型的概念Java中的泛型Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型...
  • 全面总结Java泛型

    2009-12-17 00:57:27
    • 全面总结Ja• 全面总结Java泛型v• 全面总结Ja• 全面总结Java泛型va泛型a泛型• 全面• 全面总结Java泛型• ... 全面总• 全面总结Java泛型结Java泛型• 全面总结Java泛型• 全面总结• 全面总结Java泛型Java泛型
  • 泛型是什么意思在这就不多说了,而Java泛型类的定义也比较简单,例如:public class Test{}。这样就定义了一个泛型类Test,在实例化该类时,必须指明泛型T的具体类型,例如:Test t = new Test();,指明泛型T的...
  • Java泛型擦除

    千次阅读 2019-11-16 13:44:53
    Java泛型(generics)是JDK 5中引入的一个新特性,泛型提供了编译时类型安全监测机制,该机制允许程序员在编译时监测非法的类型。使用泛型机制编写的程序代码要比那些杂乱地使用Object变量,然后再进行强制类型转换...
  • Java泛型教程

    千次阅读 2018-12-10 10:49:23
    Java 泛型概述 Java泛型环境设置 Java泛型通用类 Java泛型类型参数命名约定 Java泛型类型推断 Java泛型泛型方法 Java泛型多类型参数 Java泛型参数化类型 Java泛型原始类型 Java泛型有界类型参数 Java泛型多边界 ...
  • Java泛型以及使用泛型的好处

    千次阅读 2019-07-05 16:38:19
    Java泛型 Java泛型(generics)是JDK5中引入的一个新特性,泛型提供了编译时类型安全监测机制,该机制允许我们在编译时检测到非法的类型数据结构; 泛型的本质就是参数化类型,也就是所操作的数据类型被指定为一...
  • java泛型

    2017-05-29 16:24:23
    java中泛型java泛型本人第一次听”泛型”以为是一个新的朋友,但是看了下面的博客定义才知道,java中的泛型和C++中的模板属于同一个概念。 这里直接引用别人的博客,详情请看 链接
  • Java泛型 Java泛型的主要目的 Java泛型的主要目的是可以建立具有类型安全的数据结构,如链表、散列表等数据结构,最重要的一个优点就是:在使用这些泛型类建立的数据结构时,不必进行强制类型转换,既不要求进行运行...
  • Java 泛型详解

    2018-09-18 17:03:22
    Java泛型详解,Java泛型详解,Java泛型详解,Java泛型详解
  • Java泛型的本质

    千次阅读 2018-07-13 10:16:53
    二、Java泛型Java 泛型是Java1.5新增的特性,JVM并不支持。实现原理:Java源代码里面类型提供实现泛型功能,而编译后Class文件类型就变成原生类型(即类型被擦除掉),而在引用处插入强制类型转换以实现JVM对泛型的...
  • C++泛型 PK JAVA泛型

    千次阅读 2013-05-07 12:49:29
    Java SE在5.0后增加了泛型,而C++一直支持泛型,并有强大的STL。 C++的泛型其实就是一个模板生成器,缺点是代码膨胀,而JAVA泛型和C++采取的机制完全不同,它利用“擦除”的方式把类型参数替换为限定类型(无限定...
  • Java 5.0 泛型Java泛型接口

    万次阅读 2009-12-20 16:21:00
    // Java泛型接口interface Info24 { // 在接口上定义泛型 public T getVar(); // 定义抽象方法,抽象方法的返回值就是泛型类型}class InfoImp24 implements Info24 { // 定义泛型接口的子类 private T var; // 定义...
  • Java泛型教程导航

    2020-12-09 16:15:41
    Java 泛型概述 Java泛型环境设置 Java泛型通用类 Java泛型类型参数命名约定 Java泛型类型推断 Java泛型泛型方法 Java泛型多类型参数 Java泛型参数化类型 Java泛型原始类型 Java泛型有界...
  • Java 1.5 之前没有泛型,通常需要使用强制类型转换的方式将一种数据类型转换为另一种数据类型,这种转换要求开发者对实际参数的类型具有可预知性。对于强制类型转换错误的情况,编译器可能不会提示错误,但是在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,340
精华内容 22,536
关键字:

泛型java

java 订阅