精华内容
下载资源
问答
  • 2020-04-21 10:12:06

    静态方法泛型定义<T>只能放在static关键字之后

    更多相关内容
  • 如果被方法是用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同的方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。泛型类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类型了。而第二种可以自己定义。

    展开全文
  • 泛型 泛型简介 泛型可以理解为参数化类型,主要作用在类,方法和接口上。...泛型方法 : 方法有参数 , 方法的参数 可以指定成一些 泛型 ; 泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ; 泛

    泛型

    泛型简介

    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静态泛型使用方法实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • public <T> void fun1(T key) {// 是泛型方法 如果没有就不知道 参数T key 中T类型从何而来 System.out.println("泛型方法 <T>:" + key); } } class F2<K> { public void fun2(K key) {// 不是泛型方法 K是...
    package xxx.xxxx.demo;
    
    public class FanXingZongJie {
    	public static void main(String[] args) {
    		F1 f1 = new F1();
    		f1.fun1("fun1");
    		F2<String> f2 = new F2<String>();
    		f2.fun2("fun2");
    		System.out.println(f2.fun3("fun3"));
    		F3<Integer> f3 = new F3<Integer>();
    		f3.set(1234);
    		System.out.println(f3.fun4());
    		F3.fun6("O(∩_∩);O哈哈~,我又变成String类型了,我和类Class<M>的泛型没有关系。。。");
    		F4.fun7(5678);
    		
    		F5 f5 = new F5();
    		try {
    			System.out.println(f5.fun8(Class.forName("xxx.xxxx.demo.User")) instanceof User);//true
    			System.out.println(f5.fun8(User.class) instanceof User);//true
    			System.out.println(f5.fun8(new User().getClass()) instanceof User);//true
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		} 
    	}
    }
    
    class F1 {
    	public <T> void fun1(T key) {// 是泛型方法 如果没有<T>就不知道 参数T key 中T类型从何而来
    		System.out.println("泛型方法 <T>:" + key);
    	}
    }
    
    class F2<K> {
    	public void fun2(K key) {// 不是泛型方法 K是声明 类的时候创建的类型
    		System.out.println("不是泛型方法:" + key);
    	}
    
    	public K fun3(K key) {// 同样不是泛型方法,因为 方法中没有加<K> K是声明类的时候加的
    		return key;
    	}
    }
    
    class F3<M> {
    	private M key;
    
    	// public static M val; 不能用static修饰泛型成员变量   静态方法和变量 不用实例化类就能调用。
    	public void set(M key) {
    		this.key = key;
    	}
    	public M fun4() {// 同样不是泛型方法,因为 方法中没有加<M> M是声明类的时候加的
    		return this.key;
    	}
    	// public static void fun5(M val) { //会出错误
    	// 因为泛型是要在对象创建的时候才知道是什么类型的,
    	// 而对象创建的代码执行先后顺序是static的部分,然后才是构造函数等等。
    	// 所以在对象初始化之前static的部分已经执行了,
    	// 如果你在静态部分引用的泛型,那么毫无疑问虚拟机根本不知道是什么东西,
    	// 因为这个时候类还没有初始化。因此在静态方法、数据域或初始化语句中,为了类而引用class F3<M>声明的泛型类型参数是非法的
    	// }
    	
    	public static <N> void fun6(N val) {
    		System.out.println("static 静态方法中 声明的独立泛型<N>,可以使用。"+val);
    	}
    }
    
    class F4{
    	public static <H> void fun7(H key) {
    		System.out.println(key);
    	}
    }
    
    class User{
    	private String name;
    	private int age;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "User [name=" + name + ", age=" + age + "]";
    	}
    	
    }
    class F5{
    	public <H>H  fun8(Class<H> h) throws InstantiationException, IllegalAccessException {
    		H hs = h.newInstance();
    		System.out.println(hs);
    		return hs;
    	}
    	public <H> void fun9(Class<H> h) throws InstantiationException, IllegalAccessException {
    		H hs = h.newInstance();
    		System.out.println(hs);
    	}
    }
    
    
    
    
    
    
    
    

    展开全文
  • 静态方法泛型

    千次阅读 2019-10-24 16:21:55
    静态方法有一种情况需要注意一下,那就是在类中的静态方法使用泛型...即:如果静态方法要使用泛型的话,必须将静态方法也定义成泛型方法。 public class StaticGenerator<T> { .... .... /** * 如果在...
  • java静态方法使用泛型

    2022-04-04 11:51:45
    //可以看出与句柄无关,是静态方法自动做出的判断 //在方法中自动进行强制类型转换,语法很特别。 //(这个语句毫无疑问会报错,只是subList这个ArrayList有,而HashSet没有的方法能更明确的展示这个语法) test2...
  • 静态方法泛型

    2021-03-01 16:49:41
    泛型存在的意义就是为了动态指定具体类型,增强灵活性和通用性 静态和非静态之分就在于静态是编译时类型,动态是运行时类型。 Java中的静态变量和静态代码块是在类加载的时候就执行的 实例化对象时,先声明并实例化...
  • // 泛型方法静态方法泛型     泛型类定义的泛型 在整个类中有效 如果被方法使用   那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定     为了让不同方法可以操作不同类型 ...
  • 静态方法使用泛型

    2019-11-12 17:07:46
    静态方法使用泛型 public class Utils { public static<T,V> void method(MyClass1<T> t,MyClass2<V> v){ //... }; } 类Utils上不需要指定泛型; 调用时,不需要指定泛型,可以自动匹配...
  • Java静态方法泛型

    2020-11-26 13:47:55
    泛型类中的静态方法不能使用类的泛型而应该将该方法定义为泛型方法。 在java中泛型只是一个占位符,必须在传递类型后才能使用。就泛型而言,类实例化时才能正真的的传递类型参数,由于静态方法的加载先于类的实例化...
  • 万能设置值 public void setValue<t>(t value) where t : JToken { this.jObject[fieldName] = value;...万能创建不同泛型的对象。 public static JObjectTarget<t> createJObjectTarget<...
  • 静态方法中使用泛型时有一种情况需要注意一下,那就是静态方法无法访问类上定义的 泛型;如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上。 2 语法结构 public 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...
  • 众所周知,HttpClient我们通常会把他封装成一个工具类,工具类应保持开闭原则(虽然这里只是一个简单的工具类,没有使用设计模式,嘿嘿嘿),所以这就否定了在工具类中单独加一个方法来适应返回值为JSONArray....
  • Java静态方法与非静态方法泛型

    千次阅读 2019-06-03 16:01:32
    Java中,非静态方法可以使用类的泛型,也可以定义自己的泛型静态方法由于随着类的加载而加载,不能访问类的泛型(因为在创建对象的时候才确定),因此必须定义自己的泛型类型。 详细请参考:...
  • 泛型and静态方法

    2021-11-22 10:23:20
    泛型类的静态方法 v.s. 静态泛型方法
  • Java静态泛型方法

    万次阅读 2016-09-12 23:48:52
    泛型方法使用 不仅集合中可以使用,在定义类和方法的时候也是经常使用的,但是关于泛型的静态方法使用的场景还是不太多。下面从求两个数的最大数的实现上来看一下它们的简单使用: 普通泛型方法 package me.
  • 返回类型的静态方法中的泛型似乎与继承相处得不好.请看下面的代码:class ClassInfo {public ClassInfo(Class clazz) {this(clazz,null);}public ClassInfo(Class clazz, ClassInfo super C> superClassInfo) {}}...
  • 类中的静态部分能否使用泛型?继承类中的泛型定义会产生哪些问题?
  • 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...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,297
精华内容 45,318
关键字:

静态方法泛型