Devo usare l'inizializzatore statico o la super classe

Question

Ho un'interfaccia denominata Parser. Due classi ParserA, ParserB implementa Parser.

public interface Parser{ 
    public void initialize(); 
    public int Parse(byte[] data); 
} 

Ho confusione con l'inizializzazione. ParserA inizializza due Maps. ParserB inizializza due Maps. Ma diversi dati. Maps sono inizializzati con dati costanti. Significa non dal runtime.

Quindi dovrei usare approach1 o 2?

Approach1:

class Initializer{ 
    //have two maps as member 
} 

Class ParserA extents initializer implements Parser{ 
     public int Parse(byte[] data){ 

     } 

     public void initialize(){ 
     //Initialize those maps 
     } 
} 

Similarly for class B 

Approach2:

class Constants{ 
    //Static initializer of four maps[two for ParserA, two for ParserB] 
} 

Class ParserA implements Parser{ 
     public int Parse(byte[] data){ 

     } 

     public void initialize(){ 
      //Constants.map1 likewise use. 
     } 
} 

Similarly for class B 

che è preferito nel caso d'uso di cui sopra?

Q2: Ho un altro metodo di utilità nella classe Initializer. Lascia che sia getAttr che utilizza queste due mappe. In questo scenario, quale approccio è migliore?

Q3 Se si desidera multiple threads to use these parsers e si assume che scelgo l'approccio 1, si verifica inutile intiailization su ciascun thread. Questo è ciò che veramente mi confonde.

Sono un po 'più confuso.

Si supponga che Animal sia una classe base per Tiger, Lion. Ogni animale avrà age, numOfLegs come membri. Avrà senso avere la classe Animal invece di avere age, numOfLegs in ogni classe di Animal. Quindi, Superclass vince qui. non lo è? Se è così, immagino che anche il mio scenario sia simile a questo.

Answer 1

Dal momento che si sta chiedendo parere, ecco il mio 2 centesimi:

Entrambi gli approcci sembrano inutili. L'idea di base dell'interfaccia Parser sembra un po 'errata. Se i parser verranno inizializzati staticamente, perché prevedete che gli utenti del parser chiamino il metodo initialize? Cosa farebbe il programma se non chiamasse initialize e usasse il metodo parse?

Lo scopo dell'interfaccia Parser è analizzare un byte []. Le implementazioni individuali dovrebbero inizializzarsi con la logica che vogliono. Quindi, ti suggerirei di rimuovere il metodo di inizializzazione in Parser e di avere lo ParserA e lo ParserB inizializzarlo con le Mappe (o qualsiasi altra cosa di cui potrebbero aver bisogno) quando vengono create.

Qualcosa di simile:

public interface Parser { 
    int parser(byte[] data); 
} 

public class ParserA implements Praser { 

    public ParserA() { 
     //initialize the maps they use or whatever the data structure that is needed 
    } 

    public int parser(byte[] data) { 
     //logic of parsing 
    } 
} 

// in modo simile per ParserB.

Per il tuo Q2: se non esponi il DS interno e lo stato del DS è immutabile, questi parser possono essere condivisi con più thread senza alcun problema.

Answer 2

andrei per una terza opzione

Class ParserA{ 
    // two maps declaration 
    static { 
     // maps initialization 
    } 

    public int ParseA(byte[] data){ 
     //parse the byte array 
    } 

    public xxxx getAttr(){ 

    } 
} 

Il blocco statico viene eseguito solo quando il caricatore di classe carica la classe, che avviene solo una volta, indipendentemente dal numero di fili. Ciò consente di inizializzare gli attributi statici di ciascun parser.