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.

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

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

用法 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