I'm confused about accessor methods.

Question

Part of the application I'm developing translates a sequence of strings into a series of hex values. The number of strings will be either 2 or 3. In the cass where there's 3 strings the last would represent an integer or a decimal fraction.
I have a class Xlate that has 3 translation methods thus:
public int[] translate(String msg) {};
public int[] translate(String msg, int val) {};
public int[] translate(String msg, String aValString) {};
The problem I have is that the Xlate does not return what is expected when passed an argument via the method signature. If explicitly passed a string sequence it works OK.
If I pass the argumants... "pause" "21.09876"
I would expect to see a translation of ... "msg translation array = 76,98,10,20,0A"
What I get is "msg translation array = FF, FF, FF, FF,FF" which indicates the array has not been amended after initialised.
This is most likely due to the lack of accessor definitions and their use. HOWEVER, I am confused by such methods.
I now realise that to pass values setter/getter accessor methods are .
I think these might be along the lines of the following:
private String[] commandList; // declares a string variable
public Xlate() { this(""); }
public Xlate(String[] msg) { this.commandList = msg[1]; } // holds the name
public String getCommandStrings() { return this.commandList; } // gets the commandList
I can't get this to work and know these are not correct.
I need help to get me moving ahead of this problem. Any help would be appreciated.
Thanks.
Philip
import java.lang.String;
public class Control {
  public Control() {
   int i;
  static final public Xlate x = new Xlate();
//  static final public Comms rc = new Comms();
  public static void main(String[] args) {
    String cmd[] =  args;
    for (int i=0;i<args.length;i++)
      cmd=args[i];
controller(cmd);
// public static void controller(String portName, String command, String parameter) {
public static void controller(String[] parameters) {
Control c = new Control();
int[] msg ={1,1,1,1,1};
// Booleans 'pragmaN' are used to select/deselect debug statements
// though would be embedded in the bytecode
// so these are not compiler directives
boolean pragma1=true, pragma2=true, pragma3=true; // toggle using !
int pVal;
if (pragma1==true) {
System.out.print("msg array = ");
for (pVal=0; pVal<4;pVal++)
     System.out.print(Integer.toHexString(msg[pVal]).toUpperCase() + ",");
System.out.println(Integer.toHexString(msg[pVal++]).toUpperCase());
// rc.setupComPort(parameters[0]); // Configure the port referenced
msg = x.translate("start"); //*********TRANSLATE()************
msg = x.translate("pause","12.34567"); //*********TRANSLATE()************
if (pragma2==true) {
System.out.print("msg translation array = ");
for (pVal=0; pVal<4;pVal++)
     System.out.print(Integer.toHexString(msg[pVal]).toUpperCase() + ",");
System.out.println(Integer.toHexString(msg[pVal++]).toUpperCase());
// rc.writeCmd(msg);
// Control messages have 3 fixed formats comprising 'a string', 'a string
// plus an integer' and 'a String plus a String'.
// For the control messages with an argument a string is constructed before
// translation by parging the arguments.
// Do ensure the number of args is greater than 1 and less than 3.
// Converts integer types to Strings
String argString="";
System.out.println("arg len = "+ parameters.length);;
switch (parameters.length) {
case 2:
     System.out.println("in switch 2");;
     argString = (parameters[1]);
     msg = x.translate(argString); //*********TRANSLATE()************
     if (pragma3==true) {
     System.out.print("msg translation array = ");
     for (pVal=0; pVal<4;pVal++)
     System.out.print(Integer.toHexString(msg[pVal]).toUpperCase() + ",");
     System.out.println(Integer.toHexString(msg[pVal++]).toUpperCase());
     break;
case 3:
     if (pragma3==true) {
     System.out.println("in switch 3"); ;
     argString = (parameters[1] + parameters[2]);
     msg = x.translate(argString); //*********TRANSLATE()************
     if (pragma3==true) {
     System.out.print("msg translation array = ");
     for (pVal=0; pVal<4;pVal++)
     System.out.print(Integer.toHexString(msg[pVal]).toUpperCase() + ",");
     System.out.println(Integer.toHexString(msg[pVal++]).toUpperCase());
     break;
default:
     System.out.println("Argument length error");
break;
// rc.writeCmd(msg);
import java.text.*;
import java.text.StringCharacterIterator; // required for CharacterIterator class
public class Xlate {
private String[] commandList; // declares a string variable
public Xlate() { this(""); }
public Xlate(String[] msg) { this.commandList = msg[1]; } // holds the name
public String getCommandStrings() { return this.commandList; } // gets the commandList
// These methods form a basic translation mechanism used as proof
public int[] translate(String msg) {
int[] paramList = {
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; //initialise this array
//Power On and Off controls
if (msg == "start") {
paramList = new int[] {
     0xFF, 0xFF, 0xFF, 0x01, 0x20};
if (msg == "stop") {
paramList = new int[] {
     0xFF, 0xFF, 0xFF, 0x00, 0x20};
return (paramList);
public int[] translate(String msg, int val) {
int[] paramList = {};
int pVal;
// Memory recall with memory ID.
if (msg == "M") { // Recall memory
paramList = new int[] {
     0xFF, 0xFF, 0xFF, 0xFF, 0x02};
// stuff the argument in to the paramList array
paramList[3] = Integer.decode(Integer.toHexString(val)).shortValue();
return (paramList);
  public int[] translate(String msg, String aValString) {
// Convert the string
    int i, j, k;
    int index = 0, c = 0;
    int[] p, paramList = {};
    final StringBuffer result = new StringBuffer(); // only ever one buffer
    char character;
    if (msg == "pause") {
      paramList = new int[] {
       0xFF, 0xFF, 0xFF, 0xFF, 0x0A};
// The period character is the axle where operations centre...
// working from the left most position index until period is found.
// append chars to result string en route.
// if period then stop - this is the integer part
    StringCharacterIterator sci = new StringCharacterIterator(aValString);
    result.append('0'); // a fudge to pad out the resulting string
    character = sci.current();
    while (character != '.') {
      //char is not a period so append to buffer
      result.append(character);
      character = sci.next();
    character = sci.next();
// working from the position of 'the period character' append chars to result string en route.
// stop at the end having bound the fraction part
    while (character != StringCharacterIterator.DONE) {
      result.append(character);
      character = sci.next();
    aValString = result.toString(); // save the result
    sci = new StringCharacterIterator(aValString);
    String[] part = {
     "00", "00", "00", "00"}; // array index ordered 0 to 3 from left to right
    result.delete(0, result.capacity()); // initialise the StringBuffer result
    character = sci.first();
    for (index = 0; index <= 3; ++index) {
      for (i = 0; i <= 1; ++i) {
     if (character != StringCharacterIterator.DONE) {
       result.append(character);
       character = sci.next();
     else {
       result.append('0');
      part[index] = result.toString();
      result.delete(0, result.capacity()); // initialise the StringBuffer result
// the sequence handles the conversion of decimal to packed BCD for transmission
    for (k = 0; k <= 3; k++) {
      // cast the String in the array part indexed by k to an int
      i = Integer.parseInt(part[k]);
      for (j = 0; j < 10; j++) {
     if ( (i >= (j * 10)) & (i < ( (j + 1) * 10))) {
       paramList[k] = (j * 0x10 + (i - (j * 10)));
    return (paramList);

Answer 1

Sorry, this is way too much to look at (at least for me). Please create a small test function that fails & post the formatted code. In doing this, you may even spot the problem yourself!