覆盖方法，以便参数需要一个子类 [英] Override method so that a parameter requires a subclass

问题描述

我有一个抽象超类和2个扩展它的类

  public abstract class MyAbstract {} 
 
 public class A extends MyAbstract {} 
 
 public class B extends MyAbstract {} 
  

我有一个接口，它有一个方法，它接受MyAbstract的子类作为其参数。 b $ b< T扩展了MyAbstract> void someMethod（T param）;
}

然后我有一个实现该接口的类

  public class AnotherClass implements MyInterface {
 @Override 
< T extends MyAbstract> void someMethod（T param）{} 
} 
  

但我只想让一个特定的要在该方法中使用 MyAbstract 的子类。

以下是我迄今为止尝试的一些事情：

 < T延伸A> void someMethod（T param）; //不重写方法
 
 void someMethod（A param）; //不重写方法
  

是否有一个接口采用泛型参数，该接口的实现者指定了该参数的一个更受限制的版本或者这是不可能的？

解决方案

是的， 实际上采用泛型参数：

  public interface MyInterface< T extends MyAbstract> {
 void someMethod（T param）; 
} 
  

然后你可以限制它在哪里使用：

  public class AnotherClass< T extends A>实现MyInterface< T> {
 @Override 
 public void someMethod（T param）{} 
} 
  

或
$ b

  public class AnotherClass implements MyInterface< A> {
 @Override 
 public void someMethod（A param）{} 
} 
  

I have an abstract super class and 2 classes that extend it

public abstract class MyAbstract {}

public class A extends MyAbstract {}

public class B extends MyAbstract {}

I have an interface which has a method that takes a subclass of MyAbstract as its parameter

public interface MyInterface {
    <T extends MyAbstract> void someMethod(T param);
}

I then have a class that implements that interface

public class AnotherClass implements MyInterface {
    @Override
    <T extends MyAbstract> void someMethod(T param) {}
}

But I only want to allow a specific subclass of MyAbstract to be used in the method.

Here are a couple of the things I tried so far:

<T extends A> void someMethod(T param); //doesn't override the method

void someMethod(A param); //doesn't override the method

Is there anyway to have a interface take a generic parameter and the implementer of that interface specify a more restricted version of that parameter or is this simply not possible?

解决方案

Yes, you make the interface itself actually take the generic parameter:

public interface MyInterface<T extends MyAbstract> {
    void someMethod(T param);
}

Then you can limit it where used:

public class AnotherClass<T extends A> implements MyInterface<T> {
    @Override
    public void someMethod(T param) {}
}

Or:

public class AnotherClass implements MyInterface<A> {
    @Override
    public void someMethod(A param) {}
}

这篇关于覆盖方法，以便参数需要一个子类的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！