Question

我有以下三个班级。

SuperClass.java
SubClass1 extends SuperClass
SubClass2 extends SuperClass

我有一个接受SuperClass类型的方法参数的方法。

getResult(SuperClass request){
//Here the request can be of SubClass1 type or SubClass2 type.

}

此处request可以是SubClass1类型或SubClass2类型。

基于请求类型的getResult()内部方法我需要做一些逻辑。

要找出我可以使用instanceof运算符的类型，如下所示。

if(request instanceof SubClass1){
//do something
}else if(request instanceof SubClass2){
//dosomething
}

有没有找到请求类型的最佳方法？

谢谢！

Answer 1

尽量避免使用instanceof关键字。

不鼓励的原因是它不是OOP。对象的调用者/用户应该没有理由知道哪个具体类是一个实例，超出了哪个类型，它被声明为变量。如果在子类中需要不同的行为，请添加一个方法并以不同方式实现它们。

基本方式：我会写一些类似的东西：

enum Types{ SUB_1, SUB_2 }

public class SubClass1 extends SuperClass{
  public Types type = Types.SUB_1;
} 

public class SubClass2 extends SuperClass{
  public Types type = Types.SUB_2;
}

和：

if(Types.SUB_1 == request.type){
  //do something
}else if(Types.SUB_2 == request.type){
  //do something
}

正确的方式（从我看来）我会在你的情况下使用多态。

多态性 - 发送到不同对象的相同消息会导致依赖的行为关于接收消息的对象的性质。

意思是：

 public interface SuperClassItf{
  public void doStuff();
 }

 public class SubClass1 extends SuperClassItf{
     public void doStuff(){
          // do 1
       }
    } 

    public class SubClass2 extends SuperClassItf{
     public void doStuff(){
        // do 2
     }
    }

主要

getResult(SuperClassItf request){ request.doStuff(); //polymorphic method call }

Answer 2

为什么不将getResult（）放在接口中，让逻辑在抽象的SuperClass具体子类中进行？

public interface ResultProvider {
    public Result getResult();
}

public abstract class SuperClass implements ResultProvider {
    ...
}

public SubClass1 extends SuperClass {
    public Result getResult() {
        ...
    }
}

public SubClass2 extends SuperClass {
    public Result getResult() {
        ...
    }
}

Answer 3

另一种方法是运行时多态。以下是您的示例代码。

public class SuperClass
{
public void doSomething(){}
}
public class SubClass1 extends SuperClass{
  public void doSomething(){}
} 

public class SubClass2 extends SuperClass{
  public void doSomething(){}
}

getResult(SuperClass request){

 request.doSomething();

}

Answer 4

来自我的评论：

气馁的唯一原因是因为它表明了多态行为未得到适当利用，有点像非OO编程。但这并不意味着你永远不必使用它，在某些情况下你可以使用它。

运行时多态性

现在你可以利用Overriding（Runtime polymorphism）这是一种正确的做事方式。

abstract class SuperClass{
   public abstract Result getResult();
}

class SubClass1 extends SuperClass{
   @Override
   public Result getResult(){
      //logic
   }
}


class SubClass2 extends SuperClass{
   @Override
   public Result getResult(){
      //logic
   }
}

//calling 

getResult(SuperClass request){
   Result r = request.getResult();
}

决定请求类的类型？

4 个答案:

运行时多态性