Java 如何在方法中使用泛型参数以将参数类型限制为某些特定的类类型？

我有一个名为

getInfo（）

的方法。它只有一个参数，但该参数只能有两种可能的类型，

Exception

或自定义类

CLAZZ\u A

。因此，当我定义这个方法

getInfo（）

时，我想将其参数类型限制为这两种类型。我能做什么？我相信Java泛型类型可能有用，但我不知道如何做到这一点。

可能只是过载：

getInfo(Exception e){}
getInfo(MyClass mc){}

这样，您将在编译时知道您的参数是什么，并保证它是两个可接受的参数之一。如果行为足够相似，你可以通过施法从另一个中调用一个

如果这是不吸引人的，考虑让对象扩展异常（如果这是相关的），那样的方式<代码> GETFIN（异常E）{} /代码>就足够了。

可能只是过载：

getInfo(Exception e){}
getInfo(MyClass mc){}

这样，您将在编译时知道您的参数是什么，并保证它是两个可接受的参数之一。如果行为足够相似，你可以通过施法从另一个中调用一个

---

如果这是不吸引人的，考虑让对象扩展异常（如果这是相关的），这样的方式<代码> GETFIN（异常E）{} /Cult>就足够了。泛型中的

< P>，一个类型参数可以有多个界限：因此，如果您想将一个方法的参数限制为两种类型，请尝试以下方法。（CLAZZ_A必须是一个接口才能工作）

class-SomeClass{
无效剂量测定法（T）{
// ...
}    
}

在泛型中，类型参数可以有多个边界，其形式为：

。因此，如果您想将一个方法的参数限制为两种类型，请尝试以下方法。（CLAZZ_A必须是一个接口才能工作）

class-SomeClass{
无效剂量测定法（T）{
// ...
}    
}

如果您不喜欢重载，可以创建类似于

Try

monad的内容。这样的单子通常表示某件事的成功结果，或者表示某个异常所描述的失败。可能这与您的情景非常接近

// Represents either some successful result of type T or failure
public class Try<T> {
  final T value;
  final Exception ex;

  private Try(T value, Exception ex) {
    this.value = value;
    this.ex = ex;
  }

  // Construct Try with normal value
  public static <T> Try<T> of(T value) {
    return new Try<>(value, null);
  }

  // Construct an exceptional Try with given exception
  public static <T> Try<T> exceptional(Exception ex) {
    return new Try<>(null, ex);
  }

  // Run given Callable and construct either successful Try or exceptional
  // based on result
  public static <T> Try<T> run(Callable<T> c) {
    try {
      return of(c.call());
    }
    catch(Exception ex) {
      return exceptional(ex);
    }
  }

  // Return true if this Try represents successful result
  public boolean isSuccess() {
    return ex == null;
  }

  // return stored value or throw an exception if this Try is exceptional
  public T get() throws Exception {
    if(ex != null) throw ex;
    return value;
  }

  // Returns result of this Try or supplied default result if this Try
  // is exceptional
  public T getOrDefault(T defaultValue) {
    if(ex != null) return defaultValue;
    return value;
  }

  // Returns exception of exceptional Try or null for successful Try
  public Exception getException() {
    return ex;
  }
}

或

或（使用Java-8语法）

---

因此，现在您有了严格的类型控制：您只能传递

Try

对象，该对象可以保存

CLASS\u A

对象或

异常。使用
Try
方法，您可以在
getInfo
方法中方便地处理这两种情况，并且不需要任何类型强制转换。
如果您不喜欢重载，可以创建类似于
Try
monad的内容。这样的单子通常表示某件事的成功结果，或者表示某个异常所描述的失败。可能这与您的情景非常接近

// Represents either some successful result of type T or failure
public class Try<T> {
  final T value;
  final Exception ex;

  private Try(T value, Exception ex) {
    this.value = value;
    this.ex = ex;
  }

  // Construct Try with normal value
  public static <T> Try<T> of(T value) {
    return new Try<>(value, null);
  }

  // Construct an exceptional Try with given exception
  public static <T> Try<T> exceptional(Exception ex) {
    return new Try<>(null, ex);
  }

  // Run given Callable and construct either successful Try or exceptional
  // based on result
  public static <T> Try<T> run(Callable<T> c) {
    try {
      return of(c.call());
    }
    catch(Exception ex) {
      return exceptional(ex);
    }
  }

  // Return true if this Try represents successful result
  public boolean isSuccess() {
    return ex == null;
  }

  // return stored value or throw an exception if this Try is exceptional
  public T get() throws Exception {
    if(ex != null) throw ex;
    return value;
  }

  // Returns result of this Try or supplied default result if this Try
  // is exceptional
  public T getOrDefault(T defaultValue) {
    if(ex != null) return defaultValue;
    return value;
  }

  // Returns exception of exceptional Try or null for successful Try
  public Exception getException() {
    return ex;
  }
}

或

或（使用Java-8语法）

因此，现在您有了严格的类型控制：您只能传递
Try
对象，该对象可以保存
CLASS\u A
对象或
异常。使用
Try
方法，您可以在
getInfo
方法中方便地处理这两种情况，并且不需要任何类型转换。
除非
CLAZZ\u A
是一个接口，否则这将不起作用。更多信息。在这种情况下，泛型没有什么意义。由于这将描述联合类型，
CLAZZ\u a
不太可能也是一个
异常
，或者他们可以只使用传入
异常
的方法。除非
CLAZZ\u a
是一个接口，否则这将不起作用。更多信息。在这种情况下，泛型没有什么意义。由于这将描述联合类型，
CLAZZ_a
不太可能也是一个
异常
，或者他们可以使用传入
异常
的方法。重载似乎是这里最实用的选择，但我不会让
MyClass
扩展
Exception
，除非它绝对有意义。重载似乎是这里最实用的选择，但我不会让
MyClass
扩展
Exception
，除非它绝对有意义。
getInfo(Try.of(new CLAZZ_A()));

getInfo(Try.exceptional(new Exception()));

getInfo(Try.run(() -> fetchTheCLAZZ_A()));