精华内容
下载资源
问答
  • 2019独角兽企业重金招聘...泛型类单参数泛型类:public class Rectangle {private T width;private T height;public Rectangle(T width, T height) {this.width = width;this.height = height;}public T getWidth()...

    2019独角兽企业重金招聘Python工程师标准>>>

    c2a5127ccc75cf6de0dea2728c32f9a1.png

    泛型类

    单参数泛型类:

    public class Rectangle {

    private T width;

    private T height;

    public Rectangle(T width, T height) {

    this.width = width;

    this.height = height;

    }

    public T getWidth() {

    return width;

    }

    public void setWidth(T width) {

    this.width = width;

    }

    public T getHeight() {

    return height;

    }

    public void setHeight(T height) {

    this.height = height;

    }

    public void showDetails(){

    System.out.println("the rectangle, width is " + this.width + " height is " + this.height);

    }

    }

    通过public class Rectangle {}定义泛型类,在实例化该类时,必须指明泛型T的具体类型,

    例如:Rectangle rectangle = new Rectangle();,指明泛型T的类型为String。

    泛型通配符:

    我们知道Ingeter是Number的一个子类,同时在特性章节中我们也验证过Generic与Generic实际上是相同的一种基本类型。那么问题来了,在使用Generic作为形参的方法中,能否使用Generic的实例传入呢?在逻辑上类似于Generic和Generic是否可以看成具有父子关系的泛型类型呢?

    为了弄清楚这个问题,我们使用Generic这个泛型类继续看下面的例子:

    public void showKeyValue1(Generic obj){

    Log.d("泛型测试","key value is " + obj.getKey());

    }

    Generic gInteger = new Generic(123);

    Generic gNumber = new Generic(456);

    showKeyValue(gNumber);

    // showKeyValue这个方法编译器会为我们报错:Generic

    // cannot be applied to Generic

    // showKeyValue(gInteger);

    通过提示信息我们可以看到Generic不能被看作为Generic的子类。由此可以看出:同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

    回到上面的例子,如何解决上面的问题?总不能为了定义一个新的方法来处理Generic类型的类,这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic和Generic父类的引用类型。由此类型通配符应运而生。

    我们可以将上面的方法改一下:

    public void showKeyValue1(Generic> obj){

    Log.d("泛型测试","key value is " + obj.getKey());

    }

    类型通配符一般是使用?代替具体的类型实参,注意了,此处’?’是类型实参,而不是类型形参 。重要说三遍!此处’?’是类型实参,而不是类型形参 ! 此处’?’是类型实参,而不是类型形参 !再直白点的意思就是,此处的?和Number、String、Integer一样都是一种实际的类型,可以把?看成所有类型的父类。是一种真实的类型。

    可以解决当具体类型不确定的时候,这个通配符就是 ?  ;当操作类型时,不需要使用类型的具体功能时,只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

    多参数泛型类:

    /**

    * Created with IntelliJ IDEA.

    * Description:

    * User: zhubo

    * Date: 2017-11-29

    * Time: 17:24

    */

    public class Container {

    private K key;

    private V value;

    public Container(K key, V value) {

    this.key = key;

    this.value = value;

    }

    public K getKey() {

    return key;

    }

    public void setKey(K key) {

    this.key = key;

    }

    public V getValue() {

    return value;

    }

    public void setValue(V value) {

    this.value = value;

    }

    }

    通过public class Container {}定义泛型类,在实例化该类时,必须指明泛型K、V的具体类型,

    例如:Container c1 = new Container("name", "Messi");,指明泛型K的类型为String,泛型V的类型为String。

    泛型接口

    public interface Calculator {

    public T and(T a , T b);

    }

    public class CalculatorInteger implements Calculator {

    @Override

    public Integer and(Integer a, Integer b) {

    return a + b;

    }

    }

    通过public interface Calculator {}定义泛型接口,在实现该接口时,必须指明泛型T的具体类型,

    例如:public class CalculatorInteger implements Calculator{},指明泛型T的类型为Integer,实例化该类时无需制定泛型类型。

    泛型方法

    public class Generic {

    public T getObject(Class c){

    T t = null;

    try {

    t = c.newInstance();

    } catch (Exception e){

    e.printStackTrace();

    }

    return t;

    }

    public static void main(String[] args) {

    try{

    Generic generic = new Generic();

    Object obj = generic.getObject(Class.forName("com.qf58.supplier.entity.others.Generic"));

    }catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    泛型方法说明:

    219cc1419b3b6f57a8bafd504552ba47.png

    在调用泛型方法的时候,在不指定泛型的情况下,泛型变量的类型为该方法中的几种类型的同一个父类的最小级,直到Object。在指定泛型的时候,该方法中的几种类型必须是该泛型实例类型或者其子类。

    在初始化泛型类的时候,不指定泛型的时候,泛型的类型为Object,就比如ArrayList中,如果不指定泛型,那么这个ArrayList中可以放任意类型的对象。

    泛型的好处是在编译的时候进行类型安全检查,并且所有的强制转换都是自动和隐式的,以提高代码的重用率。

    泛型方法例子:

    /**

    * Created with IntelliJ IDEA.

    * Description:

    * User: zhubo

    * Date: 2017-11-29

    * Time: 19:49

    */

    public class Generate {

    private T key;

    public Generate(T key) {

    this.key = key;

    }

    public T getKey() {

    return key;

    }

    public void setKey(T key) {

    this.key = key;

    }

    }

    /**

    * Created with IntelliJ IDEA.

    * Description:

    * User: zhubo

    * Date: 2017-11-29

    * Time: 15:27

    */

    public class DoMain {

    public static void main(String[] args) {

    Generate generate = new Generate<>(123);

    DoMain domain = new DoMain();

    Integer integer = domain.showKeyName(generate);

    System.out.println(integer);

    domain.showKeyValue2(generate);

    }

    //首先在public与返回值之间的必不可少,这表明这是一个泛型方法,并进行泛型的T的类型声明

    //这个T可以出现在这个泛型方法的任意位置

    public void showD(T e){

    }

    //泛型的数量也可以为任意多个

    public K show(T t,K k){

    K kk = null;

    return kk;

    }

    public void showList(List list){

    }

    public T showKeyName(Generate container){

    System.out.println("container key :" + container.getKey());

    T test = container.getKey();

    return test;

    }

    public void showKeyValue(Generate obj){

    System.out.println("key value is " + obj.getKey());

    }

    public void showKeyValue1(Generate obj){

    }

    public void showKeyValue2(Generate> obj){

    System.out.println("key value is " + obj.getKey());

    }

    }

    泛型方法与可变参数

    再看一个泛型方法和可变参数的例子:

    public void printMsg(T ... args){

    for(T t : args){

    System.out.println(t);

    }

    }

    public static void main(String[] args) {

    DoMain domain = new DoMain();

    domain.printMsg("111",222,"aaa","234.5");

    }

    静态方法与泛型

    静态方法有一种情况需要注意一下,那就是在类中的静态方法使用泛型:静态方法无法访问类上定义的泛型;如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上。

    即:如果静态方法要使用泛型的话,必须将静态方法也定义成泛型方法 。

    /**

    * Created with IntelliJ IDEA.

    * Description:

    * User: zhubo

    * Date: 2017-11-29

    * Time: 21:10

    */

    public class StaticGenerator {

    /**

    * 如果在类中定义使用泛型的静态方法,需要添加额外的泛型声明(将这个方法定义成泛型方法)

    * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。

    * 如:public static void show(T t){..},此时编译器会提示错误信息:

    * "StaticGenerator cannot be refrenced from static context"

    */

    public static void show(T t){

    }

    }

    泛型方法总结

    泛型方法能使方法独立于类而产生变化,以下是一个基本的指导原则:

    无论何时,如果你能做到,你就该尽量使用泛型方法。也就是说,如果使用泛型方法将整个类泛型化,那么就应该使用泛型方法。另外对于一个static的方法而已,无法访问泛型类型的参数。所以如果static方法要使用泛型能力,就必须使其成为泛型方法。

    转载于:https://my.oschina.net/LucasZhu/blog/1581748

    展开全文
  • 我对泛型方法的显式类型参数有问题.我知道我可以这样做:Foo.function();假设有一个void function() {...}在Foo类中的函数.确切的问题是:>我想下载一些内容(Android版附Ion)>这些内容类似(文章,BlogArticle,...

    我对泛型方法的显式类型参数有问题.我知道我可以这样做:

    Foo.function();

    假设有一个

    void function() {...}

    在Foo类中的函数.确切的问题是:

    >我想下载一些内容(Android版附Ion)

    >这些内容类似(文章,BlogArticle,…),都实现了ContentItem接口

    >目前下载如下:

    例如新闻

    private void downloadNews() {

    Ion.with(this)

    .load(URL_NEWS)

    .as(new TypeToken>(){})

    .setCallback(new FutureCallback>() {

    @Override

    public void onCompleted(Exception e, List result) {

    // do something with result

    }

    });

    }

    如果我想下载博客文章,我必须更改网址和文章类(对于BlogArticle).

    我试图制作这样的通用函数:

    private void download(String url) {

    Ion.with(this)

    .load(url)

    .as(new TypeToken>(){})

    .setCallback(new FutureCallback>() {

    @Override

    public void onCompleted(Exception e, List result) {

    // do something with result

    }

    });

    }

    并调用该函数

    this.download(url);

    没关系,编译好.跑完后我得到了

    java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.my.packagename.model.ContentItem

    问题是它没有使用显式类将Json映射到pojo.

    你能建议我一个通用的解决方案吗?

    展开全文
  • 其中JDK1.5中泛型是一件非常重要的实现技术,它可以帮助我们解决程序的参数转换问题。本文为大家详细介绍一下泛型。一、泛型问题的引出假设需要你定义一个描述坐标的程序类Point,需要提供两个属性x、y。对于这两个...

    从JDK1.5以后引入了三大常用新特性:泛型、枚举(enum)、注解(Annotation)。其中JDK1.5中泛型是一件非常重要的实现技术,它可以帮助我们解决程序的参数转换问题。本文为大家详细介绍一下泛型。

    一、泛型问题的引出

    假设需要你定义一个描述坐标的程序类Point,需要提供两个属性x、y。对于这两个属性的内容可能有如下选择:

    1. x = 10、y = 20 ;

    2. x = 10.1、y = 20.1 ;

    3. x = 东经80度、y = 北纬20度

    那么现在首先要解决的问题就是Point类中的x、y的属性类型问题,此时需要保存的有int、double、String,所以在java中只有一种类型可以保存所有类型:Object型。  例:

    class Point {                               //按照题目要求定义一个Point的类

    private Object x ;                      //定义Object对象,接收不同类型的参数

    private Object y ;                      //定义Object对象,接收不同类型的参数

    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 Test {

    public static void main(String[] args){

    // 设置数据

    Point p = new Point() ;

    p.setX(10); // 自动装箱并且向上转型为Object

    p.setY(20);

    // 取出数据

    int x = (Integer) p.getX() ; // 强制向下转型为Integer并且自动拆箱

    int y = (Integer) p.getY() ;

    System.out.println("x = " +x+",y = "+y);

    }

    }

    当传入字符串数据类型时

    public class Test {

    public static void main(String[] args) {

    // 设置数据

    Point p = new Point() ;

    p.setX("东经80度");

    p.setY("北纬20度");

    // 取出数据

    String x = (String) p.getX() ;

    String y = (String) p.getY() ;

    System.out.println("x = " +x+",y = "+y);

    }

    }

    当传入的是浮点数的时候

    public calss Test {

    public static void main(String[] args) {

    //设置数据

    Point p = new Point();

    p.setX(10.1);// 自动装箱并且向上转型为Object

    p.setY(20.1);

    // 取出数据

    double x = (Double) p.getX() ;// 强制向下转型为Double并且自动拆箱

    double y = (Double) p.getY() ;

    System.out.println("x = " +x+",y = "+y);

    }

    }

    通过以上的实例,我们发现有两个不妥的地方:

    不管是哪种类型的传入,必须保证x和y的类型一致,如果在主方法中传入数据时将x传double类型,y传String类型,则在编译时不会报错,但是在运行是会出现ClassCastException错误。(ClassCastException是指两个没有关系的对象进行强制转换的异常)

    因此引入泛型

    二、泛型类的语法和基本使用

    泛型指的就是在类定义的时候并不会设置类中的属性或方法中的参数的具体类型,而是在类使用时再进行定义。如果要想进行这种泛型的操作,就必须做一个类型标记的声明。  例:  单参数参数泛型基本语法

    class MyClass {

    T value1;

    }

    多参数泛型

    class MyClass {

    T value1;

    E value2;

    }

    泛型命名规则

    尖括号 <> 中的 T 被称作是类型参数,用于指代任何类型。实际上这个T你可以任意写,但出于规范的目的,Java还是建议我们用单个大写字母来代表类型参数。常见的如:

    T 代表一般的任何类。

    E 代表 Element 的意思,或者 Exception 异常的意思。

    K 代表 Key 的意思

    V 代表 Value 的意思,通常与 K 一起配合使用。

    S 代表 Subtype。

    使用泛型类

    //定义一个泛型参数的类

    class MyClass {

    T value1;

    }

    //主类中的使用

    public class Test {

    public static void main(String[] args) {

    MyClass myClass1 = new MyClass();

    MyClass myClass2 = new MyClass();

    }

    }

    class MyClass {

    T value1;

    E value2;

    }

    public class Test {

    public static void main(String[] args) {

    MyClass myClass1 = new MyClass();

    }

    }

    注意:泛型只能接受类,所有的基本数据类型必须使用包装类!

    现在在用我们的泛型类来实现第一个Point类的例子

    package www.bit.java.test;

    class Point { // T表示参数,是一个占位的标记;如果有多个泛型就继续在后面追加

    private T x ;

    private T y ;

    public T getX() {

    return x;

    }

    public void setX(T x) {

    this.x = x;

    }

    public T getY() {

    return y;

    }

    public void setY(T y) {

    this.y = y;

    }

    }

    public class TestDemo {

    public static void main(String[] args) {

    // 设置数据

    Point p = new Point() ; // JDK1.5的语法

    p.setX("东经80度");

    p.setY("北纬20度");

    // 取出数据

    String x = p.getX() ; // 避免了向下转型

    String y = p.getY() ;

    System.out.println("x = " +x+",y = "+y);

    }

    }

    注意:Point< String > p = new Point< String >() ;  此行语句在JDK1.7以后可以这么写:Point< String > p = new Point<>()  当开发的程序可以避免向下转型,也就意味着安全隐患被消除了。尽量不要去使用向下转型。  泛型的出现彻底改变了向下转型的需求。引入泛型后,如果明确设置了类型,则为设置类型;如果没有设置类型,则默认为Object类型。

    三、泛型方法

    class MyClass{

    //返回值类型为void,参数类型为T

    public void testMethod1(T t) {

    System.out.println(t);

    }

    //返回值类型为T,参数类型也为T

    pubic T testMethod2(T t) {

    return t;

    }

    }

    泛型方法与泛型类稍有不同的地方是,类型参数也就是尖括号那一部分是写在返回值前面的。 中的 T 被称为类型参数,而方法中的 T 被称为参数化类型,它不是运行时真正的参数。

    泛型方法与泛型类共存  例:

    class MyClass{

    public void testMethod1(T t) {

    System.out.println(t);

    }

    public T testMethod2(T t) {

    return t;

    }

    }

    public class Test {

    public static void main(String[] args) {

    MyClass myClass = new MyClass<>();

    myClass.testMethod1("hello 泛型类");

    Integer i = myClass.testMethod2(100);

    System.out.println(i);

    }

    }

    上面代码中,MyClass 是泛型类,testMethod1 是泛型类中的普通方法,而 testMethod2 是一个泛型方法。而泛型类中的类型参数与泛型方法中的类型参数是没有相应的联系的,**泛型方法始终以自己定义的类型参数为准**。

    泛型类的实际类型参数是 String,而传递给泛型方法的类型参数是 Integer,两者不相干。但是,为了避免混淆,如果在一个泛型类中存在泛型方法,那么两者的类型参数最好不要同名。

    因此,上述代码这样写比较好

    class MyClass{

    public void testMethod1(T t) {

    System.out.println(t);

    }

    public E testMethod2(E e) {

    return e;

    }

    }

    四、通配符

    在程序类中追加了泛型的定义后,避免了ClassCastException的问题,但是又会产生新的情况:参数的统一问题。  例:

    package www.bit.java.test;

    class Message {

    private T message ;

    public T getMessage() {

    return message;

    }

    public void setMessage(T message) {

    this.message = message;

    }

    }

    public class TestDemo {

    public static void main(String[] args) {

    Message message = new Message() ;

    message.setMessage("hello world");

    fun1(message);

    fun2(message);

    }

    //

    public static void fun1(Message temp){

    System.out.println(temp.getMessage());

    }

    //注意这里形参的泛型传的是Interage,那么上面传的是String类,调用之后就会出错

    public static void fun2(Message temp){

    SyStem.out.println(temp.getMessage());

    }

    }

    我们需要的解决方案:可以接收所有的泛型类型,但是又不能够让用户随意修改。这种情况就需要使用通配符”?”来处理。  例:使用通配符

    public class TestDemo {

    public static void main(String[] args) {

    Message message = new Message() ;

    message.setMessage(55);

    fun(message);

    }

    // 此时使用通配符"?"描述的是它可以接收任意类型,但是由于不确定类型,所以无法修改

    public static void fun(Message> temp){

    //temp.setMessage(100); 无法修改!

    System.out.println(temp.getMessage());

    }

    }

    在”?”的基础上又产生了两个子通配符:

    ? extends 类:设置泛型上限:

    例如:? extends Number,表示只能够设置Number或其子类,例如:Integer、Double等;

    ? super 类:设置泛型下限:

    例如:? super String,表示只能够设置String及其父类Object。

    例:设置泛型上限

    package www.bit.java.test;

    class Message { // 设置泛型上限

    private T message ;

    public T getMessage() {

    return message;

    }

    public void setMessage(T message) {

    this.message = message;

    }

    }

    public class TestDemo {

    public static void main(String[] args) {

    Message message = new Message() ;

    message.setMessage(55);

    fun(message);

    }

    // 此时使用通配符"?"描述的是它可以接收任意类型,但是由于不确定类型,所以无法修改

    public static void fun(Message extends Number> temp){

    //temp.setMessage(100); 仍然无法修改!

    System.out.println(temp.getMessage());

    }

    }

    例:设置泛型下限

    package www.bit.java.test;

    class Message {

    private T message ;

    public T getMessage() {

    return message;

    }

    public void setMessage(T message) {

    this.message = message;

    }

    }

    public class TestDemo {

    public static void main(String[] args) {

    Message message = new Message() ;

    message.setMessage("Hello World");

    fun(message);

    }

    public static void fun(Message super String> temp){

    // 此时可以修改!!

    temp.setMessage("bit!");

    System.out.println(temp.getMessage());

    }

    }

    注意:上限可以用在声明,不能修改;而下限只能用在方法参数,可以修改内容!

    五、泛型接口

    泛型除了可以定义在类中,也可以定义在接口里面,这种情况我们称之为泛型接口。  例:定义一个泛型接口

    interface IMessage { // 在接口上定义了泛型

    public void print(T t) ;

    }

    对于这个接口的实现子类有两种做法  例:在子类定义时继续使用泛型

    package www.bit.java.test;

    interface IMessage { // 在接口上定义了泛型

    public void print(T t);

    }

    class MessageImpl implements IMessage {

    @Override

    public void print(T t) {

    System.out.println(t);

    }

    }

    public class TestDemo {

    public static void main(String[] args) {

    IMessage msg = new MessageImpl() ;

    msg.print("Hello World");

    }

    }

    例:在子类实现接口的时候明确给出具体类型

    package www.bit.java.test;

    interface IMessage { // 在接口上定义了泛型

    public void print(T t) ;

    }

    class MessageImpl implements IMessage {

    @Override

    public void print(String t) {

    System.out.println(t);

    }

    }

    public class TestDemo {

    public static void main(String[] args) {

    IMessage msg = new MessageImpl() ;

    msg.print("Hello World");

    }

    }

    六、类型擦出

    泛型是 Java 1.5 版本才引进的概念,在这之前是没有泛型的概念的,但显然,泛型代码能够很好地和之前版本的代码很好地兼容。  这是因为,泛型信息只存在于代码编译阶段,在进入 JVM 之前,与泛型相关的信息会被擦除掉,专业术语叫做类型擦除。  例:观察泛型擦出

    class MyClass{

    private T message;

    public T getMessage() {

    return message;

    }

    public void setMessage(T message) {

    this.message = message;

    }

    public void testMethod1(T t) {

    System.out.println(t);

    }

    }

    public class Test {

    public static void main(String[] args) {

    MyClass myClass1 = new MyClass<>();

    MyClass myClass2 = new MyClass<>();

    System.out.println(myClass1.getClass() == myClass2.getClass());

    }

    }

    运行结果为 true    打印的结果为 true 是因为 MyClass 和 MyClass 在 jvm 中的 Class 都是 MyClass.class。  例:

    import java.lang.reflect.Field;

    class MyClass{

    private T message;

    private E text;

    public E getText() {

    return text;

    }

    public void setText(E text) {

    this.text = text;

    }

    public T getMessage() {

    return message;

    }

    public void setMessage(T message) {

    this.message = message;

    }

    public void testMethod1(T t) {

    System.out.println(t);

    }

    }

    public class Test {

    public static void main(String[] args) {

    MyClass myClass1 = new MyClass<>();

    Class cls = myClass1.getClass();

    Field[] fields = cls.getDeclaredFields();

    for (Field field : fields) {

    System.out.println(field.getType());

    }

    }

    }

    运行结果    在泛型类被类型擦除的时候,之前泛型类中的类型参数部分如果没有指定上限,如 则会被转译成普通的Object 类型,如果指定了上限如 则类型参数就被替换成类型上限。

    展开全文
  • 形式类型参数与实际类型参数之间的关系类似于形式方法参数与实际方法参数之间的关系,只是类型参数表示类型,而不是表示值。有没有可能不指定类型?有没有可能在运行时才知道具体的类型是什么?所以,就出现了泛型。...

    泛型T

    泛型的许多最佳例子都来自集合框架,因为泛型让您在保存在集合中的元素上指定类型约束。

    在定义泛型类或声明泛型类的变量时,使用尖括号来指定形式类型参数。形式类型参数与实际类型参数之间的关系类似于形式方法参数与实际方法参数之间的关系,只是类型参数表示类型,而不是表示值。

    有没有可能不指定类型?有没有可能在运行时才知道具体的类型是什么?

    所以,就出现了泛型。

    eg:

    public class Container {

    private K key;

    private V value;

    public Container(K k, V v) {

    key = k;

    value = v;

    }

    在编译期,是无法知道K和V具体是什么类型,只有在运行时才会真正根据类型来构造和分配内存

    一个基本的原则是:无论何时,只要你能做到,你就应该尽量使用泛型方法。也就是说,如果使用泛型方法可以取代将整个类泛化,那么应该有限采用泛型方法

    public class Main {

    public static void out(T t) {

    System.out.println(t);

    }

    public static void main(String[] args) {

    out("findingsea");

    out(123);

    out(11.11);

    out(true);

    }

    }

    可以看到方法的参数彻底泛化了,这个过程涉及到编译器的类型推导和自动打包,也就说原来需要我们自己对类型进行的判断和处理,现在编译器帮我们做了。这样在定义方法的时候不必考虑以后到底需要处理哪些类型的参数,大大增加了编程的灵活性。

    再看一个泛型方法和可变参数的例子:

    public class Main {

    public static void out(T... args) {

    for (T t : args) {

    System.out.println(t);

    }

    }

    public static void main(String[] args) {

    out("findingsea", 123, 11.11, true);

    }

    }

    输出和前一段代码相同,可以看到泛型可以和可变参数非常完美的结合。

    参考:

    Java泛型:泛型类、泛型接口和泛型方法 - findingea - SegmentFault

    https://segmentfault.com/a/1190000002646193

    Java泛型详解 - Jinuxwu的专栏 - 博客频道 - CSDN.NET

    http://blog.csdn.net/jinuxwu/article/details/6771121/

    Java 可变参数 - 蛊惑Into - 博客园

    http://www.cnblogs.com/whgw/archive/2011/10/01/2197103.html

    展开全文
  • 1泛型的类型参数只能是类类型包括自定义类不能是简单类型 2同一种泛型可以对应多个版本因为参数类型是不确定的不同版本的泛型类实例是不兼容的 3泛型的类型参数可以有多个 4泛型参数类型可以使用extends语句例如...
  • 泛型概述 泛型: 是JDK5中引入的特性,它提供了编译时类型安全检测机制,该机制允许...这种参数类型可以用在类、方法接口中,分别被称为泛型类、泛型方法泛型接口 泛型定义格式: <类型>: 指定一种类型的格...
  • 泛型:一种程序设计语言的新特性,于...在Java泛型主要体现在泛型类、泛型方法泛型接口中。泛型类:当一个类要操作的引用数据类型不确定的时候,可以给该类定义一个形参。用到这个类的时候,通过传递类型参数的...
  • 文章目录泛型类泛型类的继承泛型与内部类泛型接口泛型接口的实现泛型方法形参的类型参数通过实参确定泛型方法被多个形参推断返回值的类型参数通过方法返回值赋值的对象确定形参和返回值用了同一个类型参数泛型方法...
  • 2.3泛型接口泛型 1.JDK1.5新特性 1.1可变参数 使用要求: 一个方法有且只能有一个可变参数,并且放在方法的最后一个参数 语法: 类型声明 ... 参数名称 int ... data 1.2foreach循环 ...
  • 之所以声明泛型方法,一般是因为你想要在该方法的多个参数之间宣称一个类型约束。   public &lt;T&gt; T ifThenElse(boolean b, T first, T second) { return b ? first : second; } 你可以调用ifThen...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,550
精华内容 1,020
关键字:

java接口方法参数泛型

java 订阅