Efficienza

[JunkyFunki]

Salve,

secondo voi quale delle seguenti tecniche è più efficiente in termini di risparmio memoria ed aumento delle prestazioni?

Tecnica A :

public class A {

   public D=new D();
   public E=new E();
   public F=new F();


}

public class B {

   public D=new D();
   public E=new E();
   public F=new F();

}

Tecnica B:

public class A {

   public C=new C();


}

public class B {

   public C=new C();

}

public class C {

   public D=new D();
   public E=new E();
   public F=new F();

}

[andbin]

A dire il vero, sinceramente, non ho capito il nesso tra i due esempi. Sono casi differenti, con un numero di classi diverse, con variabili di istanza differenti (oltretutto public e sopratutto sbagliate come sintassi .... manca il nome della variabile).

[JunkyFunki]

Originariamente inviato da andbin
A dire il vero, sinceramente, non ho capito il nesso tra i due esempi. Sono casi differenti, con un numero di classi diverse, con variabili di istanza differenti (oltretutto public e sopratutto sbagliate come sintassi .... manca il nome della variabile).

Nella prima "tenica" ho due classi (A e B) che dichiarano e utilizzano i metodi delle classi D,E ed F

Nella seconda "tecnica" le classi D,E ed F vengono dichiarate e gestite dalla classe C.
In questo modo le classi A e B devono far riferimento ai metodi di una sola classe (la C) invece che a tre classi (D,E ed F)

Riscrivo il codice d'esempio :

Tecnica A :

public class A {

    public D uno = new D();
    public E  due= new E();
    public F  tre= new F();

    public void metodo() {
        ...
        uno.operazione();
        due.esegui();
        tre.cancella();
        ...
    }
}

public class B {

    public D uno = new D();
    public E due = new E();
    public F tre = new F();

    public void metodo() {
        ...
        uno.operazione();
        due.esegui();
        tre.cancella();
        ...
    }
}

Tecnica B:

public class A {

    public C esempio = new C();


    public void metodo() {
        ...
        esempio.operazione();
        esempio.esegui();
        esempio.cancella();
        ...
    }

}

public class B {

    public C esempio = new C();

    public void metodo() {
        ...
        esempio.operazione();
        esempio.esegui();
        esempio.cancella();
        ...
    }
}

public class C {

    public D uno = new D();
    public E due = new E();
    public F tre = new F();
    

    public operazione() {
        uno.operazione();
    }

    public esegui() {
        due.esegui();
    }

    public cancella() {
        tre.cancella();
    }

}
}

[andbin]

Originariamente inviato da JunkyFunki
Nella prima "tenica" ho due classi (A e B) che dichiarano e utilizzano i metodi delle classi D,E ed F

Nella seconda "tecnica" le classi D,E ed F vengono dichiarate e gestite dalla classe C.
In questo modo le classi A e B devono far riferimento ai metodi di una sola classe (la C) invece che a tre classi (D,E ed F)

Ok, più chiaro di prima lo è .... comunque la differenza, a livello di prestazioni, è davvero piccolissima ... infinitesima, sicuramente trascurabile.

Più che altro è una questione strutturale ... di "design". Ma non stare a preoccuparti perché c'è 1 invocazione di un metodo in più di mezzo.

[JunkyFunki]

Originariamente inviato da andbin
Ok, più chiaro di prima lo è .... comunque la differenza, a livello di prestazioni, è davvero piccolissima ... infinitesima, sicuramente trascurabile.

Più che altro è una questione strutturale ... di "design". Ma non stare a preoccuparti perché c'è 1 invocazione di un metodo in più di mezzo.

allora se la differenza è trascurabile non ho chiaro come java utilizza la memoria.

Nella mia ignoranza credo che quando la classe A,B dichiano le classi D,E ed F nella memoria ho caricato le classi :

A
D(di A)
E (di A)
F(di A)
B
D(di B)
E (di B)
F(di B)
Tot.8

Nel secondo caso ,ovvero quando le classi D,E ed F sono gestite dalla classe C dovrei avere questa situazione in memoria :

A
C(di A)
D(di C di A)
E(di C di A)
F(di C di A)
B
C(di B)
D(di C di B)
E(di C di B)
F(di C di B)
Tot.10

giusto ?