精华内容
下载资源
问答
  • 泛型类怎么调用方法
    千次阅读
    2021-02-26 19:11:01

    泛型类定义的泛型,在整个类中有效。如果被方法是用,那么

    泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。

    为了让不同的方法可以操作不同类型,而且类型还不确定。那么

    可以将泛型定义在方法上。

    泛型类

    class Demo

    {

    public void show(T t)

    {

    System.out.println("show: "+t);

    }

    public void print(T t)

    {

    System.out.println("show: "+t);

    }

    }

    class GenericDemo4

    {

    public static void main(String[] args)

    {

    Demod = new Demo();

    d.show(new Integer(4));

    Demod1 = new Demo();

    d1.print("haha");

    }

    }

    结果:

    show: 4

    show: haha

    泛型方法

    class Demo

    {

    public void show(T t)

    {

    System.out.println("show: "+t);

    }

    public void print(Q q)

    {

    System.out.println("print:"+q);

    }

    }

    class GenericDemo4

    {

    public static void main(String[] args)

    {

    Demo d = new Demo();

    d.show("hello boy!");

    d.print("Alex i love you !");

    }

    }

    结果:

    show: hello boy!

    print:Alex i love you !

    同时定义泛型类和泛型方法

    class Demo

    {

    public void show(T t)

    {

    System.out.println("show: "+t);

    }

    public void print(Q q)

    {

    System.out.println("print:"+q);

    }

    }

    class GenericDemo4

    {

    public static void main(String[] args)

    {

    Demo d = new Demo();

    d.show("hello boy!");

    d.print("Alex i love you !");

    d.print(5);

    d.print("heiei");

    }

    }

    结果:

    show: hello boy!

    print:Alex i love you !

    print:5

    print:heiei

    特殊之处:

    静态方法不可以访问类上定义的泛型

    如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。

    class Demo

    {

    public void show(T t)

    {

    System.out.println("show: "+t);

    }

    public void print(Q q)

    {

    System.out.println("print:"+q);

    }

    public static void method(W t)

    {

    System.out.println("method: "+t);

    }

    }

    class GenericDemo4

    {

    public static void main(String[] args)

    {

    Demo d = new Demo();

    d.show("hello boy!");

    d.print("Alex i love you !");

    d.print(5);

    d.print("heiei");

    Demo.method("hihi");

    }

    }

    结果:

    show: hello boy!

    print:Alex i love you !

    print:5

    print:heiei

    method: hihi

    泛型定义在接口上

    interface Inter

    {

    void show(T t);

    }

    //第一种

    class InterImpl implements Inter

    {

    public void show(String t)

    {

    System.out.println("show :"+t);

    }

    }

    /*第二种

    class InterImplimplements Inter

    {

    public void show(T t)

    {

    System.out.println("show :"+t);

    }

    }

    */

    class GenericDemo5

    {

    public static void main(String[] args)

    {

    /*

    InterImpl i = new InterImpl();

    i.show(4);

    */

    InterImpl i = new InterImpl();

    i.show("haha");

    }

    }

    结果:

    show :haha

    第一种相对来说就比较死,固定为String类型了。而第二种可以自己定义。

    更多相关内容
  • 定义一个泛型类basicRobotController: public class basicRobotController<R extends RoutePoint, O> { @RequestMapping(value="updateRoutePoint", method = RequestMethod.POST,produces={"application/...

    定义一个泛型类basicRobotController:

    public class basicRobotController<R extends RoutePoint, O> {
    
    @RequestMapping(value="updateRoutePoint", method = RequestMethod.POST,produces={"application/json;charset=utf-8"})
    @ResponseBody
    public void updateRoutePoint(String routePointStr,String collection){
    R routePoint = JSONObject.parseObject(routePointStr, clazzR);
    routePoint.getOrder();
    ...
        }
    }
    

    定义sprayRobotController 继承basicRobotController:

    @Controller
    @RequestMapping("sprayRobot")
    public class sprayRobotController extends basicRobotController<SprayRoutePoint, SprayOperatorData> {
    
        @Resource
        public void setService(ISprayRobotService sprayRobotService){
            super.setBaseService(sprayRobotService);
        }
    
    }
    

    (1)如果basicRobotControllerupdateRoutePoint方法中,泛型类R的实例routePoint 需要调用其本身定义的方法,需要定义泛型R的具体类后才能调用。
    (2)本例因为定义basicRobotController时,泛型R继承RoutePoint类,因此泛型R的实例routePoint可以调用RoutePoint类的方法。
    (3)若定义basicRobotController时R没有继承至RoutePoint,则无法调用RoutePointgetOrder()方法。

    展开全文
  • 主要为大家详细介绍了.NET CORE动态调用泛型方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java系列之:泛型类泛型方法泛型接口一、泛型二、泛型类三、泛型方法四、泛型接口五、类型通配符 一、泛型 泛型:本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数...

    Java系列之:泛型类、泛型方法、泛型接口

    一、泛型

    • 泛型:本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型。这种参数可以用在类、方法和接口中,分别被称为泛型类、泛型方法、泛型接口。

    泛型定义格式:

    • <类型>:指定一种类型的格式。这里的类型可以看成是形参。
    • <类型1,类型2…>:指定多种类型的格式,多种类型用逗号隔开,这里的类型可以看成是形参。
    • 将来具体调用时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型。

    泛型的好处:

    • 把运行时期的问题提前到了编译期间
    • 避免了强制类型转换

    二、泛型类

    泛型类的定义格式:

    • 格式:修饰符 class 类名<类型>{}
    • 泛例:public class Generic<T> {}
    • T可以是任意标识
    public class Generic<T>{
        private T t;
    
        public T get(){
            return t;
        }
    
        public void set(T t){
            this.t = t;
        }
    }
    
    
    public class CollectionDemo {
    
        public static void main(String[] args) {
            Generic<String> stu = new Generic<String>();
            stu.set("鸣人");
            System.out.println(stu.get());
    
            Generic<Integer> stu1 = new Generic<Integer>();
            stu1.set(10);
            System.out.println(stu1.get());
        }
    }
    
    

    三、泛型方法

    泛型方法的定义格式:

    • 格式:修饰符 <类型> 返回值类型方法名(类型变量名){}
    • 范例:public <T> void show(T t){}
        public <T> T show(T t){
            return t;
        }
    
        public <T> void show1(T t){
            System.out.println(t);
        }
    

    四、泛型接口

    泛型接口的定义格式:

    • 格式:修饰符 interface 接口名<类型>{}
    • 范例:public interface Generic <T>{}
    
    public interface GenInterface<T> {
        void show(T t);
    }
    
    public class GenImpl<T> implements GenInterface<T>{
        @Override
        public void show(T t) {
            System.out.println(t);
        }
    }
    
    public class CollectionDemo{
    
        public static void main(String[] args) {
            GenImpl<String> str = new GenImpl<String>();
            str.show("加油");
    
            GenImpl<Integer> i = new GenImpl<>();
            i.show(30);
        }
    }
    

    五、类型通配符

    为了表示各种泛型List的父类,可以使用类型通配符:

    • 类型通配符:<?>
    • List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
    • 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中

    如果不希望List<?>是任何泛型的父类,只希望代表某一类泛型List的父类,可以使用类型通配符的上限。

    • 类型通配符上限:<?extends类型>
    • List<? extends Number>:表示的类型是Number或者其子类型

    除了可以指定类型通配符的上限,也可以指定类型通配符的下限:

    • 类型通配符下限:<?super类型>
    • List<?super Number>:表示的类型是Number或者其父类型
    import java.util.ArrayList;
    import java.util.List;
    
    public class CollectionDemo{
    
        public static void main(String[] args) {
            List<?> numbersList = new ArrayList<Number>();
    
            //类型通配符上限
            List<? extends Number> list1 = new ArrayList<Number>();
            List<? extends Number> list2 = new ArrayList<Integer>();
    
            //类型通配符下限
            List<? super Number> list3 = new ArrayList<Number>();
    
        }
    }
    
    展开全文
  • 泛型泛型类泛型方法

    千次阅读 2022-03-16 10:40:33
    1. public 和 返回类型中间的标识符,**可以理解为**,声明该...2. 只有声明了的方法泛型方法泛型类中的成员方法**不是**泛型方法 3. 表明,该方法使用泛型类型T,可以使用在**返回类型,传入参数列表,方法体**里

    泛型

    JDK1.5新特性

    优点:

    1. 类型安全:编译时检测类型
    2. 减少类型转换

    泛型类

    概念:在类声明体中用到了类型参数。

    语法:

    /*
    class 类型名<泛型标识,泛型标识, ...>{
        private 泛型标示 变量名;
    }
    */
    public class GenericDemo<T> {
        private T key;
    
        public GenericDemo(T key) {
            this.key = key;
        }
    
        public T getKey() {
            return key;
        }
    
        public void setKey(T key) {
            this.key = key;
        }
    
        public static void main(String[] args) {
            
            /*
            类名<具体的数据类型> 对象名 = new 类目<具体的数据类型>();
    
            JDK1.7后,可以省略成这样:
            类名<具体的数据类型> 对象名 = new 类目<>();
            */
            GenericDemo<Integer> integerGenericDemo = new GenericDemo<>(10);
            GenericDemo<String> stringGenericDemo = new GenericDemo<>("abc");
            //如果没有指定具体的数据类型,此时,操作类型是Object
            GenericDemo genericDemo = new GenericDemo("genericDemo");
    
            System.out.println(integerGenericDemo.key);
            System.out.println(stringGenericDemo.key);
            System.out.println(genericDemo.key);
            //泛型类型在逻辑上可以看成是多个不同的类型,但实际上是相同类型
          System.out.println(integerGenericDemo.getClass()==stringGenericDemo.getClass());	//输出结果为true
        }
    }
    
    
    

    注意:

    1. 泛型类只支持类类型不支持基本数据类型(如int),但可以用包装类(如Integer )

    泛型标识<>:类型形参

    由外部使用类的时候来指定

    泛型标识含义
    TType
    EElement
    KKey
    VValue

    泛型类的继承

    1. 子类也是泛型类,子类和父类的泛型标识要一致。子类也可以扩展泛型标识,但子类中至少有一个泛型标识与父类相同

    2. 子类不是泛型类,父类要明确泛型的数据类型

    //1.子类也是泛型类,子类和父类的泛型标识要一致
    
    class Child<T> extends Parent<T>{}
    
    //也可以扩展,但子类中至少有一个泛型标识与父类相同
    class Child<T,E> extends Parent<T>{}
    
    //2.子类不是泛型类,父类要明确泛型的数据类型
    
    class Child extends Parent<String>{}
    

    泛型接口

    1. 实现类不是泛型类时,接口要明确数据类型
    2. 实现类也是泛型类时,实现类和接口的泛型类型要一致

    泛型方法

    泛型方法比泛型类更加灵活

    泛型类和泛型方法的区别
    泛型类实例化类的时候指明泛型的具体类型
    泛型方法调用方法的时候指明泛型的具体类型

    语法

    修饰符 <T,E,...> 返回值类型 方法名(形参列表){
        方法体... 
    }
    
    1. public 和 返回类型中间的标识符,可以理解为,声明该方法为泛型方法
    2. 只有声明了的方法是泛型方法,泛型类中的成员方法不是泛型方法
    3. 表明,该方法使用泛型类型T,可以使用在返回类型,传入参数列表,方法体

    泛型方法与可变参数

    public class GenericDemo<T> {
    
        public static <E> void print(E... e){
            for(int i = 0; i < e.length; i++){
                System.out.println(e[i]);
            }
        }
    
        public static void main(String[] args) {
            GenericDemo.print(1,2,3,4,5);
            GenericDemo.print("a","b","c");
        }
    }
    

    类型通配符: ?

    概念:用“?”代替具体类型,是类型实参,不是类型形参

    /*
    	类型通配符上限
    	语法:
    	类/接口 <? extends 实参类型>
    	作用:要求该泛型的类型只能是《该实参类型或其子类型》  
    */
    
    public static void showAnimal(ArrayList<? extends Cat> list){
        for(int i;i<list.size();i++){
            Cat cat = list.get(i);
            System.out.println(cat);
        }
    }
    public static void main(String[] args){
        ArrayList<Animal> animals = new ArrayList<>();
        ArrayList<Cat> cats = new ArrayList<>();
        ArrayList<MiniCat> miniCats = new ArrayList<>();
        
        //showAnimal(animals); 编译报错
        showAnimal(cats);
        showAnimal(miniCats);
    }
    
    /*
    	类型通配符下限
    	语法:
    	类/接口 <? super 实参类型>
    	作用:要求该泛型的类型只能是《该实参类型或其父类型》  
    */
    

    类型擦除

    概念:

    JDK1.5以前没有泛型,但泛型代码能很好地和之前版本的代码兼容,是因为,泛型信息只存在于代码编译阶段,

    在进入JVM之前,与泛型相关的信息会被擦除

    展开全文
  • 主要介绍了Java静态泛型使用方法实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 一、泛型类用法、 二、泛型方法用法、 三、泛型通配符 、 四、泛型安全检查、
  • Java——泛型调用

    2022-04-09 08:27:25
    Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许开发者在编译时检测到非法的类型。 泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。 一、...
  • The below code gives me the error:SceneNode.java:17: cannot find symbolsymbol : method execute() location:class java.lang.Objectoperation.execute();^ 1 errorCode:import java.util.LinkedList;...
  • Java 泛型方法调用

    千次阅读 2020-09-09 21:28:01
    * 测试泛型方法 */ public class TestFX { /** * 返回第一个元素 * @param a * @param <T> 声明一个类型 * @return */ public static <T> T getFirst(T... a) { return a[0]; } public ...
  • 泛型类泛型方法

    2021-09-15 13:38:30
    泛型方法是指调用方法时才声明泛型类型。即不用和泛型类泛型类型一致。 当为实例泛型方法时,可以声明泛型类或者将该方法声明为泛型方法。 当有静态泛型方法时,只能将该方法声明为泛型方法泛型类可以...
  • 泛型方法 1. 泛型的提出 List中默认的类型是Object,当我们向List中传入数字和字符串的时候可以执行,但是当要输出的时候就让人头疼。这时候泛型就出来了,可以指定List中传入对象的类型。当传入与指定类型不一样的...
  • 1、泛型是什么 首先告诉大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢?先看看下面这段代码: ArrayList<String> strList = new ArrayList<String>(); ArrayList<Integer> int...
  • 如您所见,当调用m2(t)时,t“是A”. 输出: >实际 O >预期 A 如何在上面的情况下使用泛型,以便选择m2(A a)? 编辑: 即使我添加了类型B(类似于A),我也希望有一个通用的解决方案. ... public static void main(String...
  • 目录标题泛型引入1. 泛型类特点2. 最简单泛型类3. 泛型方法4. 泛型接口5. 泛型类可是同时设置多个类型...泛型方法调用时,才指定具体类型 这样就解决了多个相似的方法、接口 )创建的问题,一个泛型类即可代替所
  • 有没有办法了解从泛型类调用方法将返回什么类型?有一个例子:Generified generified = new Generified();Method method = generified.getClass().getMethod("getDoubleValue");Class> returnType = ........好...
  • JAVA容器之泛型类泛型方法
  • 您可以编写一个可以用不同类型的参数调用泛型方法声明。根据传递给泛型方法的参数类型,编译器会适当地处理每个方法调用。以下是定义泛型方法的规则-所有泛型方法声明都有一个类型参数部分,该类型参数部分由方...
  • 一提到参数,最熟悉的就是定义方法时有形参,然后调用方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为...
  • C#泛型类泛型方法

    2019-10-21 20:16:46
    泛型可以理解为广泛的类型,或者不确定的类型,也就是说允许我们编写一个可以与任何数据类型同时运行,且不报错的方法或者泛型类 泛型类是指这个的某些字段的类型是不确定的,只有在构造的时候才能确定下的...
  • 泛型允许我们使用类型参数Type parameter,它用一个自定义的标识符(T、V、E)来...在使用泛型类时(区别于定义泛型类泛型允许我们使用类型参数Type parameter,它用一个自定义的标识符(T、V、E)来代表一个类型,...
  • } } } Lua player = CS.Player() TheTable = { "aa","bb","cc" } player:PFunction(TheTable) 调用泛型方法方法 C# using System; using System.Collections; using System.Collections.Generic; using ...
  • 泛型(Generic type 或者 generics)是对Java语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的。可以在集合框架(Collection framework)中看到泛型的动机。例如,Map 允许您向一个 Map 添加任意的...
  • 泛型类: using System; namespace ThreadDemo { class Program { static void Main(string[] args) { MyStack<int> myStack = new MyStack<int>(3); myStack.Push(1); myStack.Push(2);
  • 下面小编就为大家带来一篇浅谈Java泛型让声明方法返回子类型的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • C#泛型类泛型方法总结

    千次阅读 2020-06-11 11:21:11
    前言:本博文从C#泛型入手,依次介绍泛型类泛型方法,如果读者想对泛型有更多的了解,可访问本人另一篇博文:C#中List泛型用法,必知必会! 文章目录一、泛型是什么?二、泛型类的定义三、泛型方法定义 一、泛型是...
  • 一、Dart 泛型类泛型方法、 二、Dart 泛型中的特定类型约束、 三、Dart 自带泛型、 四、完整代码示例、 五、 相关资源、
  • 这种参数类型可以用在方法和接口中,分别被称为泛型类、泛指方法、泛指接口。 泛型定义格式: - <类型>:指定一种类型的格式。这里的类型可以看成是形参 - <类型1,类型2…>:指定多类型的格
  • 你定义了一个泛型、接口),那么Java规定,你不能在所有的静态方法、静态初块等所有静态内容中使用泛型的类型参数! 泛型不能用在静态方法等; 泛型方法方法调用时可以接收不同类型的参数。根据传递给泛型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 226,204
精华内容 90,481
关键字:

泛型类怎么调用方法