在2种不同类别的2种方法之间交换数据

Question

Im quite new to Java and this might be a basic doubt. But please help. I have a class as below:

public class EnterLeaveHandler implements IOtfHandler {
    public void handle(java.lang.Object ... args) {

        long time = (Long) args[0];
        int func = (Integer) args[1];
        int cpuid = (Integer) args[2];
        int source = (Integer) args[3];
}

I have another class:

public class DefFunctionHandler implements IOtfHandler {

    public void handle(Object... args) {

        int stream = (Integer) args[0];
        int func = (Integer) args[1];
        String name = (String) args[2];
        int funcgroup = (Integer) args[3];
        int source = (Integer) args[4];
    }
}

So like you can see..there are 2 different classes, which have the same method, but receive different data. I need to get an input from the user for the "String name" in DefFunctionHandler class, and I identify the given name with the name in the file that I have...then correlate it with other data in the method like funcgroup and func . The same func is there in the other class too. So I need to make a comparison between them to get the data in the other class like time, etc.

So the data in the methods can be compared to the data structure in C...how do I implement such a structure in Java? I read that structs are similar to classes in Java. But in my case, I have the data in methods and not classes. Please tell me how to solve this problem.

Answer 1

To Answer Your Original Question

Long story short, you can't access method variables externally. What you want to do is make those variables fields within the class. Putting them outside the method means they stick around after the method is done, and it means you can access them from outside.

public class EnterLeaveHandler implements IOtfHandler {
    private long time;
    private int func;
    private int cpuid;
    private int source;

    // Please don't use varargs like this; read the whole answer!!
    public void handle(Object ... args) {
        time = (Long) args[0];
        func = (Integer) args[1];
        cpuid = (Integer) args[2];
        source = (Integer) args[3];
    }
}

Then you access them by creating getters and setters :

public long getTime() {
    return time;
}
public void setTime(long t) {
    time = t;
}
// etc...

---

HOWEVER, Some Suggestions...

Your code is... strange, to say the least. It's also very non-Java-like. As much as possible, you should try to avoid having multiple overriding methods that need different data. Also, you normally want to initialize your fields in the constructor , not in some other method.

It's not clear how much of the code you have access to, but if you're able to rewrite the interface, I would definitely do so. Object varargs in an interface is just weird. The reason for using an interface is so that you can call an interface method with identical parameters and, regardless of the object type underneath, something useful will happen. It defeats the point of the interface to have two implementations of the same method require totally different arguments. The following code demonstrates why this is:

IOtfHandler h1 = new EnterLeaveHandler();
IOtfHandler h2 = new DefFunctionHandler();
h1.handle(0, 0, 0, 0);
h2.handle(0, 0, 0, 0); // Crashes with ClassCastException!! :(
                       // And would also crash two lines later with ArrayIndexOutOfBoundsException

Much better to just make them different methods entirely.You know what variables you're expecting, so you should take advantage of that fact. Your method signatures would be far better off looking something like this:

public class EnterLeaveHandler implements IOtfHandler {
    public void handle(long time, int func, int cpuid, int source) {
    // Do things with your shiny new variables
}
public class DefFunctionHandler implements IOtfHandler {
    public void handle(int stream, int func, String name, int funcgroup, int source) {
        // Do things with your shiny new variables
    }
}

As others have suggested, if the "real" method signatures are not identical, you shouldn't be using an interface. Better to use an abstract base class instead, to hold what little data is common between them:

abstract class IOtfHandler {
    private int source;
    private int func;

    public void setSource(int source) {
        this.source = source;
    }
    // etc
}
class EnterLeaverHandler extends IOtfHandler {
    private long time;
    // etc
}
class DefFunctionHandler extends IOtfHandler {
    private String name;
    // etc
}

Of course, if you set all the variables in the constructors, you may be able to add an abstract handle() method to the base class, since then that method should have the same signature, and take no arguments at all!

---

Final Result

So if we pull together all the changes I've talked about-- moving the method variables into fields , using getters and setters , using useful method signatures , using constructors , and using a base class instead of a misleading interface, we end up with something like this:

abstract class IOtfHandler {
    private int source;
    private int func;

    public void setSource(int source) {
        this.source = source;
    }
    public int getSource() {
        return source;
    }
    public void setFunc(int func) {
        this.func = func;
    }
    public int getFunc() {
        return func;
    }

    // abstract handle method
    abstract public void handle();
}

class EnterLeaverHandler extends IOtfHandler {
    private long time;
    private int cpuid;

    // getters and setters
    public void setTime(long time) {
        this.time = time;
    }
    public long getTime() {
        return time;
    }
    public void setCpuId(int cpuid) {
        this.cpuid = cpuid;
    }
    public int getCpuId() {
        return cpuid;
    }

    // constructor
    public EnterLeaverHandler(long time, int cpuid, int source, int func) {
        setTime(time);
        setCpuId(cpuid);
        setSource(source);
        setFunc(func);
    }

    // handle method
    public void handle() {
        System.out.println("EnterLeaverHandler.handle()");
        // Do whatever class-specific handling you might want to do in here.
    }
}

class DefFunctionHandler extends IOtfHandler {
    private String name;
    private int funcGroup;
    private int stream;

    // getters and setters
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setFuncGroup(int funcGroup) {
        this.funcGroup = funcGroup;
    }
    public int getFuncGroup() {
        return funcGroup;
    }
    public void setStream(int stream) {
        this.stream = stream;
    }
    public int getStream() {
        return stream;
    }

    // constructor
    public DefFunctionHandler(String name, int funcGroup, int stream, int source, int func) {
        setName(name);
        setFuncGroup(funcGroup);
        setStream(stream);
        setSource(source);
        setFunc(func);
    }

    // handle method
    public void handle() {
        System.out.println("DefFunctionHandler.handle()");
        // Do whatever class-specific handling you might want to do in here.
    }
}

public class Main {
    public static void main(String[] args) {
        IOtfHandler h1 = new DefFunctionHandler("name", 0, 0, 0, 0);
        IOtfHandler h2 = new EnterLeaverHandler(0, 0, 0, 0);
        h1.handle();
        h2.handle();
    }
}

Answer 2

In order to make the variables class variables, all you have to do is move their declaration outside of the method. In other words, your code for the EnterLeaveHandler might look like this:

public class EnterLeaveHandler implements IOtfHandler {

    long time;
    int func;
    int cpuid;
    int source;

    public void handle(java.lang.Object ... args) {

        time = (Long) args[0];
        func = (Integer) args[1];
        cpuid = (Integer) args[2];
        source = (Integer) args[3];
        ...
    }
}

Answer 3

You need to restructure your objects to have proper constuctors and setters/getters

This gives the benefit of protecting all your private variables and forcing other classes to adhere to your classe's "contract" by only allowing them to access it's inner variables via those setters/getters and constructor. Now you just instantiate the object, then use ti's methods to manipulate it.

Here is an example from your first example class:

public class EnterLeaveHandler implements IOtfHandler {

    private long time;
    private int func, cpuid, source;

    public EnterLeavehandler(long time, int func, int cpuid, int source) {

        this.time = time;
        this.func = func;
        this.cpuid = cpuid;
        this.source = souce;

    }

    public long getTime() {
        return this.time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    public int getFunc() {
        return this.func;
    }

    public void setFunc(int func) {
        this.func = func;
    }

    public int getCPUID() {
        return this.cpuid;
    }

    public void setCPUID(int cpuid) {
        this.cpuid = cpuid;
    }

    public int getSource() {
        return this.source;
    }

    public void setSource(int source) {
        this.source = source;
    }

    public void handle(long t, int f, int c, int s) {

        this.setTime(t);
        this.setFunc(f);
        this.setCPUID(c);
        this.setSource(s);
    }
}

Answer 4

Create an abstract super class for your classes. Extend this with your classes and init the parameters in the handle call.

public abstract class AbstarctFunctionHandler implements IOtfHandler { 
   long time; 
   int func; 
   int cpuid; 
   int source 
   //add getters and setters, if you fancy

   public boolean equals(AbstarctFunctionHandler obj){ 
      //compare variables 
      return true;
   } 
}

Answer 5

The best solution I could think of 1. is create a getter and setter

 public void setName(String name) {
       this.name = name;
    }

    public String getName() {
       return name;
    }

http://docs.oracle.com/javaee/6/tutorial/doc/gjbbp.html

2.create a wrapper method to do the comparsion prior to calling the individual method.

Hope this helps you.