请完成整个问题以获得完整的想法。

先让类(class)Box给出如下:-

public class Box <T>{
    private T t;

    public  void  set(T t){
        this.t  = t;
        System.out.println("value:\n");
        System.out.printf("%s", t.toString());
    }
    public T get() {
        return t;
    }
    static int retInt(){
        return 5;

    }
     public <U extends Number> void inspect(U u){
            System.out.println("T: " + t.getClass().getName());
            System.out.println("U: " + u.getClass().getName());
        }

}

通用类 Util如下所示:-

public class Util<T>{
    private T t;

    //Generic method
    public  <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }

    /* Static generic or non-generic methods can be declared in generic class 
       but they can not make use of generic parameter type(as generics static    
       methods  using class type variable must know the type argument 
       (i.e value of type parameter); and knowledge of type argument is
       possible only when object of same generic class are instantiated  
       (meaning assigning value of generic type parameter <T> or better to 
       say declared object have it's type argument; for example 
       as in List<T> replace T with Integer,String, Float etc);
       but static method may be called without having 
       instance of class; so such declaration for static generic method are
       not allowed) here it is <T>;  like for example as shown below  

       public static int checkFun(T t){
          return 5;
       } // this generate compiler error complaining "can not make static
        //  reference to non-static type T".           
    */


    public static <K> boolean cmp(Box<K> b1, Box<K> b2){
        // implement comparator to compare but here 
        return true;
    }

    // Inner class Pair
    public class Pair <K, V> {
        private K key;
        private V value;

        // Generic constructor
        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }

        public void setKey(K key) {
            int i = 6;
            if(i >4 || i<9);
            this.key = key;
        }

        public void setValue(V value) {
            this.value = value;
        }

        public K getKey(){
            return key;
        }

        public V getValue(){
            return value;
        }

    }

    public void main1() {           
        //The complete syntax for invoking this method would be:
        // <Integer, String>   new Util<T>().
        Pair<Integer, String> p1 = new Pair<Integer,String>(1, "apple");
        Pair<Integer, String> p2 = new Pair<Integer, String>(2, "pear");
        boolean same = compare(p1, p2);
        //boolean same = true;
        if(same)System.out.println("it is true: they are the same");
        else System.out.println("nah! they are not the same...");

        //boolean sm = compare();
    }

    public static void main  (String[] args) /*throws FileNotFoundException */{
        //new Util<Integer>(). main1();

        Util<Integer> util = new Util<>();
        util.main1();
    }  
}

上面的代码编译和执行都很好，我的不适在于:

如果我们添加 static方法修饰符

public <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2)    -------(1)
// called in method main1() 

并制作它

public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2)     -------(2) 

然后编译器会报错Cannot make a static reference to the non-static type Pair 而similar method

 public static <K> boolean cmp(Box<K> b1, Box<K> b2)    -------(3)

这也是静态的，但不会提示。即使我们没有使用类型参数 <T>在这两种方法中 but一个big but在我们谈论的方法中 eq-1它使用的参数来自内部类 Pair (所以我的歧义推理可以引用这个特性来解释)。

但还是；从逻辑上讲，我觉得添加修饰符 static eq-1 中的方法不应生成编译时错误，因为 eq-2 中的方法在哪里被调用时，该方法将负责使用正确的参数调用 eq-2 中的方法并且应该允许它像静态方法一样被调用。

问题:- 方法没有使用静态修饰符的解释是什么:

public <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2)

感谢您的帮助。

最佳答案

原因是 Util 类上的类型参数和内部类 Pair 是非静态的。因为 Pair 是一个非静态内部类，它可以使用 Util 的 T 类型参数(尽管在这种情况下它没有)。因此，当使用 Pair 时，有必要指定一个 T，或者通过在 Util 实例的上下文中访问它(其中 T 是隐式可用的)，或者通过通过特定的 Util<T> 访问它来限定。 ，例如Util<Integer>.Pair<String,Object> .另一种思考方式是 Pair 的类型取决于 Util 和 Util<String>.Pair<K,V> 的类型参数。与 Util<Object>.Pair<K,V> 不兼容.

要保持Util上的类型参数T，同时保持Pair为非静态内部类，可以将compare的签名改成

public static <T, K, V> boolean compare(Util<T>.Pair<K, V> p1, Util<T>.Pair<K, V> p2)

或

public static <K,V> boolean compare(Util<?>.Pair<K,V> p1, Util<?>.Pair<K,V> p2)

这是可能的，因为 T 的实例化与方法的主体无关。

作为替代方案，由于 Pair 不引用 Util 内部的任何内容(非静态)，您可以将 Pair 的定义更改为

public static class Pair <K, V> { /* ... */ }

最后为了完整性，如果Util没有类型参数那么

public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2)

和

public class Pair<K, V> { /* ... */ }

就好了。

关于java - 为什么我不能在泛型类上静态引用内部类的静态方法？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23832497/