ordine numerico ai campi di una classe

[MyBloodyV.]

public class CestoFrutta {
    
    
    public static final String  ENCODING =  "IBM037";

    private String tipoCestino = ""; //1 
    private Number numeroMele=new Long(0l); //2 
    private Number numerPere=new Integer(0); //3
    private String coloreCestino = ""; //4
     
    
    //inizio lunghezze  
    private int l_coloreCestino=48;
    private int l_tipoCestino=24;
    private int l_numeroMele=12;
    private int l_numeroPere=8;
    //fine lunghezze 
    
    public CestoFrutta() {
        super();
         tipoCestino = init(l_tipoCestino);
         coloreCestino= init(l_coloreCestino);
    }
    
    public byte[] getBytes() throws Throwable {

        StringBuffer bf = new StringBuffer(this.getTipoCestino());//1
        bf.append(String.format("%12d", this.getNumeroMele()));//2
        bf.append(String.format("%8d", this.getNumerPere()));//3
        bf.append(this.getColoreCestino());//4
        return bf.toString().getBytes(ENCODING);
    }
    
    public void setBytes(byte[] array) throws Throwable {
         
        byte[] array_tipoCestino  = new byte[l_tipoCestino];
        byte[] array_numeroMele = new byte[l_numeroMele];
        byte[] array_numeroPere= new byte[l_numeroPere];
        byte[] array_coloreCestino  = new byte[l_coloreCestino];
     
        int j = 0;
        
        //1
        tipoCestino=setStr(tipoCestino, j,array_tipoCestino, array);
        j += array_tipoCestino.length;
        
        //2
        numeroMele=setNum(numeroMele, j,array_numeroMele, array);
        j += array_numeroMele.length;
        
        //3
        numerPere=setNum(numerPere, j,array_numeroPere, array);
        j += array_numeroPere.length;
        
        //4
        coloreCestino=setStr(coloreCestino, j,array_coloreCestino, array);
        j += array_coloreCestino.length;
        
    }
     
    
    private Number setNum(Number num, int j, byte[] arr1, byte[] arr2) throws UnsupportedEncodingException, ParseException{
         
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr2[j + i];
        }
        String str = new String(arr1, ENCODING);
        num  = NumberFormat.getInstance().parse(str.trim());
         return  num;
    }
    
    
    private String setStr(String str, int j, byte[] arr1, byte[] arr2) throws UnsupportedEncodingException, ParseException{
        
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr2[j + i];
        }
        str = new String(arr1, ENCODING);
         return  str;
    }
    
    private String init(int len) {
        StringBuffer bf = new StringBuffer("");
        for (int i = 0; i < len; i++) {
            bf.append(" ");
        }
        return bf.toString();
    }
     
 
    ...tutti i get e i set dei campi 
     
}

dunque, questa è una classe tipo quella che devo gestire

in sostanza il mio problema è: se guardi la getBytes e la setBytes, noterai (lo vedi dai commenti) che c'è un ordine di costruzione all'interno degli stessi metodi, che riguarda i 4 campi --- ora i campi sono 4 ma potrebbero diventare 20, e magari avrei bisogno di cambiare l'ordine --- per come è fatto il codice ora dovrei modificarlo in questa maniera (esempio nella getBytes):

prima:

StringBuffer bf = new StringBuffer(this.getTipoCestino());//1
bf.append(String.format("%12d", this.getNumeroMele()));//2
bf.append(String.format("%8d", this.getNumerPere()));//3
bf.append(this.getColoreCestino());//4
return bf.toString().getBytes(ENCODING);

dopo (inverto l'ordine tra mele e pere):
StringBuffer bf = new StringBuffer(this.getTipoCestino());//1
bf.append(String.format("%8d", this.getNumerPere()));//2
bf.append(String.format("%12d", this.getNumeroMele()));//3
bf.append(this.getColoreCestino());//4
return bf.toString().getBytes(ENCODING);

cambiando quindi la sequenza --- mi piacerebbe invece avere questi elementi legati a dei numeri e andare a toccare solo questi numeri rappresentanti l'ordine; si potrebbe fare con le liste o le mappe ma forse c'è di meglio

grazie

[andbin]

mi piacerebbe invece avere questi elementi legati a dei numeri e andare a toccare solo questi numeri rappresentanti l'ordine

Mah ... a dire il vero, il codice è molto dubbio su svariati aspetti.

Perché devi comporre la stringa in quel modo e poi convertirla in sequenza di byte? Te lo sei "inventato" tu o c'è un requisito ben preciso che devi rispettare (e che ovviamente io ignoro)? E indipendentemente dalla precedente domanda, chi usa poi quel byte array? Insomma, a chi lo restituisci e da chi lo ricevi?
E perché usi l'encoding IBM037? (che è una roba che si vede praticamente "ogni morte di papa", come si dice, se non di più ...)

E poi, ad esempio nel setNum/setStr, perché passi num/str se poi NON usi il valore del parametro? Guarda bene. Questi metodi hanno il primo parametro che usi solo come destinazione (num = ....) ma il valore ricevuto alla invocazione NON lo usi. E quindi quale è il senso?

E se anche avessi svariate classi in cui vuoi gestire una logica del genere ... mica stavi forse pensando di replicare tutti quei setNum/setStr in tutte le classi? Che sarebbe assurdo (oltre che anti-OOP).

Insomma ... quale è il senso/motivo di tutto questo?

[MyBloodyV.]

1) diciamo che sono partito da un modello simile che era fatto così; compone le stringhe e poi converte tutto in byte
2) come viene utilizzato, non ho idea
3) l'encoding mi è stato dato
4) vero (intendo l'osservazione sui setNum/setStr), è sbagliato
5) beh farei una superclasse


facciamo che raccolgo qualche info su cosa dovrebbe fare questa classe, che serve anche a me; poi provo a riformulare il tutto

grazie intanto