我创建了界面TwoMethods.源代码:

interface TwoMethods<T>
{
    public void method(T t);
}

然后我创建了实现这个接口的类,在反汇编后我看到了2个方法.类:

class A implements TwoMethods<A>
{
    @Override
    public void method(A a) {}
}

拆解后:

class A implements TwoMethods<A> {
   A();
   public void method(A); //first
   public void method(java.lang.Object); //second
}

同样适用于Comparable界面.为什么当我创建参数化接口时,我有两种方法.总是,当我使用参数时？我还有另外的方法Object作为参数？

假设我有以下类层次结构:

interface Collection<E>
{
    Collection<E> $plus(E element)
}

interface MutableCollection<E> extends Collection<E>
{
    @Override
    MutableCollection<E> $plus(E element)
}

interface Set<E> extends Collection<E>
{
    @Override
    Set<E> $plus(E element)
}

interface MutableSet<E> extends Set<E>, MutableCollection<E>
{
    @Override
    default MutableSet<E> $plus(E element)
    {
        // ... implementation
    }
}

abstract class AbstractArraySet<E> implements Set<E>
{
    // ... no $plus(...) implementation
}

class ArraySet<E> extends AbstractArraySet<E> implements MutableSet<E>
{
    // ... no $plus(...) implementation
}

如您所见,只有MutableSet该类提供了该$plus方法的实现.在测试用例中,我在类型的实例上调用此方法ArraySet.测试总是在CI环境中传递,而它总是AbstractMethodError在我的本地环境中失败.在这两种情况下,我都在使用Gradle(2.7).

错误: …

具有以下定义:

public interface BaseService<T, ID> {

    T findOne(ID id);

}

public class BaseServiceImpl<T,ID extends Serializable> implements BaseService<T, ID> {

    @Override
    public T findOne(ID id) {
        return null;
    }

}

为什么BaseServiceImpl.class.getDeclaredMethods()返回2种方法:

• public java.lang.Object BaseServiceImpl.findOne(java.io.Serializable)
• public java.lang.Object BaseServiceImpl.findOne(java.lang.Object)

有没有办法过滤掉这些？

描述

我有一个奇怪的问题，其中Method::getGenericReturnType()无法检索通用类型信息。

这是最小化版本：

public class Test {
    public static void main(String[] args) {
        Method method = B.class.getMethods()[0]; // foo() method inherited from A
        System.out.println(method.getGenericReturnType());
    }

    static class A {
        public List<String> foo() { return null; }
    }

    public static class B extends A {}
}

输出是

java.util.List

没有任何通用类型信息。这对我来说似乎很奇怪。

但是，将As 的可见性更改为public并正确地给出

java.util.List<java.lang.String>

题

我不知道这是错误还是实际预期的行为。如果是预期的，其背后的原因是什么？

我正在使用来自 AdoptOpenJDK 的 OpenJDK 15：

// javac
javac 15.0.1

// java
openjdk version "15.0.1" 2020-10-20
OpenJDK Runtime Environment AdoptOpenJDK (build 15.0.1+9) …

我正在编写一个应用程序，用于检查该方法是顺数还是桥接。为了测试该应用程序，我在存根中添加了各种方法。但是对于任何一种方法，该块都不会包含在测试用例中。存根包含诸如validate（Object o）等方法，其方法与其他任何普通的Java类一样。

我应该在存根中添加哪种方法，以便覆盖该行？

代码：

     Method[] methods = inputClass.getMethods();
        for (Method method : methods) {

        if (method.isSynthetic() || method.isBridge()) {
            isInternal = true;
        }
       // More code.
     }

我想知道为什么Java编译器会在foo这里为该方法添加桥接方法：

public class Outer {

  class SuperClass {
    public void foo() { }
  }

  public class SubClass extends SuperClass { }
}

该foo方法被编译为public在SuperClass类型。然而，该SubClass方法将方法重新定义为通向相同方法的桥梁。我想知道为什么需要这座桥。