When defining a constructor or method with more than three parameters it is considered a best practice to create a parameters object for holding the values which are required. This especially holds true when some of the parameters are optional (as they will contain default values) and also when two or more consecutive parameters are of the same type (as developers may accidentally transpose these parameters – which will not result in compile time or runtime errors, making debugging a nightmare!)
The most appropriate solution for such cases is to break up the method into separate methods, however when this is not feasible creating a parameters object will improve both code readability and provide a cleaner design which leaves less room for unexpected errors.
Consider the following method:
1 2 3 4 5 6 7 8 9 | public function someMethod(a:String, b:Object, c:int = 1, x:int = 2, y:int = 3, z:Boolean = true):SomeType { |
The parameters defined in this method are typical of what you will often see, however it is much cleaner and reliable to create a parameters object for holding these parameters. In addition, a parameters object allows for a much easier client implementation as default values need not be reassigned for all parameters which proceed a parameter which you need to specify a value other than the default value. For instance, if a method accepts 5 parameters and the first two parameters are required but the last three are optional, if you you need to specify a value for the last parameter you will need to re-assign the default values for the proceeding parameters, when in fact you really only need to specify three parameters.
The following example demonstrates creating a parameter object which can be passed to “someMethod”:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | package { public final class SomeMethodParams { public var a:String; public var b:Object; public var c:int = 1; public var x:int = 2; public var y:int = 3; public var z:Boolean = true; //only specify required parameters in constructor //optional parameters are simply public properties //which have default values assigned public function SomeMethodParams(a:String, b:Object) { this.a = a; this.b = b; } } } |
When invoking “someMethod†clients can now simply instantiate an instance of the parameter object, set values only for what is needed and pass it in as follows:
1 2 3 4 5 6 | var params:SomeMethodParams= new SomeMethodParams("a",{}) ; params.z = false; instance.someMethod( params ); |
So if you would like to improved code readability and provide proactive exception precautions, consider utilizing parameter objects for methods which require more than three parameters.