从不同类型的实例中调用相同的方法名称

Question

I have some libraries from external company, I want to use this API. I try to implement calling this API, my logic should call the same method name. I have duplicate codes, I want to avoid to do this. I'm beginner and subjects like interfaces, polymorphism are little bit difficult to me.

public void modPeople(Object person)
{
 if (person instanceof com.company.persontype1)
 {
  com.company.persontype1 fireman = (com.company.persontype1) person; 
  String name = fireman.getName();

     if (name!=null ) {
     ...
      fireman.set_name();
      fireman.save();
     }

     permissions  = fireman.get_Permissions();
     ...
  permissions = fixperm (permissions);

  fireman.set_Permissions();
 };

 if (person instanceof com.company.persontype2)
 {
  com.company.persontype2 nurse = (com.company.persontype2) person; 
  String name = nurse.getName();

     if (name!=null ) {
     ...
      nurse.set_name();
      nurse.save();
     }

     permissions  = nurse.get_Permissions();
     ...
  permissions = fixperm (permissions);

  nurse.set_Permissions();
 };
}

Answer 1

First of all I should mention that the methodology which you requested in your question is called "Duck Typing" . Generally this technology is possible in Java (see below the example) but it's not widely used in Java. There could be performance hits etc. It would be much better to introduce a proper inheritance/interface level instead.

Also the provided example don't deal with exceptions properly etc. It's just a quick and quite dirty "demostration of the technology". Feel free to adapt it for your needs.

It's Java7 (for multi-catch clauses, you may refactor this with ease).

ISomeIterface.java (it contains all common methods implemented by classes which are used in your "bad code"):

package org.test;

public interface ISomeInterface {
  public String getName();
  public void setName(String _name);
  public void save();
  // specify other common methods
}

ReflectCaller.java:

package org.test1;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;

import org.test.ISomeInterface;

public class ReflectCaller {

  private final Method[] methods = ISomeInterface.class.getDeclaredMethods();
  private final Map<Class<?>, Method[]> maps = new HashMap<Class<?>, Method[]>();

  public void inspectClass(Class<?> _clazz) throws NoSuchMethodException, SecurityException {
    final Method[] ms = new Method[methods.length];
    int i = 0;
    for(final Method m: methods) {
      ms[i] = _clazz.getMethod(m.getName(), m.getParameterTypes());
      i++;
    }
    maps.put(_clazz, ms);
  }

  public ISomeInterface wrapper(Object _obj) {
    final Method[] ms = maps.get(_obj.getClass());
    // To be replaced by guava's Preconditions.checkState()
    if (ms == null)
      throw new NoSuchElementException(String.format("Class %s is unregistered", _obj.getClass().getName()));
    return new SomeInterfaceImpl(_obj, ms);
  }

  private static class SomeInterfaceImpl implements ISomeInterface {
    private final Object obj;
    private final Method[] ms;

    public SomeInterfaceImpl(Object _obj, Method[] _ms) {
      ms = _ms;
      obj = _obj;
    }

    @Override
    public String getName() {
      try {
        return (String) ms[0].invoke(obj);
      } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
        throw new RuntimeException(e);
      }
    }

    @Override
    public void setName(String _name) {
      try {
        ms[1].invoke(obj, _name);
      } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
        throw new RuntimeException(e);
      }
    }

    @Override
    public void save() {
      try {
        ms[2].invoke(obj);
      } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
        throw new RuntimeException(e);
      }
    }
  }
}

And test class ReflectTest.java. Notice that classes ReflectTest.Test and ReflectTest.Test2 has the same methods as ISomeInterface but don't implement it, they are completely independent from that interface and from each other.

package org.test2;

import org.test.ISomeInterface;
import org.test1.ReflectCaller;

public class ReflectTest {
  private final ReflectCaller rc;
  ReflectTest(Class ... _classes) throws NoSuchMethodException, SecurityException {
    rc = new ReflectCaller();
    for(final Class c: _classes)
      rc.inspectClass(c);
  }

  void callSequence(Object _o) {
    // this function demonstrates the sequence of method calls for an object which has "compliant" methods
    ISomeInterface tw = rc.wrapper(_o);
    tw.setName("boo");
    System.out.printf("getName() = %s\n", tw.getName());
    tw.save();
  }

  public static class Test {
    public String getName() {
      System.out.printf("%s.getName()\n", getClass().getName());
      return "boo";
    }
    public void setName(String _name) {
      System.out.printf("%s.setName(%s)\n", getClass().getName(), _name);
    }
    public void save() {
      System.out.printf("%s.save()\n", getClass().getName());
    }
  }

  public static class Test2 {
    public String getName() {
      System.out.printf("%s.getName()\n", getClass().getName());
      return "boo2";
    }
    public void setName(String _name) {
      System.out.printf("%s.setName(%s)\n", getClass().getName(), _name);
    }
    public void save() {
      System.out.printf("%s.save()\n", getClass().getName());
    }
  }

  public static void main(String[] args) {
    ReflectTest rt;
    try {
      rt = new ReflectTest(Test.class, Test2.class);
    } catch (NoSuchMethodException | SecurityException e) {
      System.out.println(e);
      System.exit(2);
      return;
    }

    rt.callSequence(new Test());
    rt.callSequence(new Test2());
  }
}