精华内容
下载资源
问答
  • Java泛型入参的三种通配符使用

    千次阅读 2015-03-03 18:02:04
    Java泛型中有三种通配符 1、子类界定 2、超类界定 3、无限定 1、子类界定 package com.zjh.test; import java.io.Serializable; import com.zjh.test.model.Animal; import com.zjh.test.model.Horse; import ...

    Java泛型中有三种通配符

    1、<? extends xxx>子类界定

    2、<? super xxx>超类界定

    3、<?>无限定


    1、<? extends xxx>子类界定

    package com.zjh.test;


    import java.io.Serializable;

    import com.zjh.test.model.Animal;
    import com.zjh.test.model.Horse;
    import com.zjh.test.model.LittleHorse;

    public class Pair {

        public static <T extends Comparable & Serializable> Animal<T> getAnimal(
                T[] t) {
            T min = t[0];
            T max = t[0];
            for (int i = 1; i < t.length; i++) {
                T key = t[i];
                if (min.compareTo(key) > 0) {

                    min = key;
                }

                if (max.compareTo(key) < 0) {

                    max = key;
                }
            }
            Animal animal = new Animal<T>(min, max);

            return animal;
        }

        public static <T extends Comparable & Serializable> String getName(T t) {

            return t.toString();

        }

        public static String getHorseName(Animal<? extends Horse> a) {

            return a.getBigger().toString();

        }

        public static void main(String args[]) {

            // Animal animal = getAnimal(new String[] { "zjh", "zcx", "llj", "zst",
            // "lly" });
            // System.out.println(animal.toString());
            //
            // getName(animal);
            LittleHorse lh1 = new LittleHorse("zjh", 26);
            LittleHorse lh2 = new LittleHorse("llj", 27);
            Animal<LittleHorse> animal = new Animal<LittleHorse>(lh1, lh2);
            System.out.print(getHorseName(animal));

        }

    }



    package com.zjh.test.model;

    import java.io.Serializable;

    public class Animal<T extends Comparable & Serializable> {

        @Override
        public String toString() {
            // TODO Auto-generated method stub
            String s = "minName:" + t1.toString() + ",maxName:" + t2.toString();
            return s;
        }

        public T getBigger(){
            
            if(t1.compareTo(t2) > 0 ){
                
                return t1;
                
            }else{
                return t2;
            }
        }
        private T t1;
        private T t2;

        public Animal() {
            t1 = null;
            t2 = null;
        }

        public Animal(T t1, T t2) {

            this.t1 = t1;
            this.t2 = t2;
        }
        

    }

    2、超类限定

    与子类限定,直观解释来说,子类限定的通配符用来从入参中读取信息,而父类限定的通配符用来写入代码执行结果信息。

    从限定上来说,子类限定时,入参必须是限定类的子类泛型,而父类则是限定类的父类。


    public static Animal<? super LittleHorse> getHorse(LittleHorse[] t,
                Animal<? super LittleHorse> a) {
            LittleHorse min = t[0];
            LittleHorse max = t[0];
            for (int i = 1; i < t.length; i++) {
                LittleHorse key = t[i];
                if (min.compareTo(key) > 0) {

                    min = key;
                }

                if (max.compareTo(key) < 0) {

                    max = key;
                }
            }

            a.setT1(min);
            a.setT2(max);
            return a;
        }


        public static void main(String args[]) {

            // Animal animal = getAnimal(new String[] { "zjh", "zcx", "llj", "zst",
            // "lly" });
            // System.out.println(animal.toString());
            //
            // getName(animal);
    //        LittleHorse lh1 = new LittleHorse("zjh", 26);
    //        LittleHorse lh2 = new LittleHorse("llj", 27);
    //        Animal<LittleHorse> animal = new Animal<LittleHorse>(lh1, lh2);
    //        System.out.print(getHorseName(animal));
        
            LittleHorse lh1 = new LittleHorse("zjh", 26);
            LittleHorse lh2 = new LittleHorse("llj", 27);
            LittleHorse lh3 = new LittleHorse("zcx", 25);
            LittleHorse lh4 = new LittleHorse("zst",10);
            LittleHorse [] s = new LittleHorse[]{lh1,lh2,lh3,lh4};
            Horse t1 = new Horse();
            Horse t2 = new Horse();
            Animal<Horse> animal = new Animal<Horse>(t1, t2);
            //可以编译
            Animal<?> animal2 = getHorse(s,animal);
            System.out.println(animal2.getBigger().toString());
            LittleHorse lt1 = new LittleHorse();
            LittleHorse lt2 = new LittleHorse();
            Animal<LittleHorse> animal_test = new Animal<LittleHorse>(lt1, lt2);
        //无法编译
            //getHorse(animal_test);
        }


    3、<?>无限定




    展开全文
  • 网上还有关于null入参的讨论,我理解是由于null入参两个方法都可以,所以会选择更加特殊化的方法,也就是第二个func。 这里可以试一下,定义一个Object入参的方法,编译器会直接说与T data入参的方法歧义。 (T是一...

    重载的基本知识不在这里讨论了。

    重载的一个关键理论,如果方法名相同,参数个数、父类型、位置也相同,则调用更加特殊化一个方法。

    多余的没写,大家可以运行一下下面的代码,然后理解一下就ok了。

    public class TestMain {
    
    	public static void main(String[] args) {
    		TestMain t = new TestMain();
    		t.func("message");
    		t.func(new String("message"));
    		t.func(new Object());
    	}
    
    	protected <T> void func(T data) {
    		System.out.println("fun1" + data);
    	}
    
    	protected void func(String data) {
    		System.out.println("fun2" + data);
    	}
    
    }

    由于string和T相比较,带有String data入参的方法更加特殊化,所以当传入String参数的时候,会调用第2个func。

    网上还有关于null入参的讨论,我理解是由于null入参两个方法都可以,所以会选择更加特殊化的方法,也就是第二个func。

    这里可以试一下,定义一个Object入参的方法,编译器会直接说与T data入参的方法歧义。

    (T是一个泛型,没有具体说明类型,这里类似于Object类型)

    展开全文
  • package service; public interface TestGenericService { //方法一 单参数 String singleParam(User user);... //方法三 带有泛型参数 String genericTypeParam(PageReq<User> userReq); }
  • Java泛型作为方法入参类型匹配规则

    千次阅读 2020-01-19 15:54:10
    A的get()方法返回值为泛型,运行时期具体实例类型在编译时期是不清楚的,因此 B C 编译状态 运行时method()方法传入的实例 接口 接口 通过 可能即是B的实现类,也是C的实现类 ...

    测试代码

    public class Test {
    
        void test(A a) {
            method(a.get());
        }
    
        void method(C s) {
            // ...
        }
    
    }
    
    interface A {
        <E extends B> E get();
    }
    
    interface B {
        // ...
    }
    
    interface C {
        // ...
    }

    总结

    A的get()方法返回值为泛型,运行时期具体实例类型在编译时期是不清楚的,因此

    BC编译状态运行时method()方法传入的实例
    接口接口通过可能即是B的实现类,也是C的实现类
    接口通过可能即是B的实现类,也是C的子类
    接口通过可能即是B的子类,也是C的实现类
    不通过不可能即是B的子类,也是C的子类(Java类单继承原则)

     

     

     

     

     

     

     

     

    展开全文
  • JAVA泛型

    千次阅读 2019-09-19 21:15:47
    JAVA泛型1 概念2 泛型方法( )3 泛型类 4 类型通配符 ?5 类型擦除 1 概念 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型,也就是说所操作的数据类型被指定...

    1 概念

    泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。比如我们要写一个排序方法,能够对整型数组、字符串数组甚至其他任何类型的数组进行排序,我们就可以使用 Java 泛型。

    2 泛型方法( )

    你可以写一个泛型方法,该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型,编译器适当地处理每一个方法调用。

    // 泛型方法 printArray
    public static <E> void printArray(E[] inputArray) {
    	for (E element : inputArray) {
    		System.out.printf("%s ", element);
    	}
    }
    
    1. <? extends T>表示该通配符所代表的类型是 T 类型的子类。
    2. <? super T>表示该通配符所代表的类型是 T 类型的父类。

    3 泛型类

    泛型类的声明和非泛型类的声明类似,除了在类名后面添加了类型参数声明部分。和泛型方法一样,泛型类的类型参数声明部分也包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数,这些类被称为参数化的类或参数化的类型。

    public class Box<T> {
    	private T t;
    	public void add(T t) {
    		this.t = t;
    	}
    	public T get() {
    		return t;
    	}
    }
    

    4 类型通配符 ?

    类 型 通 配 符 一 般 是 使 用 ? 代 替 具 体 的 类 型 参 数 。 例 如 List<?> 在 逻 辑 上 是 List,List 等所有 List<具体类型实参>的父类。

    5 类型擦除

    Java 中的泛型基本上都是在编译器这个层次来实现的。在生成的 Java 字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数,会被编译器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的 List和 List等类型,在编译之后都会变成 List。JVM 看到的只是 List,而由泛型附加的类型信息对 JVM 来说是不可见的。类型擦除的基本过程也比较简单,首先是找到用来替换类型参数的具体类。这个具体类一般是 Object。如果指定了类型参数的上界的话,则使用这个上界。把代码中的类型参数都替换成具体的类。

    注:以上内容来源网络收集和归纳,如有错误请不吝赐教。

    展开全文
  • java泛型

    2021-01-24 19:08:11
    java泛型学习 下面是我之前学习时候记的笔记,回过头来自己都看不明白。 学习泛型: 1、为什么需要泛型,方法体意义相同,不同类型入参,数据集从运行时错误提前到编译时错误,强转。 2、泛型方法和泛型类泛型接口,...
  • Java泛型

    2021-08-22 16:14:48
    梳理Java泛型使用及实现原理
  • java泛型总结

    2019-04-09 17:19:51
    深入理解java泛型,包括类名泛型的定义,方法泛型定义,泛型的返回
  • java 泛型

    千次阅读 2019-01-08 19:08:38
    java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。 泛型经常被称为参数化类型,它能够像方法一样接受不同类型的参数。 ...
  • 1.泛型public interface Demo {void test(T t);}public class DemoImpl ...1@Overridepublic void test(User user) {// TODO Auto-generated method stub}}java泛型实现是基于类型擦除,编译之后没有具体的类...
  • Java泛型遇到多态与Java泛型边界

    千次阅读 2017-04-20 15:49:42
    说明: 今天,继续学姐java编程思想-泛型这一章的时候,对于通配符的理解不够明白,于是又网上查了些资料,发现一篇写的很好的文章,在此记录学习一下
  • Java 泛型

    2021-06-28 16:19:11
    Java 泛型总结为什么要用泛型泛型类和泛型接口泛型类:泛型接口:注意实现泛型接口的类有两种实现方法:泛型方法:普通方法:泛型方法:限定类型变量泛型中的约束和局限性不能用基本类型实例化类型参数运行时类型查询...
  • Java泛型总结

    2019-10-15 20:06:48
    文章目录泛型总结Java 泛型泛型方法1. 泛型方法的基本用法2. 类中的泛型方法3. 泛型方法与可变参数4. 静态方法与泛型5. 泛型方法总结泛型泛型接口类型通配符泛型上下边界泛型的实际应用实现...泛型的本质是...
  • ![图片说明](https://img-ask.csdn.net/upload/201601/04/1451863985_371743.png) !...!...!...!... public static final String httpsRead( ... return httpsRead(url, urlMethod, requestProperty, urlParamToString(urlParam));...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,974
精华内容 10,389
关键字:

java泛型入参

java 订阅