Java 泛型详解：泛型类、泛型接口、泛型方法

最新推荐文章于 2024-10-05 23:32:13 发布
最新推荐文章于 2024-10-05 23:32:13 发布
阅读量5.7k 收藏 77
点赞数 9
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anlian523/article/details/100595691
版权

文章目录


泛型按照使用方法分为三种情况：

  1. 泛型类
  2. 泛型接口
  3. 泛型方法

泛型类

  • 泛型允许我们使用类型参数Type parameter，它用一个自定义的标识符(T、V、E)来代表一个类型，用< >括住，放在类名后面。然后在类定义中所有使用该类型的地方都用这个标识符来代替，因为在定义这个类的时候还不知道这个具体类型到底是哪个类型。
  • 可使用类型参数Type parameter的地方：声明变量、形参、返回值、强制类型转换。注意不可以用于构造器。
  • 在使用泛型类时（区别于定义泛型类时），< >里面的类型必须被具体类型或定义泛型类时的类型参数所确定。如果是被定义泛型类时的类型参数确定的这种情况，则是把确定类型的任务交给了定义泛型类，这种情况常出现在泛型类的继承、或内部类。
  • 泛型与多态不冲突。当使用泛型类class store<phone>时，你既可以使用phone，也可以使用vivoPhone。

泛型类的继承

class two<A,B> {//定义泛型类
}
class three<C> extends two<A, B> {//报错can't resolve symbol 'A',can't resolve symbol 'B'
}

class two<A,B> {
}
class three<A,B,C> extends two<A, B> {
}

在第一段代码中，类three的声明会报错，而第二段不会。这是因为，class three<A,B,C>属于声明泛型类，而extends two<A, B>属于使用泛型类。使用泛型类的时候类型参数必须被确定，这里extends two<A, B>中的A,B被泛型类class three<A,B,C>的声明里的A,B所确定。
虽然extends two<A, B>中的A,B不是具体类型却还是类型参数，但有了声明泛型类class three<A,B,C>的保证，A,B最终能被具体类型所确定。

泛型与内部类

此例实现了一个简单的栈，内部原理是链式存储。

// A stack implemented with an internal linked structure.

public class LinkedStack<T> {//声明泛型类
    private static class Node<U> {//声明泛型类
        U item;
        Node<U> next;
        Node() { item = null; next = null; }
        Node(U item, Node<U> next) {
            this.item = item;
            this.next = next;
        }
        boolean end() { return item == null && next == null; }
    }
    private Node<T> top = new Node<T>(); //使用泛型类，但这里被定义泛型类的类型参数确定
    public void push(T item) {
        top = new Node<T>(item, top);
    }   
    public T pop() {
        T result = top.item;
        if(!top.end())
            top = top.next;
        return result;
    }
    public static void main(String[] args) {
        LinkedStack<String> lss = new LinkedStack<String>();
        for(String s : "Phasers on stun!".split(" "))
            lss.push(s);
        String s;
        while((s = lss.pop()) != null)
            System.out.println(s);
    }
} /* Output:
stun!
on
Phasers
*///:~

类LinkedStack中有个内部类Node，它们都是泛型类。在定义泛型类Node时，类型参数没有被确定，当然也不需要被确定。在使用泛型类private Node<T> top = new Node<T>()时，Node的类型参数被定义泛型类LinkedStack的T所确定，因为这句private Node<T> top = new Node<T>()处于LinkedStack的类定义中，所以这样用也合理。

泛型接口

  • 各方面和泛型类都是类似的。自定义的标识符(T、V、E)来代表一个类型，用< >括住，放在接口名后面。
  • 在使用泛型接口时，< >里面的类型必须被具体类型、定义泛型类或泛型接口时的类型参数所确定。不过一般泛型接口多被具体类型确定。

泛型接口的实现

interface two<A>{

}
class three<A,B> implements two<A>{

}
interface four<A,B> extends two<A>{
    
}

上例说明了使用泛型接口时，可以被定义泛型类或泛型接口时的类型参数所确定。

interface two<A>{
    A f(A a);
}
class impl implements two<Object>{
    public Object f(Object a){
        return new Object();
    }
}

当使用泛型接口时，确定好的具体类型要覆盖掉原来的所有使用类型参数的地方。比如类impl中的f方法中，所有使用A的地方都要用Object替换掉。

泛型方法

  • 自定义的标识符(T、V、E)来代表一个类型，用< >括住，放在方法返回值前面。可以被用到形参声明、方法返回值、方法定义中的变量声明和类型转换。
  • 泛型方法使得该泛型方法的类型参数独立于类而产生变化。泛型方法和泛型类没有关系。
  • 泛型方法的类型参数，一般情况下都是被推断inference出来。更具体地讲，只能被形参或返回值推断出来，当形参和返回值用了同一个类型参数时，二者推断出来的类型必须一样、或者符合多态。
  • 形参的类型参数通过实参确定；返回值的类型参数通过方法返回值赋值的对象确定。这也就是类型参数推断。
  • 当形参的类型参数和返回值的类型参数是同一个时，优先使用形参的推断。因为返回值的类型参数的推断是一种拖延行为。
  • 类的成员方法可以使用定义泛型类的类型参数（注意，这种方法不是泛型方法，只不过使用了类型参数而已）；而类的静态方法不可以使用泛型类的类型参数，这是因为只有当创建泛型类对象时类型参数才会被具体类型确定，也就是说，泛型类的类型参数是与对象相关的。那么，很自然地，作为一个static方法肯定不可以使用泛型类的类型参数。static方法想用到泛型只能将其定义为泛型方法。

形参的类型参数通过实参确定

class GenericMethods {
    public <T> void f(T x) {
        System.out.println(x.getClass().getName());
    }
    public void testInt(){
        f(1);
    }
}

public class testP {
    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        gm.f("");
        gm.f(1);
        gm.f(1.0);
        gm.f(1.0F);
        gm.f('c');
        gm.f(gm);
        gm.testInt();
    }
}

f方法是一个泛型方法，返回值是void，形参是< >里的T。调用泛型方法，既可以通过对象来调用，例如gm.f("");，此时T被推断为String类型；也可以在除该泛型方法外，且类定义中调用，例如testInt()方法中，此时T被推断为int类型。
泛型方法和自动打包让f方法看起来像是被无限重载了一样。

泛型方法被多个形参推断

public class Test {  
    public static void main(String[] args) {  

        /**依靠类型参数推断*/  
        int i = Test.add(1, 2); //这两个参数都是Integer，所以T为Integer类型  
        Number f = Test.add(1, 1.2); //这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Number  
        Object o = Test.add(1, "asd"); //这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Object  

        /**显式的类型说明*/  
        int a = Test.<Integer>add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类  
        int b = Test.<Integer>add(1, 2.2); //编译错误，指定了Integer，不能为Float  
        Number c = Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float  
    }  

    //这是一个简单的泛型方法  
    public static <T> T add(T x,T y){  
        return y;  
    }  
}

add方法的两个形参都使用到了类型参数T，即使用了同一个类型参数。那么在推断的时候会依靠两个实参的共同最小父类来推断（就好像数学里的最小公倍数）。

返回值的类型参数通过方法返回值赋值的对象确定

class GenericMethods {
    public <T> T f2(Object x) {
        System.out.println(x.getClass().getName());
        return (T)x;
    }
}

public class testP {
    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        int o1 = gm.f2(2);
        String o2 = gm.f2(2);//能通过编译，但运行时报错
        gm.f2(1.2);//
    }
}

f2方法是一个泛型方法，返回值是< >里的T，形参是Object x。

  • 执行int o1 = gm.f2(2)后，由于f2方法返回值赋值给了一个int变量，那么这里T就被推断为了int，并且在f2方法的运行过程中，所有使用T的地方都会替换为int，所以return (T)x;实际是执行的return (int)x;。所以，整个运行过程是，2被向上转型为Object，然后强行cast为了int，最后被返回出来。
  • 执行String o2 = gm.f2(2)后，由于这里T就被推断为了String，一个实际为2的Object对象在向上转型为String类型时，会受到RTTI的检查，被发现无法转型后便报错。
  • 执行gm.f2(1.2)后，由于返回值没有赋值给对象，所以T没有被推断出来，也不需要被推断出来。因为没有进行赋值，返回值并不关心。

形参和返回值用了同一个类型参数

class A{}
class B extends A{}

class GenericMethods {
    public <T> T f1(T x) {
        System.out.println(x.getClass().getName());
        return x;
    }
}

public class testP {
    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        int i = gm.f1(1);
        //String s = gm.f1(1);
        A a = gm.f1(new B());
        //B b = gm.f1(new A());
    }
}

f1方法是一个泛型方法，返回值是< >里的T，形参也是< >里的T。这种情况只使用形参的类型推断，因为靠返回值推断是一种推延行为。

  • 执行int i = gm.f1(1)时，形参处的T被推断为int，所以没有问题。
  • 执行String s = gm.f1(1)时，形参处的T被推断为int，然后返回值int赋值给一个String类型，所以这里编译报错。
  • 执行A a = gm.f1(new B())时，形参处的T被推断为B。然后返回值B对象赋值给一个A类型，这里向上转型。
  • 执行B b = gm.f1(new A())时，形参处的T被推断为A。然后返回值A对象赋值给一个B类型，这里向下转型，不可以，编译报错。
  • 这里如果是B b = (B) gm.f1(new A())则能够编译通过。这里把工作交给了强制类型转换，编译器便不会报错了，但运行报错。

泛型方法定义中的类型推断

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class New {
    public static <K,V> Map map() {
        return new HashMap<K,V>();//泛型方法定义中使用类型参数
    }
    public static <T> List list() {
        return new ArrayList<T>();
    }
    public static void main(String[] args) {
        Map<String,List<String>> sls = New.map();
        List<String> ls = New.list();
    }
}

注意这种情况一般都是发生在return语句里。通过泛型方法的赋值，推断出了泛型方法定义中的类型参数的具体类型。

静态方法不可以使用泛型类定义的类型参数

class two<A>{
    public void f(A a){//只是一个使用了类型参数的成员方法
        System.out.println(a);
    }

//    public static void f1(A a){//静态方法不可以使用泛型类定义的类型参数
//        System.out.println(a);
//    }

    public static <A> void staticF(A a){//泛型方法，静态方法
        System.out.println(a);
    }

    public <A> void memberF(A a){//泛型方法，成员方法
        System.out.println(a);
    }
}

注意staticF方法里的A和two<A>里的A没有任何关系。同样，memberF方法里的A和two<A>里的A没有任何关系。因为这二者都是泛型方法。
two<A>里的A是与对象相关的，只有创建对象时才能确定。f1是静态方法，自然不可能与对象相关的东西有关系。

泛型方法返回值赋值给形参

这种情况区别于泛型方法返回值赋值给变量。

import java.util.HashMap;
import java.util.Map;

class LimitsOfInference {
    static void f(Map<String,Integer> petPeople) {

    }
    public static void main(String[] args) {
         f(New.map()); //报一个警告
    }
}

public class New {
    public static <K,V> Map map() {
        return new HashMap<K,V>();
    }
}

警告内容为：在这里插入图片描述
说明泛型方法中的类型参数并没有被推断出来，所以这里泛型方法返回值只知道是个Map。

而为了这里不报警告，则需要使用显示的类型说明，在调用泛型方法时，在点操作符和方法名之间插入尖括号，然后把具体类型放在里面。这种语法很少见，在这样的非赋值语句中，才需要用到，一般用类型参数推断就可以解决。

import java.util.HashMap;
import java.util.Map;

class LimitsOfInference {
    static void f(Map<String,Integer> petPeople) {

    }
    public static void main(String[] args) {
         f(New.<String,Integer>map()); //不报任何警告
    }
}
public class New {
    public static <K,V> Map map() {
        return new HashMap<K,V>();
    }
}

可变参数和泛型方法

import java.util.*;

public class GenericVarargs {
    public static <T> List<T> makeList(T... args) {
        List<T> result = new ArrayList<T>();
        for(T item : args)
            result.add(item);
        return result;
    }
    public static void main(String[] args) {
        List<String> ls = makeList("A");
        System.out.println(ls);
        ls = makeList("A", "B", "C");
        System.out.println(ls);
        ls = makeList("ABCDEFFHIJKLMNOPQRSTUVWXYZ".split(""));
        System.out.println(ls);
    }
} /* Output:
[A]
[A, B, C]
[, A, B, C, D, E, F, F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z]
*///:~

makeList方法的功能类似于java.util.Arrays.asList()的功能。

泛型类和泛型方法

此例中泛型类和泛型方法同时存在。有一个泛型接口Generator用来产生某种对象。CountedObject类必须有默认构造器因为newInstance。

interface Generator<T> {
    T next();
}

class CountedObject {
    private static long counter = 0;
    private final long id = counter++;// 用于记录创建对象的次数
    public long getId() {
        return id;
    }
    public String toString() {
        return "CountedObject" + id;
    }
}

public class BasicGenerator<T> implements Generator<T> {
    private Class<T> type;
    public BasicGenerator(Class<T> type) {
        this.type = type;
    }
    
    @Override
    public T next() {
        try {
            return type.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    
    public static <T> Generator<T> create(Class<T> type) {//静态泛型方法
        return new BasicGenerator<T>(type);
    }
  
    public static void main(String[] args) {
        Generator<CountedObject> gen = BasicGenerator.create(CountedObject.class);
        for (int i = 0; i < 5; i++) {
            System.out.println(gen.next());
        }
    }
}
  • create方法是静态的泛型方法，而泛型类 BasicGenerator 的类型参数是与对象相关的，所以 create方法里的 T 不是泛型类的 T。或者说，在create方法里，create方法的<T>暂时隐藏了BasicGenerator<T>的<T>，这使得泛型方法的类型参数独立于对象。
  • 此例体现了泛型方法的好处，由于泛型方法的类型参数推断，所以这里允许执行BasicGenerator.create(CountedObject.class)，而不是去执行麻烦的new BasicGenerator<CountedObject>(CountedObject.class)。简单的说，让你少写了尖括号。
  • 注意一下create方法的return语句和返回值，可以看出Generator<CountedObject>是BasicGenerator<CountedObject>的父类。注意这种与泛型有关的多态。

泛型类中的成员泛型方法和静态泛型方法

对上例进行修改，使其同时拥有成员的泛型方法和静态的泛型方法，且这两种泛型方法使用的类型参数和泛型类的类型参数是同一个（都用的T）。staticCreate和memberCreate的返回值都进行了修改，使其返回子类BasicGenerator而不是父接口Generator，这是为了对象方便调用新增加的成员方法。

//前面省略
public class BasicGenerator<T> implements Generator<T> {
    private Class<T> type;
    public BasicGenerator(Class<T> type) {
        this.type = type;
    }

    @Override
    public T next() {
        try {
            return type.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public static <T> BasicGenerator<T> staticCreate(Class<T> type) {//静态的泛型方法
        return new BasicGenerator<T>(type);
    }

    public <T> BasicGenerator<T> memberCreate(Class<T> type) {//成员的泛型方法
        return new BasicGenerator<T>(type);
    }

    public <T> void test (T t) {//成员的泛型方法
        System.out.println(t.getClass().getName());
    }

    public static void main(String[] args) {
        BasicGenerator<CountedObject> gen = BasicGenerator.staticCreate(CountedObject.class);
        for (int i = 0; i < 5; i++) {
            System.out.println(gen.next());
        }
        gen.test("");//这里独立于类，泛型方法test推断出了自己的类型参数T为String，而不是gen对象确定的CountedObject
        gen.test(1);
        BasicGenerator<String> gen1 = gen.memberCreate(String.class);
        System.out.println(gen1.type.getName());
    }
}/*output:
CountedObject0
CountedObject1
CountedObject2
CountedObject3
CountedObject4
java.lang.String
java.lang.Integer
java.lang.String
*/

从运行结果可以看出：泛型方法不管是静态的还是成员的，就算和泛型类使用了同一个类型参数T，在泛型方法中也会暂时隐藏泛型类的类型参数，而使用自己的类型参数，并且把确定具体类型的任务交给了类型参数推断。这样，就做到了泛型方法能够独立于泛型类的类型参数而产生变化。

匿名内部类和泛型

本例使用了匿名内部类来继承并实现泛型接口。

interface Generator<T> {//定义泛型接口
    T next();
}

class Customer {
    private static long counter = 1;
    private final long id = counter++;
    private Customer() {}
    public String toString() { return "Customer " + id; }
    // A method to produce Generator objects:
    public static Generator<Customer> generator() {
        return new Generator<Customer>() {//使用泛型接口
            public Customer next() { return new Customer(); }
        };
    }
}

return new Generator<Customer>()这里属于使用泛型接口，既然是使用，那么必须把类型参数确定下来，并且把使用了类型参数的地方进行替换，替换为Customer。继承并实现泛型类的匿名内部类同理。

个人理解总结

  • 泛型的类型参数看起来就像是让代码变成了一套模板，当给定具体类型时，模板里的类型参数就会被替换以生效。
  • 泛型这种类似“模板”的灵活性，在使用泛型时（生成泛型类对象）得以体现，但在使用泛型后（在泛型类对象上调用方法）失去。
Generic_2(泛型类-泛型方法-泛型接口-泛型限定(上限)
10-01
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。
Java泛型方法
weixin_34281477的博客
01-12 126
2019独角兽企业重金招聘Python工程师标准>>> ...
【Java】—— 泛型：自定义泛型类、泛型方法
最新发布
weixin_63106307的博客
10-05 1562
1、这种语法形式就叫泛型。的形式我们称为类型参数，这里的"类型"习惯上使用T表示，是Type的缩写。即：。：代表未知的数据类型，我们可以指定为，，等。类比方法的参数的概念，我们把，称为类型形参，将称为类型实参，有助于我们理解泛型这里的T，可以替换成K，V等任意字母。2、在哪里可以声明类型变量声明类或接口时，在类名或接口名后面声明泛型类型，我们把这样的类或接口称为泛型类或泛型接口。
泛型类、泛型接口、泛型方法及泛型的应用
detscaozv622278146的博客
04-27 156
面向对象的一个重要目标就是对代码的重用，支持这个目标的重要机制就是泛型； 泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，* 分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。* 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实...
java泛型（二）、泛型的内部原理：类型擦除以及类型擦除带来的问题
热门推荐
Kilnn
08-29 7万+
参考：java核心技术 一、Java泛型的实现方法：类型擦除 前面已经说了，Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出（type erasure）。 Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在
Java基础-泛型类、泛型接口、泛型方法
Eistert
10-20 1504
1. 概述 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类
Java泛型详解：类型安全与泛型类接口
除了泛型类，Java还支持泛型方法，即方法级别的泛型。方法的泛型允许我们为方法的返回值或参数指定类型参数，以提供局部的类型安全性。例如： ```java public static <T> List<T> createList(T... elements) { ...
Java泛型详解：强类型集合与泛型方法
2. **泛型类**：泛型类允许我们在类的定义中使用类型参数，例如`class MyContainer<T> { T item; }`，这里的`T`就是一个类型参数，代表一个未知的类型，实际使用时可以替换为任何具体的类型。 3. **泛型通配符**：...
Java泛型详解：类模板与应用实例
4. 多类型参数：`class Notepad, V>`是一个具有两个类型参数的泛型类，分别表示键（key）和值（value）。它提供了`getKey()`、`getValue()`、`setKey()`和`setValue()`方法，用于操作键值对。在`GenericsDemo09`中，...
Java泛型详解：限定泛型上限与成员方法
标题中提到的"限定泛型上限"是指在声明泛型类或方法时，我们可以限制泛型参数的类型必须是某个特定类或者接口的子类型。这可以通过在尖括号内使用`extends`关键字来实现。例如，`T extends List` 表示`T`必须是`List...
Java泛型详解：提升集合安全与效率
泛型通过在类或接口的声明阶段引入类型参数，使得在使用时可以根据实际需要传递具体的类型，提高了代码的可读性和安全性。 2. 泛型概念与使用： - 泛型参数：在定义类或接口时，使用类型参数来标识不确定的类型，...
泛型类，泛型接口，泛型方法
宋轶山
08-19 147
1.  泛型接口和泛型类的使用类似，无区别。 2.  泛型方法使用是将泛型参数放在方法的返回值之前，例子： public &lt;T&gt; void f(T x){ System.out.println("泛型方法"+x.getClass().getName()); } 如果f(T x)这个方法所在的类已经是拥有泛型参数T的泛型类，那么可以省略前面的&lt;T...
java 泛型接口 泛型方法
panjiao119的博客
05-27 348
1   java 泛型接口： package Inteface; interface GneInter{  public void say(); } class Gin implements GneInter{  private String info;  public Gin(String info)  {   this.info = info;  }  public
泛型类，泛型接口和泛型方法
NoKris的博客
05-06 158
泛型的三种使用
java 泛型接口和方法
weixin_30748995的博客
07-05 113
java5后，可以声明泛型接口，声明方式和声明泛型类是一样的。 public interface IDAO<T>{} 泛型接口子类有两种方式： 直接在子类后申明泛型； 在子类实现的接口中给出具体的泛型类型 public class DaoImpl<T> implements IDAO<T>{} public class DaoImpl impleme...
Java中泛型方法、泛型接口。
qq_41877039的博客
07-24 228
最近自学Java，一直做笔记的方式并不是很好，还不如将每次将理解直接写下来，也不用后期的整理。咱们来看看在Java中泛型方法、泛型接口咋用； 1.泛型方法 public <E> String myFunc(E name){//和普通方法的定义就差在多一个<E> return name+", Hello"; } 这就是一个正常的泛型函数的定...
JAVA泛型接口
2301_80884223的博客
06-10 1005
泛型接口：允许在定义接口时声明类型参数，即泛型接口，这种类型参数在整个接口中可当成类型使用。class Sub<具体类型列表>implements IBase<具体类型列表>{}class Sub<类型参数表>implements IBase<类型参数表>{}泛型接口案例：子类Sub实现接口 IBase<T>1.实现子类没有明确地指明类型参数的具体类型。1.泛型的类型参数不能作为静态成员变量的类型。2.静态方法中不能有任何泛型类型参数出现。2.实现子类明确指明类型参数的具体类型。子类实现泛型接口形式。
java 泛型方法
斜阳雨陌
07-04 1336
java泛型方法
Jason_LH1024的博客
03-18 240
前面学习了java泛型类，这里再来说一下带有类型参数的简单方法： 泛型方法。。 public class ArrayAlg1 { public static <T> T getMiddle(T...a) { return a[a.length/2]; } String middle = ArrayAlg1.<Strin...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值