Question

我想编写一个动态接收不同类型对象的方法。一旦我收到动态对象，我就会在内部使用逻辑方法根据与该对象关联的属性执行某些操作。它将如下所示：

MainClass{
class1 obj1;//all these are pojo
class2 obj2;
class3 obj3;
method1(<dynamic_object>)
}
    method1(<dynamic_object>){
        if(dynamic_object.property 1 == true){
            callmethod2(dynamic_object.property 1)
        }
        else{
            callmethod3(dynamic_object.property 1)
        }
    }

此处 dynamic_objects 属于不同类型。我怎样才能在Java中实现这一目标？ 我不想在这里使用反射。

Answer 1

为了识别对象的类型，您可以使用instanceof运算符。

 private void instanceOfMethodExample(Object object){
    if(object instanceof String)
        print("Its a String!");
    else if(object instanceof Integer)
        print("Its an Int!");
    else
        print("Its a " + object.getClass().getName()); // by calling getClass().getName() method you take the class name of the object as a String
}

Answer 2

使用访客模式，简而言之，您可以使用以下内容：

public class Visitor {

    interface UserVisitor {
        public void visit(CarUser user1);

        public void visit(BusUser user2);
    }


    static class VehicleVisitor implements UserVisitor {

        private Car vehicle;
        private Bus bus;

        VehicleVisitor(Car vehicle, Bus bus) {
            this.vehicle = vehicle;
            this.bus = bus;
        }

        public void visit(CarUser user1) {
            user1.setCar(vehicle);
        }

        public void visit(BusUser user2) {
            user2.setBus(bus);
        }
    }

    interface UserVisitorClient {
        void accept(UserVisitor visitor);
    }

    static class CarUser implements UserVisitorClient {

        private Car car;

        public void accept(UserVisitor visitor) {
            visitor.visit(this);
        }

        public void setCar(Car car) {
            this.car = car;
        }

        public Car getCar() {
            return car;
        }
    }

    static class BusUser implements UserVisitorClient {

        private Bus bus;

        public void accept(UserVisitor visitor) {
            visitor.visit(this);
        }

        public void setBus(Bus bus) {
            this.bus = bus;
        }

        public Bus getBus() {
            return bus;
        }
    }

    static class Car {

        @Override
        public String toString() {
            return "CAR";
        }
    }
    static class Bus {

        @Override
        public String toString() {
            return "BUS";
        }
    }

    public static void main(String[] args) {
        List<UserVisitorClient> users = new ArrayList<UserVisitorClient>();
        CarUser user1 = new CarUser();
        users.add(user1);
        BusUser user2 = new BusUser();
        users.add(user2);

        for (UserVisitorClient user : users) {
            VehicleVisitor visitor = new VehicleVisitor(new Car(), new Bus());
            user.accept(visitor);
        }

        System.out.println(user1.getCar());
        System.out.println(user2.getBus());
    }
}

这只是一个例子。但它表明，基本上你可以使用这种模式来支持你想要完成的事情。

在您的代码中，您可以：

void method1(VisitorClient client) {
    client.accept(someVisitor);
}

这将允许您达到更多面向对象的解决方案，依赖于多态而不是反射或实例。

Answer 3

最好的选择是使用通用界面

interface HasProperty {
   boolean isSet();
}

void method1(HasProperty object) {
     if (object.isSet())
        method2(object);
     else
        method3(object);
}

或者更好的方法是调用执行操作。

interface MethodOne {
   void method1();
}

MethodOne object = ...
object.method1(); // calls the appropriate method for this object.

Answer 4

使用所有对象的超类 - ＆＃34; 对象＆＃34;并使用 instanceof 运算符检查对象的类型。

method1(Object obj){
if(obj instanceof dynamic_object){
    callmethod2(dynamic_object.property 1)
}
else if(obj instanceof dynamic_object2) {
    callmethod3(dynamic_object2.property 1)
}

}

Answer 5

编辑：鉴于您新发布的代码，您甚至可能只希望为动态对象使用通用接口或基类。

接口：

public interface CommonInterface {
    boolean isValid();
    void method1();
    void method2();
    void method3();
}

类示例：

public Class1 implements CommonInterface {
    public boolean isValid() {
        return true;
    }

    public void method1() {
        System.out.println("Method 1");
    }

    public void method2() {
        System.out.println("Method 2");
    }

    public void method3() {
        System.out.println("Method 2");
    }
}

代码：

public void doSomethingWithCommonObjects(CommonInterface object) {
    object.method1();
    if (object.isValid()) {
        object.method2();
    } else {
        object.method3();
    }
}

每个动态对象只需要实现CommonInterface接口，这将为每个要实现的对象强制执行method1（），method2（），method3（）和property1（）签名。

以前的答案详情供参考：

您将不得不使用Java Generics，可能会使用相关对象的一些通用接口或基类，以便您可以调用它们的方法。

E.g。

public static <T extends Comparable<T>> T maximum(T x, T y, T z) {                      
      T max = x; // assume x is initially the largest       
      if (y.compareTo(max) > 0) {
         max = y; // y is the largest so far
      }

      if (z.compareTo(max) > 0) {
         max = z; // z is the largest now                 
      }

      return max; // returns the largest object   
   }

但是，如果您需要在不事先以编程方式知道这些方法的界面的情况下调用特定方法，那么您将进入Reflection区域。

在同一方法上动态传递不同类型的对象

5 个答案: