Java if语句中的多个instanceof

我有一个if语句，有多个instanceof check。例如：

if (object instanceof Object1) {
    // do something
} else if (object instanceof Object2) {
    // to something else
} else if (object instanceof Object2) {
    // and something else
} ...

---

解决if-else查询的更优雅的方法是什么？

OOP中的最佳实践是将逻辑放入

对象本身，并使其实现一个接口：

public interface MyLogic{
    public void doLogic();
}

public abstract class Employee {
     public abstract int calcSalary(...);
}

界面：

public interface MyLogic{
    public void doLogic();
}

public abstract class Employee {
     public abstract int calcSalary(...);
}

第一个目标：

public class Object1 implements MyLogic{
  public void doLogic(){// logic 1 here}
}

第二个目标：

public class Object2 implements MyLogic{
  public void doLogic(){// logic 2 here}
}

现在只需将逻辑移到对象本身，所有的
if
语句只需使用

object.doLogic(); // make sure object is from type MyLogic, if not, cast it

OOP中的最佳实践是将逻辑放入
对象本身，并使其实现一个接口：

public interface MyLogic{
    public void doLogic();
}

public abstract class Employee {
     public abstract int calcSalary(...);
}

界面：

public interface MyLogic{
    public void doLogic();
}

public abstract class Employee {
     public abstract int calcSalary(...);
}

第一个目标：

public class Object1 implements MyLogic{
  public void doLogic(){// logic 1 here}
}

第二个目标：

public class Object2 implements MyLogic{
  public void doLogic(){// logic 2 here}
}

现在只需将逻辑移到对象本身，所有的
if
语句只需使用

object.doLogic(); // make sure object is from type MyLogic, if not, cast it

这似乎是多态性，所以您可以为每个对象创建一个接口并实现它

interface ObjectToBeImplemented{
 method();
}

class Object1 implements ObjectToBeImplemented{ 
 @Override
 method(){...}
}
class Object2 implements ObjectToBeImplemented{ 
 @Override
 method(){...}
}

class Object3 implements ObjectToBeImplemented{ 
 @Override
 method(){...}
}

这似乎是多态性，所以您可以为每个对象创建一个接口并实现它

interface ObjectToBeImplemented{
 method();
}

class Object1 implements ObjectToBeImplemented{ 
 @Override
 method(){...}
}
class Object2 implements ObjectToBeImplemented{ 
 @Override
 method(){...}
}

class Object3 implements ObjectToBeImplemented{ 
 @Override
 method(){...}
}

这是接口的典型用法。将接口视为定义实例的类型。因此，您知道特定类型的所有实例都可以执行特定任务。此时，您并不真正关心对象的具体类，您只知道它有特定的接口可供您使用

例如：

public interface Worker {
     public void doWork();
}

public class Object1 implements Worker {
    public void doWork() {
      // work for this specific object
    }
}

public class Object2 implements Worker {
    public void doWork() {
      // work for this specific object
    }
}

public class Object3 implements Worker {
    public void doWork() {
      // work for this specific object
    }
}

那么您的if语句将替换为

obj.doWork();

这是接口的典型用法。将接口视为定义实例的类型。因此，您知道特定类型的所有实例都可以执行特定任务。此时，您并不真正关心对象的具体类，您只知道它有特定的接口可供您使用

例如：

public interface Worker {
     public void doWork();
}

public class Object1 implements Worker {
    public void doWork() {
      // work for this specific object
    }
}

public class Object2 implements Worker {
    public void doWork() {
      // work for this specific object
    }
}

public class Object3 implements Worker {
    public void doWork() {
      // work for this specific object
    }
}

那么您的if语句将替换为

obj.doWork();

这感觉像是错过了多态性的机会

这是一组类与它们的超类/接口共享相同的方法签名的地方，因此调用它的代码不需要知道它是哪种类型

无多态性：

Employee employee = ...;
if(employee instanceof Doctor) {
     salary = calcDoctorSalary(...);
} else if(employee instanceof Nurse) {
     salary = calcNurseSalary(...);
}

Employee employee = ...;
salary = employee.calcSalary(...);

多态性：

Employee employee = ...;
if(employee instanceof Doctor) {
     salary = calcDoctorSalary(...);
} else if(employee instanceof Nurse) {
     salary = calcNurseSalary(...);
}

Employee employee = ...;
salary = employee.calcSalary(...);

魔法进入了子类
calcSalary（）
在超类中是抽象的，或者在接口中是方法签名：

public interface MyLogic{
    public void doLogic();
}

public abstract class Employee {
     public abstract int calcSalary(...);
}

。。。或者

public interface Employee {
    public int calcSalary(...);
}

然后类型相关逻辑进入子类：

public class Nurse implements Employee {
    @Override
    public int calcSalary(...) {
         // code specific to nurses goes here.
    }
}

无论是扩展一个类，还是实现一个接口，您都将从经验中学到一些东西。通常，当一个人没有从一个接口开始时，他会在以后后悔。
这感觉像是错过了多态性的机会

这是一组类与它们的超类/接口共享相同的方法签名的地方，因此调用它的代码不需要知道它是哪种类型

无多态性：

Employee employee = ...;
if(employee instanceof Doctor) {
     salary = calcDoctorSalary(...);
} else if(employee instanceof Nurse) {
     salary = calcNurseSalary(...);
}

Employee employee = ...;
salary = employee.calcSalary(...);

多态性：

Employee employee = ...;
if(employee instanceof Doctor) {
     salary = calcDoctorSalary(...);
} else if(employee instanceof Nurse) {
     salary = calcNurseSalary(...);
}

Employee employee = ...;
salary = employee.calcSalary(...);

魔法进入了子类
calcSalary（）
在超类中是抽象的，或者在接口中是方法签名：

public interface MyLogic{
    public void doLogic();
}

public abstract class Employee {
     public abstract int calcSalary(...);
}

。。。或者

public interface Employee {
    public int calcSalary(...);
}

然后类型相关逻辑进入子类：

public class Nurse implements Employee {
    @Override
    public int calcSalary(...) {
         // code specific to nurses goes here.
    }
}

无论是扩展一个类，还是实现一个接口，您都将从经验中学到一些东西。通常，当一个人没有从一个接口开始时，他会在以后后悔。
他们（Object1/2/3）共享同一个接口吗？Object
从哪里来？请显示更多的代码。更优雅的方法是使用继承和虚拟方法。它们（Object1/2/3）共享相同的接口吗？对象从哪里来？请显示更多代码。更优雅的方法是使用继承和虚拟方法。嗯，我怀疑
对象
是否是接口名称的好选择（即使它只是一个示例）：-）嗯，我怀疑
对象
是否是接口名称的好选择（即使它只是一个示例）：-）问题是，我无权更改Object1、Object2等。它们不可能实现接口。还有其他解决方案吗？您可以使用java引用并使用从类名派生的方法创建一个类，并使用Reflection运行它们。问题是，我无权更改Object1、Object2等。它们不可能实现接口。还有其他解决方案吗？您可以使用java引用，创建一个具有从类名派生的方法的类，并使用反射运行它们