用法  import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.List;  public class StaticMethod {      public static void main(String[] args) {         System.out.println(test("aaaaa"));  //aaaaa  基本用法         System.out.println(test1("aa").get(0).equals("aa"));    //true  用于内部包装         System.out.println(test2(new HashSet(), Collection.class).size());  //0 用于强制转换类型         System.out.println(test3("bbbbb")); //bbbbb   装神弄鬼     }      public static T test(T obj){         return obj;     }      public static List test1(T obj){         List list = new ArrayList();         list.add(obj);         return list;     }      public static T test2(Object str, Class obj){         return (T)str;     }      public static B test3(B obj){         return obj;     }  }      原文地址：https://blog.csdn.net/m18870420619/article/details/79929316

我们在静态方法中使用泛型的时候，我们需要在static 后面加上<T>泛型标识，下面是我给出的一个例子
package demo;

import java.util.Date;

/**
 * created by yuyufeng on 2017/8/17.
 */
public class HelloService<T> {

    void sayHello1(T t) {
        System.out.println("hello: " + t);
    }

   /* static void sayHello2(T t) {
        System.out.println("hello: " + t);
    }
*/
    static <T> void sayHello3(T t) {
        System.out.println("hello: " + t);
    }

    public static void main(String[] args) {
        HelloService<Date> helloService = new HelloService<>();
        helloService.sayHello1(new Date());

        HelloService.sayHello3(new Date());
    }
}

/*
运行结果：
hello: Thu Aug 17 21:38:02 CST 2017
hello: Thu Aug 17 21:38:02 CST 2017
 */
如果不加，会报错。

前言：当工具类对多个模型类进行排序，比较等操作的时候，需要书写大量重复代码，因为懒人总要想怎么省事的，所以考虑使用泛型这个玩意简化代码
案例：当前存在两个模型类，Fruit和Person，他们都需要排序方法而且业务逻辑各不相同，因此需要分别写两个排序方法，但因为排序相同的地方太多，唯一的区别就是判断两个对象的大小关系，于是在此做简化操作。
执行步骤：
1、编写模型类接口 interface Model
1 public interface Model{2     public intcompareTo(T model);3 }
这里仅需要定义一个比较的方法
2、编写Person类 class Person
1 public class Person implements Model{2     privateString name;3
4     publicPerson(String _name) {5         this.name =_name;6 }7
8 @Override9     public intcompareTo(Person _person) {10         return this.name.compareToIgnoreCase(_person.name);11 }12 }
Fruit的代码我就不放上来了，因为为了举例我这俩的比较方法写的是一样的，但是实际业务代码可能是不一样的
3、编写工具类 class Sort
1 public classSort {2
3     public static > void sort(Listlist) {4         for (int i = 0; i < list.size() - 1; i++) {5             for (int j = i; j < list.size(); j++) {6                 if (list.get(i).compareTo(list.get(j)) > 0) {7                     T swap =list.get(i);8 list.set(i, list.get(j));9 list.set(j, swap);10 }11 }12 }13 }14 }
随便找了个排序算法就套进去了
然后就是主函数的调用
1 public classMain{2     public static voidmain(String[] args){3         LinkedList list = new LinkedList<>();4         list.add(new Person("admin"));5         list.add(new Person("root"));6         list.add(new Person("huawei"));7         list.add(new Person("cisco"));8 Sort.sort(list);9         for(Person item : list) {10 System.out.println(item.toString());11 }12 }13 }
4、Fruit类只要按照Person类一样实现Model的compareTo方法就可以使用Sort.sort方法进行排序了
后记：最开始我的想法是写个Model接口，在接口中写一个compareTo方法，然后形参类型不知道咋写了
如果写Model的话，Person实现compareTo方法的时候形参类型也肯定是Model
我这块的逻辑比较简单，用name字段进行比较，如果在Model接口加上getName方法后，怎么看都不舒服
Model类不一定都有name字段，而且这样Person类就可能会与Fruit类进行比较
虽然可以在逻辑上不这么搞，但是怎么都看得难受啊，于是就想到用泛型搞这玩意

//仅作为学习笔记



/*

//	泛型方法和静态方法泛型

	泛型类定义的泛型 在整个类中有效 如果被方法使用
	那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定

	为了让不同方法可以操作不同类型  而且类型还不确定
	那么可以将泛型定义在方法上 

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


*/

class Demo<T>
{
	public void method(T t)
	{
		System.out.println("method :"+ t);
	}

	public static <W> void staticMethod(W w)
	{
		System.out.println("staticMethod :"+ w);
	}

	public <K> void show( K  k)
	{
		System.out.println("Show :"+ k);
	}

	public <Q> void print(Q q)
	{
			System.out.println("Print :"+ q);
	}
}

class TestDemo
{
	public static void main(String [] arags)
	{
		Demo<Double> d = new Demo<Double>();

		d.method(3.4);
		
		d.staticMethod(true);

		d.show("haha");

		d.print(new Integer(4));
	}
}