Tripla classe

[IvanHares]

Buongiorno a tutti,
ho la seguente situazione:
ho tre classi A.class, B.class e C.class da 500 linee circa ciascuna che sono praticamente uguali eccetto per 20 linee di codice (circa) ciascuna;

Inoltre ho un main che richiama queste classi almeno 5 volte ciascuna.

La domanda che mi pongo è la seguente:
Dal punto di vista del tempo di esecuzione cosa cambierebbe se unificassi le tre classi in un'unica GlobalABC con gli if opportuni?

Grazie a tutti per i consigli.

[IvanHares]

Nessuno sà darmi anche solo un'opinione in merito?

[simoneRDZN]

Originariamente inviato da IvanHares
Buongiorno a tutti,
ho la seguente situazione:
ho tre classi A.class, B.class e C.class da 500 linee circa ciascuna che sono praticamente uguali eccetto per 20 linee di codice (circa) ciascuna;

Inoltre ho un main che richiama queste classi almeno 5 volte ciascuna.

La domanda che mi pongo è la seguente:
Dal punto di vista del tempo di esecuzione cosa cambierebbe se unificassi le tre classi in un'unica GlobalABC con gli if opportuni?

Grazie a tutti per i consigli.

La programmazione Object Oriented prevede che per casi del genere si ricorra ad uno dei suoi principi fondamentali, l'ereditarietà: devi fare una classe base da cui poi estenderanno le altre. In questo modo ogni classe figlia avrà a disposizione, oltre ai suoi metodi, tutti i metodi della superclasse.

[IvanHares]

Conosco il concetto dell'ereditarietà e ti posso assicurare che se il progetto fosse firmato da me, non avrei creato tre classi in quel modo.
La mia domanda era riferita all'esecuzione a runtime:

Eseguire un main che richiama 3 classi 5 volte ciascuna ha un tempo maggiore, inferiore o uguale all'esecuzione di un main che richiama una classe 15 volte?

Spero di essermi spiegato.
Grazie ancora per consigli e/o suggerimenti.

[simoneRDZN]

Originariamente inviato da IvanHares
Conosco il concetto dell'ereditarietà e ti posso assicurare che se il progetto fosse firmato da me, non avrei creato tre classi in quel modo.
La mia domanda era riferita all'esecuzione a runtime:

Eseguire un main che richiama 3 classi 5 volte ciascuna ha un tempo maggiore, inferiore o uguale all'esecuzione di un main che richiama una classe 15 volte?

Spero di essermi spiegato.
Grazie ancora per consigli e/o suggerimenti.

Dipende tu cosa intendi per "richiamare una classe n volte": se intendi "fare riferimento a quella classe, ovvero utilizzare i suoi metodi e/o proprietà n volte" dal punto di vista delle risorse è lo stesso che far riferimento a 3 classi diverse per un totale di n volte (ma nn ci metterei la mano sul fuoco!). Il problema vero è nell'istanza: un conto è istanziare 1 classe, un conto è istanziarne tre!

[IvanHares]

Allora entro un pò di + nel dettaglio delle classi:

class A
{
    public A()
    {
        //costruttore
    }
    public metodo1A(){}
    public metodo2A(){}
    ....
    public metodoNA(){}
}
class B
{
    public B()
    {
        //costruttore
    }
    public metodo1B(){}
    public metodo2B(){}
    ....
    public metodoNB(){}
}
class C
{
    public C()
    {
        //costruttore
    }
    public metodo1C(){}
    public metodo2C(){}
    ....
    public metodoNC(){}
}

class MainABC
{
   public static void main(String[]a)
   {
          A oggettoA = new A();
          B oggettoB = new B();
          C oggettoC = new C();
          int dim = 5;
          for(int i=0; i<dim; i++)
          {
                    oggettoA.metodo1A();
                    oggettoB.metodo1B();
                    oggettoC.metodo1C();
          }

          //altri calcoli

          for(int i=0; i<dim; i++)
          {
                    oggettoA.metodo2A();
                    oggettoB.metodo2B();
                    oggettoC.metodo2C();
          }

          //altri calcoli
          .....
          for(int i=0; i<dim; i++)
          {
                    oggettoA.metodoNA();
                    oggettoB.metodoNB();
                    oggettoC.metodoNC();
          }

          //risultati
   }
}

Diciamo che questa è la situazione attuale; mentre questa è la situazione che prevedo:

class Global
{
    public Global()
    {
        //costruttore
    }
    public metodo1(char tipo)
    {     //codice uguale per le tre classi

          //ora differenzio il codice per le 20 righe differenti  
           if(tipo=='A'){}
           else if(tipo=='B'){}
           else if(tipo=='C'){}
    }
    public metodo2(char tipo)
    {     //codice uguale per le tre classi

          //ora differenzio il codice per le 20 righe differenti  
           if(tipo=='A'){}
           else if(tipo=='B'){}
           else if(tipo=='C'){}
    }

    ....
    public metodoN(char tipo)
    {     //codice uguale per le tre classi

          //ora differenzio il codice per le 20 righe differenti  
           if(tipo=='A'){}
           else if(tipo=='B'){}
           else if(tipo=='C'){}
    }
}
class MainGlobal
{
   public static void main(String[]a)
   {
          Global g = new Global();

          int dim = 5;
          for(int i=0; i<dim; i++)
          {
                    g.metodo1('A');
                    g.metodo1('B');
                    g.metodo1('C');
          }
          //altri calcoli
          for(int i=0; i<dim; i++)
          {
                    g.metodo2('A');
                    g.metodo2('B');
                    g.metodo2('C');
          }
          //altri calcoli
          ....
          for(int i=0; i<dim; i++)
          {
                    g.metodoN('A');
                    g.metodoN('B');
                    g.metodoN('C');
          }
          //risultati
}

Quale dei due codici ha un'esecuzione + veloce?