0

I have a function in which I have to send two states of an object:

void functionA(MyObject objStateOff, MyObject objStateOn){
}

And there would always be only two types states: on and off But instead of having two parameters of the same type for this function, I was hoping to combine them. SO I was thinking of having a HashMap<Boolean, MyObject>. But since this map would at most contain only two entries, it seems to be a waste of resources, as I am developing for Android.

So, is there a better way of passing these two objects, without having two either use a HashMap or having two parameters in the function signature?

Update: I want to see if any other method would basically improve the following: Readability, performance(even though i think that won't change) and maintainability

Thanks.

Improve this question
4
  • 1
    I don't mean this glibly, but what's wrong with passing two arguments, as you've done? That is, what's the problem you're trying to solve? You could create a custom class with two MyObject fields, but that's not going to necessarily be more readable. Without us knowing why you want to combine the two args, it's hard to suggest the best way of doing so. Commented Apr 5, 2014 at 9:20
  • Yea, I can always leave it like that but I want to request if there are better ways of handling this kind of scenario Commented Apr 5, 2014 at 9:22
  • But again, better in what sense? What are you trying to improve? Readability, performance, maintainability, extensiblity... ? We need more info, because as written there's not a single, right answer. Commented Apr 5, 2014 at 9:32
  • apologies for the ambiguity, i wanted to see if any other method would basically improve the following: 1. Readability, performance(even though i think that won't change) and maintainability. Commented Apr 5, 2014 at 9:34

6 Answers 6

Reset to default
2

I would create a custom class with two MyObject fields, and accessors for each. This has a couple big advantages based on your goals:

  • Readability: The accessor methods describe what each object does. states.get(true), what does that mean? states.getFooOnState(), that's pretty clearly getting me the state for when foo is on.
  • Maintainability: Adding new state is much easier, if you ever need to do that; you just add a new field to this class. Maybe you'll want a MyObject for when the foo's state is unknown/initializing, or maybe you want to add event handlers that get triggered when foo gets turned on or off. One disadvantage to your current approach is that these sorts of things will cascade through your signatures: functionA needs to add a new argument, which means functionB which calls functionA needs to now get that extra parameter (so it can pass it to functionA), which means functionC needs to get it, and so on.

One caveat to the readibility issue is that you'll be gaining readibility where you use these MyObjects, but not where you first set them up. There, you'll be creating a new MyObjectState (or whatever you name it), and the constructor will look just as generic as your functionA:

MyObjectState s = new MyObjectState(objStateOff, objStateOn);

You could address that by creating a builder for MyObjectState, but that'd probably be overkill.

Performance wise, you're not going to get better than what you already have. But a custom class is going to add fairly minimal overhead (in terms of extra memory, GC activity, etc) in the grand scheme of things.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Thanks for the detailed explaination.
You're quite welcome, and thanks for clarifying your question in the comments above!
0

There's always the Pair class (http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html). Or you could pass a MyObject[] with two elements.

Improve this answer

Comments

0

I think this question doesn't have the only correct answer. Personally I would leave the function with two parameters, because that's not too much really and names of this parameters can help me to avoid confusion like "which element of map/array is for on state?".

Improve this answer

Comments

0

You can always use composition.

Create a class that contains two objects of MyObject type.

It may look overkill at first, but it's safer than array.

Hope this helps.

Improve this answer

Comments

0

You could use a simple ArrayList.

ArrayList<MyObject> a = new ArrayList<MyObject>();

a.add(objStateOff); a.add(objStateOn); 

void functionA(ArrayList<MyObject>) {
...
}

functionA(a);

Or a simple argument logic:

void functionA(int x) {

    MyObject state;

    if (x == 0) { 
        MyObject state = objStateOff; // Supposing they were defined somewhere before.
    } else if (x == 1) {
        MyObject state = objStateOn;
    }

    if (state != null) {
        // Use MyObject state.
    }

}

In this way, you don't need to specify any convention, you just set the off or on right on the argument (You can use a string or a boolean instead of an int (I mean, you could use "ON" or "OFF", literally)).

Improve this answer

4 Comments

yes, but the point is, how does the person implementing this function, know, which index is for on and which is for off
There's not much to test/check in an array of two elements. One could use an internal convention, being consistent about which state is on or off in every part of the code (If you use other things, a convention will be necessary to be followed in the same way).
You are right. Convention would be required in either of the cases. I suppose if i really not want to use a convention then i would have to go with a wrapper class as suggested by Tanmay
@Sunny, I've put another idea up there that does not require a convention, exactly...
0

if your requirement is to have two object states, then why you dont have a field in MyObject like boolean stateOfObject. Then in functionA, you can check the state and do the required logic. Why complicate by sending two objects when you have only two states? May be you have to mention the context where you are using it and why you need two objects to be passed to the functions when the object can be in only one state. May be you could use enums:

public enum StateOfObject {

 ON(10,2), 
 OFF(15,5);

 private final int length;
 private final int speed;

 StateOfObject(int length, int speed) {
    this.length = length;
    this.speed = speed;
 }

 public MyObject getObject() {
    MyObject myObj = new MyObject();
    myObj.setLength(this.length);
    myObj.setSpeed(this.speed);
    return myObj;           
 }  
}

Use it like this:

 MyObject onObject = StateOfObject.ON.getObject(); 
        System.out.print("Length: " + onObject.getLength() +
                  " Speed: " + onObject.getSpeed());
Improve this answer

1 Comment

MyObject contains a set of settings for a particular procedure, example, startTime, length, endtime, speed, etc. SO it would be a bad design to have state on/off in it as then the object would no longer define the settings of one particular state and become ambiguious

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.