精华内容
下载资源
问答
  • java中的泛型中的静态方法
    2021-06-15 10:40:32

    泛型方法

    泛型方法就是要在权限符和返回值之间声明泛型,通常用L、V、E、T、K等字母,然后就可以在这个方法的内部将其看作一种方法类型了

    在实验中遇到的问题

    public static <L> IntervalSet<L> empty() throws Exception{
    		throw new RuntimeException();
    	}
    

    本以是想用静态工厂方法定义一个初始化的方法,但是发信并不能使用类定义的泛型。

    静态方法不能直接使用类定义的泛型,也就是说如果要在静态方法中使用泛型的话,就必须将其声明为泛型方法。

    查阅的材料

    https://www.cnblogs.com/coprince/p/8603492.html
    链接

    更多相关内容
  • I've read posts about why you can't have a (Edit -- generic) (which use that type parameter from the generic class) static method in a generic class, but why can you then use static generic methods in...

    I've read posts about why you can't have a (Edit -- generic) (which use that type parameter from the generic class) static method in a generic class, but why can you then use static generic methods in non generic classes? I don't see the why the second is allowed, but I kinda understand why the first isn't.

    解决方案

    why you can't have a (Edit -- generic) (which use that type parameter from the generic class) static method in a generic class

    The reason for this is simple: The type parameter is not associated with the class but with instances of the class.

    I.e., you can't do

    class Test {

    public static void sayHello(T t) { // T for which instance?!

    System.out.println("Hello");

    }

    }

    why can you then use static generic methods in non generic classes?

    Why wouldn't you? A generic method takes the type parameter, so it doesn't matter if it's static or not, or if the class it's in is generic or not etc.

    This for instance compiles fine:

    class Test {

    public static void sayHello(T t) {

    System.out.println("Hello " + t);

    }

    }

    And you'd call the method like this:

    Test.sayHello("some argument");

    ^^^^^^^^

    type parameter provided at the method-call: no instance required.

    展开全文
  • 主要介绍了Java静态泛型使用方法实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 如果被方法是用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同的方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。泛型类class Demo{public void show...

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

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

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

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

    泛型类

    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类型了。而第二种可以自己定义。

    展开全文
  • Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是让开发者可以写出通用,灵活的代码 。 伪泛型 : Java中的泛型 , 是伪泛型 , Java 泛型开发好之后 , 在编译阶段就将泛型相关的信息消除了 ...

    泛型

    泛型简介

    1. 泛型可以理解为参数化类型,主要作用在类,方法和接口上。
    2. Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是让开发者可以写出通用,灵活的代码 。
    3. 伪泛型 : Java中的泛型 , 是伪泛型 , Java 泛型开发好之后 , 在编译阶段就将泛型相关的信息消除了 , 不会泛型留到运行时。

    泛型类型 :

    • 泛型方法 : 方法有参数 , 方法的参数 可以指定成一些 泛型 ;
    • 泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ;
    • 泛型接口 : 接口 的 参数 , 也可以是泛型 ;

    将类型传入泛型方法 , 泛型类, 泛型接口中 , 可以动态地指定一些类型 ;
    泛型的作用 :

    • 安全检查 : 在编译阶段 , 就可以进行 代码检查, 将更少的错误带到运行时 ;
    • 避免强转 : 避免类型的强转导致不必要的安全问题 ;
    • 提高性能 : 使用泛型可以提高 Java 的性能 ;

    泛型类

    泛型类 : 在类名后面使用声明泛型 , 则在该类中, 可以使用该泛型类型 T 类型 ;特别注意 , 该类中的 如下2个方法不是泛型方法 ; 其中的参数 , 返回值类型是T , 但这个T是作为一个正常的类型使用的 , 并不是声明在方法 中的泛型 ;
    如果类,接口,方法是泛型类, 泛型接口,泛型方法, 则该类 , 接口 , 方法必须由 修饰 , 有个带尖括号的 T ;

        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    

    完整的泛型类

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 该方法不是泛型方法
         *  该方法是普通方法 , 返回值类型是 T 类型
         * @return
         */
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    }
    

    泛型方法

    泛型方法 : 在方法的返回值前, 使用 声明泛型的方法 , 是泛型方法 ; 将某个类型作为参数传入 ;
    泛型个数 : 该方法是泛型方法, 且指定了2个泛型 , 泛型的个数可以有很多个, 多个泛型之间 , 使用逗号隔开 ;
    泛型方法 与 泛型类 中的泛型 :
    泛型不同 : 泛型方法指定的泛型T与 类中的泛型T没有任何关系 , 这两个T 可以是不同的类型 ;
    泛型相同 : 泛型方法中定义的泛型T , 与参数类型的T , 返回值类型的T , 方法内部的T , 都是同一个类型 ;

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 泛型方法 , 是将某个类型作为参数传入
         *      方法指定泛型 , 写法如下
         *
         * 该方法是泛型方法
         *      方法指定了 2 个泛型
         *      泛型个数 , 泛型的个数可以有很多个
         *      多个泛型之间 , 使用逗号隔开
         *
         * 为方法指定的泛型 T 与类中的泛型 T 没有任何关系
         *      这两个 T 可以是不同的类型
         *
         * 泛型方法中定义的泛型 T
         *      与参数类型的 T
         *      返回值类型的 T
         *      方法内部的 T
         *      都是同一个类型
         *
         * 与泛型类中的 T 完全没有关系
         *
         * @param <T>
         * @param <A>
         * @return
         */
        public <T, A> T getData2(T arg){
            T data = arg;
            return data;
        }
    }
    

    静态方法的泛型

    静态方法泛型 : 如果静态方法中使用了类中的泛型T, 作为参数或返回值 , 这种使用时错误的 ;
    如果必须在静态方法中使用泛型T, 则该泛型T必须是静态方法的泛型 , 不能是类的泛型 ;
    错误用法:
    错误用法正确用法 :
    正确用法

    泛型类与泛型方法完整示例

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 该方法不是泛型方法
         *  该方法是普通方法 , 返回值类型是 T 类型
         * @return
         */
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        /**
         * 泛型方法 , 是将某个类型作为参数传入
         *      方法指定泛型 , 写法如下 ;
         *
         * 该方法是泛型方法
         *      方法指定了 2 个泛型
         *      泛型个数 , 泛型的个数可以有很多个
         *      多个泛型之间 , 使用逗号隔开
         *
         * 泛型方法指定的泛型 T 与类中的泛型 T 没有任何关系
         *      这两个 T 可以是不同的类型
         *
         * 泛型方法中定义的泛型 T
         *      与参数类型的 T
         *      返回值类型的 T
         *      方法内部的 T
         *      都是同一个类型
         *
         * 与泛型类中的 T 完全没有关系
         *
         * @param <T>
         * @param <A>
         * @return
         */
        public <T, A> T getData2(T arg){
            T data = arg;
            return data;
        }
    
        /**
         * 如果静态方法中使用类 类中的泛型
         *      这种使用时错误的
         *
         * 如果必须在 静态方法 中使用泛型 T
         *      则该泛型 T 必须是静态方法的泛型
         *      不能是类的泛型
         *
         * @param arg
         * @return
         */
        public static <T> T getData3(T arg){
            T data = arg;
            return data;
        }
    }
    
    展开全文
  • 个人观点而已,没有查资料考究过,有人说Java泛型无法写静态方法,也有说可以写,但是必须在static后加上< T >。 而我认为泛型是完全可以写静态方法,并且static后加上< T >并不是必须的 package hello...
  • 静态泛型方法定义: public static <T> T deserialize(byte[] byteArray) { ObjectInputStream oip = null; try { oip = new ObjectInputStream(new ByteArrayInputStream(byteArray)); @...
  • 不能用static修饰泛型成员变量 静态方法和变量 不用实例化就能调用。 public void set(M key) { this.key = key; } public M fun4() {// 同样不是泛型方法,因为 方法中没有加<M> M是声明的时候加的 ...
  • 众所周知,HttpClient我们通常会把他封装成一个工具,工具应保持开闭原则(虽然这里只是一个简单的工具,没有使用设计模式,嘿嘿嘿),所以这就否定了在工具中单独加一个方法来适应返回值为JSONArray....
  • Java泛型静态方法中的使用

    万次阅读 2017-08-17 21:39:23
    我们在静态方法中使用泛型的时候,我们需要在static 后面加上泛型标识
  • Java静态泛型方法

    2021-03-11 10:59:35
    下面代码演示了 静态泛型方法怎么写, 数组分割工具,兼容任何数据类型 ```java package com.freestyle.common.utils; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java...
  • 泛型and静态方法

    2021-11-22 10:23:20
    泛型类静态方法 v.s. 静态的泛型方法
  • 返回类型的静态方法中的泛型似乎与继承相处得不好.请看下面的代码:class ClassInfo {public ClassInfo(Class clazz) {this(clazz,null);}public ClassInfo(Class clazz, ClassInfo super C> superClassInfo) {}}...
  • 目录标题泛型引入1. 泛型类特点2. 最简单泛型类3. 泛型方法4. 泛型接口5. 泛型类可是同时设置多个类型参数6. 泛型的类型参数可以是泛型类7...这样就解决了多个相似的方法、接口 )创建的问题,一个泛型类即可代替所
  • 一、泛型类用法、 二、泛型方法用法、 三、泛型通配符 、 四、泛型安全检查、
  • java 泛型应用,通用返回,泛型方法,泛型静态方法泛型简介应用示例静态方法增加泛型参数调用静态公有方法对比调用非静态公有方法(成员方法) 泛型简介 这里不多说明,详见 java泛型入门 应用示例 以下皆用此通用...
  • 分享给大家供大家参考,具体如下:Java泛型类的定义一 点睛泛型定义的语法如下:[访问修饰符] class 名称 泛型的主要作用在于被实例化后,传入具体的类型参数,对的成员属性的类型和成员方法的参数类型和...
  • Java 泛型 一、概述 Java 泛型(generics)是 JDK 1.5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许开发者在编译时检测到非法的类型。 1.1 什么是泛型泛型,即参数化类型。 一提到参数,...
  • JAVA容器之泛型类泛型方法
  • 主要介绍了Java泛型的用法及T.class的获取过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java静态方法使用泛型

    2022-04-04 11:51:45
    import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.HashMap; import java.util.List; public class StaticMethod { public static void main(String[] args...
  • 1、泛型是什么 首先告诉大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢?先看看下面这段代码: ArrayList<String> strList = new ArrayList<String>(); ArrayList<Integer> int...
  • 转自:...一、泛型类定义及使用 public 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() {
  • java泛型: 泛型简介 泛型 限制泛型可用类型 类型通配声明 泛型方法 问题: 如果我们需要产生多个对象,每个对象的逻辑完全一样,只是对象内的成员变量的类型不同。那我们该如何去做?如果按照正常的做法就要...
  • 我有一个课程如下:public class MyConverter {public T convert (Object o,String typeidentifier,T... do some conversions such as a java array to an ArrayList or vice versa... based on a typeidentifier Sy...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,523
精华内容 33,809
关键字:

java 泛型类的静态方法

java 订阅