[JAVA]pochi if-else,velocità, e leggibilità...e anche patterns

[MEMon]

Apro questo thread con l'intentzione di racchiudere un pò di "trucchetti" per migliorare la qualità del nostro codice.

Per iniziare, un problema che mi si presenta spesso è quello di dover eseguire un metodo a seconda del valore che assume una determinata variabile.
Ad esempio:

public void execute(int type){
	switch(type){
		case A: actionA();return;
		case B: actionB();return;
		...
	}
}

Il problema è che uso una bella catena di case, e in questo modo valuto la catena ogni volta che mi serve utilizzare il metodo,penso sia lento.

Di solito risolvo creando una classe per ogni azione che devo compiere:

class A extends C{
	
	...

	public void execute(){
		System.out.println("action A");
	}
}

class B extends C{
	
	...

	public void execute(){
		System.out.println("action B");
	}
}

abstract class C{
	
	...

	public void execute();
}

class Executor{

	private C c;

	public Executor(int type){
		c=valute(type);
	}

	private C valute(int type){
		switch(type){
			case A: return new A();
			case B return new B();
		}
	}

	public void execute(){
		c.execute();
	}

}


...
...
Executor e=new Executor(A);
e.execute();
...
...

In questo modo ho rimosso il controllo durante l'esecuzione spostandolo a "monte" e secondo me è anche più leggibile, però la catena di case rimane, e ho dovuto creare tante classi quante sono le azioni strade che posso intraprendere.
C'è modo per eliminare anche lo switch?
Secondo voi è una buona soluzione?

[shinya]

Spostare "new A()", "new B()" alla chiamata del costruttore di Executor?

Executor e = new Executor(new A());
e.execute();

[^TiGeRShArK^]

io farei cosi'....

class A implements C {
	
	...

	public void execute() {
		System.out.println("action A");
	}
}

class B implements C {
	
	...

	public void execute() {
		System.out.println("action B");
	}
}

public interface C {
	public void execute();
}

class Executor{

	private C myAction;

	public Executor(C myAction){
		this.myAction = myAction;
	}

	public void execute(){
		myAction.execute();
	}

}


...
...
A a = new A();
Executor executor = new Executor(a);
executor.execute();

anche se l'executor potrebbe pure non essere necessario....

[~FullSyst3m~]

Originariamente inviato da ^TiGeRShArK^

io farei cosi'....

class A implements C {
	
	...

	public void execute() {
		System.out.println("action A");
	}
}

class B implements C {
	
	...

	public void execute() {
		System.out.println("action B");
	}
}

public interface C {
	public void execute();
}

class Executor{

	private C myAction;

	public Executor(C myAction){
		this.myAction = myAction;
	}

	public void execute(){
		myAction.execute();
	}

}


...
...
A a = new A();
Executor executor = new Executor(a);
e.execute();

anche se l'executor potrebbe pure non essere necessario....

Non dovrebbe essere executor.execute()?

[^TiGeRShArK^]

Originariamente inviato da ~FullSyst3m~

Non dovrebbe essere executor.execute()?

yes..
m'ero perso un pezzo...

[^TiGeRShArK^]

mmmm...
rileggendo forse ho capito cosa intendeva fare...
se ho capito bene basterebbe aggiungere al mio codice un array di action (o una mappa a seconda dei valori che deve assumere la variabile) e richiamare semplicemente map[variable].execute();
ho capito bene stavolta o ancora mi sfugge qualcosa?

[^TiGeRShArK^]

tradotto in codice:

class A implements Action {
	
	...

	public void execute() {
		System.out.println("action A");
	}
}

class B implements Action {
	
	...

	public void execute() {
		System.out.println("action B");
	}
}

public interface Action {
	public void execute();
}

class Executor{

	private Action[] myActions;

	public Executor(Action[] myActions){
		this.myActions = myActions;
	}

	public void execute(int val){
		myActions[val].execute();
	}

}

int val = ???;
...
...
Action[] myActions = new Actions[2];
myActions[0] = new A();
myActions[1] = new B();
Executor executor = new Executor(myActions);
executor.execute(val);

[MEMon]

Originariamente inviato da ^TiGeRShArK^

tradotto in codice:

class A implements Action {
	
	...

	public void execute() {
		System.out.println("action A");
	}
}

class B implements Action {
	
	...

	public void execute() {
		System.out.println("action B");
	}
}

public interface Action {
	public void execute();
}

class Executor{

	private Action[] myActions;

	public Executor(Action[] myActions){
		this.myActions = myActions;
	}

	public void execute(int val){
		myActions[val].execute();
	}

}

int val = ???;
...
...
Action[] myActions = new Actions[2];
myActions[0] = new A();
myActions[1] = new B();
Executor executor = new Executor(myActions);
executor.execute(val);

Esatto questo è quello che volevo vedere.
La domanda sorge spontanea ora, è meglio il "mio" metodo che fa usa di switch(o if) o quello proposta da te che istanzia oggetti senza avere la sicurezza che poi vengano effettivamente usati?
Ho paura che a parte il fatto che non vengano usati if-else non porti altri vantaggi, perchè sicuramente non è più veloce visto che deve istanziare tanti oggetti quante sono le varie azioni che devo fare, ne di spazio per lo stesso motivo.
Sono ovviamente mie supposizioni campate in aria, cosa ne pensi?

[MEMon]

Se banalmente devo eseguire del codice solo se vera una determinata condizione, esempio:

...
if(cond){
	esegui();
}
...

E' possibile anche in questo caso eliminare il controllo condizionale?


Inoltre sempre nel medisimo caso, è meglio come scritto sopra, o così:

...
if(!cond) return;
esegui();
...

Ci sono differenza a livello prestazionale? Il compilatore interpreta allo stesso modo?

[^TiGeRShArK^]

Originariamente inviato da MEMon

Esatto questo è quello che volevo vedere.
La domanda sorge spontanea ora, è meglio il "mio" metodo che fa usa di switch(o if) o quello proposta da te che istanzia oggetti senza avere la sicurezza che poi vengano effettivamente usati?
Ho paura che a parte il fatto che non vengano usati if-else non porti altri vantaggi, perchè sicuramente non è più veloce visto che deve istanziare tanti oggetti quante sono le varie azioni che devo fare, ne di spazio per lo stesso motivo.
Sono ovviamente mie supposizioni campate in aria, cosa ne pensi?

a livello di velocità di esecuzione pura dovrebbe essere + veloce il metodo con l'array di action dato che non viene creato nessun branch, a livello di spreco di memoria credo che siamo lì con la catena di if se abbiamo una media di esecuzione piuttosto simile per le varie action, dato che resteranno comunque nel garbage collector.
Inoltre con l'array crei solo un'istanza di ogni action, invece con l'if crei una nuova istanza della action corrente per ogni esecuzione e questo peggiora sia la velocità di esecuzione che l'occupazione di memoria prima del passaggio del GC.
comunque tutto questo in teoria...
per vedere l'effettiva differenza prestazionale l'unica cosa è provare con un profiler il codice in modo da vedere velocità di esecuzione e occupazione di memoria.

[^TiGeRShArK^]

Originariamente inviato da MEMon

Se banalmente devo eseguire del codice solo se vera una determinata condizione, esempio:

...
if(cond){
	esegui();
}
...

E' possibile anche in questo caso eliminare il controllo condizionale?


Inoltre sempre nel medisimo caso, è meglio come scritto sopra, o così:

...
if(!cond) return;
esegui();
...

Ci sono differenza a livello prestazionale? Il compilatore interpreta allo stesso modo?

si può usare la stessa tecnica se la condizione è un'intero o un qualsiasi oggetto.
Nel caso di un oggetto qualsiasi si ha qualcosa del genere:

String cond = ???;

....

Map<String, Action> map = new HashMap<String, Action>();
map.add("pippo", new Pippo());
map.add("pluto", new Pluto());
map.add("topolino", new Topolino());
map.get(cond).execute();

invece per quanto riguarda scrivere:

if (!cond)
    return;
execute();

if(cond)
    execute();

dovrebbe essere uguale *in teoria*

[dupa]

Originariamente inviato da MEMon

Apro questo thread con l'intentzione di racchiudere un pò di "trucchetti" per migliorare la qualità del nostro codice.

Per iniziare, un problema che mi si presenta spesso è quello di dover eseguire un metodo a seconda del valore che assume una determinata variabile.

CUT

In questo modo ho rimosso il controllo durante l'esecuzione spostandolo a "monte" e secondo me è anche più leggibile, però la catena di case rimane, e ho dovuto creare tante classi quante sono le azioni strade che posso intraprendere.
C'è modo per eliminare anche lo switch?
Secondo voi è una buona soluzione?

sinceramente mi sembra una soluzione da "ufficio complicazione affari semplici".

comunque partendo dal problema di partenza:

public void execute(int type){

Io non ho mai avuto in vita mia una funzione alla quale passo un type per farle eseguire cose diverse....

non vedo perchè il codice che chiama execute, non dovrebbe chiamare direttamente il metodo che vuole eseguire, piuttosto che passare da questo "wrapper".

[MEMon]

Originariamente inviato da dupa

sinceramente mi sembra una soluzione da "ufficio complicazione affari semplici".

comunque partendo dal problema di partenza:

public void execute(int type){

Io non ho mai avuto in vita mia una funzione alla quale passo un type per farle eseguire cose diverse....

non vedo perchè il codice che chiama execute, non dovrebbe chiamare direttamente il metodo che vuole eseguire, piuttosto che passare da questo "wrapper".

Bhe probabilmente perche te hai sempre fatto così:

...
A a=new A();
B b=new B();
if(type==INT_A){
	a.eseguie();
}
else if(type==INT_B){
	b.esegui();
}
...

Che ha tutti i problemi, poca leggibilità, decisione a runtime ecc ecc.

[MEMon]

Originariamente inviato da ^TiGeRShArK^

si può usare la stessa tecnica se la condizione è un'intero o un qualsiasi oggetto.
Nel caso di un oggetto qualsiasi si ha qualcosa del genere:

String cond = ???;

....

Map<String, Action> map = new HashMap<String, Action>();
map.add("pippo", new Pippo());
map.add("pluto", new Pluto());
map.add("topolino", new Topolino());
map.get(cond).execute();

invece per quanto riguarda scrivere:

if (!cond)
    return;
execute();

if(cond)
    execute();

dovrebbe essere uguale *in teoria*

Però, mica male così, ma viene usato davvero per eliminare gli if?

[^TiGeRShArK^]

Originariamente inviato da MEMon

Però, mica male così, ma viene usato davvero per eliminare gli if?

si, array e mappe sono usati comunemente, insieme al polimorfismo e a qualche altro strumento, per eliminare gli if.

[^TiGeRShArK^]

Originariamente inviato da dupa

sinceramente mi sembra una soluzione da "ufficio complicazione affari semplici".

comunque partendo dal problema di partenza:

public void execute(int type){

Io non ho mai avuto in vita mia una funzione alla quale passo un type per farle eseguire cose diverse....

non vedo perchè il codice che chiama execute, non dovrebbe chiamare direttamente il metodo che vuole eseguire, piuttosto che passare da questo "wrapper".

infatti nel mio primo post ho specificato che l'executor generalmente non è necessario, ma non so nel suo caso se ha qualche motivo particolare per esistere...

[MEMon]

Ma nel tuo prima post non avevi capito quello che chiedevo, è ovvio che se so a priori di usare un metodo di A allora non serve l'esecutore, ma la situazione non è quella

La situazione è che in base a una condizione o al valore di una variabile devo fare cose diverse.

[dupa]

Originariamente inviato da MEMon

Bhe probabilmente perche te hai sempre fatto così:

...
A a=new A();
B b=new B();
if(type==INT_A){
	a.eseguie();
}
else if(type==INT_B){
	b.esegui();
}
...

Che ha tutti i problemi, poca leggibilità, decisione a runtime ecc ecc.

per sta cosa che hai scritto al max si usa il polimorfismo.
ma cmq anche il polimorfismo deve una logica di base.....

se hai super-classe Shape, estesa da Square, Circle

chiamerai

square.computeArea()
circle.computeArea()

ecc.

[MEMon]

Originariamente inviato da dupa

per sta cosa che hai scritto al max si usa il polimorfismo.

E fammi vedere come lo usi il polimorfismo per sta cosa che ho scritto.

[^TiGeRShArK^]

Originariamente inviato da MEMon

Ma nel tuo prima post non avevi capito quello che chiedevo, è ovvio che se so a priori di usare un metodo di A allora non serve l'esecutore, ma la situazione non è quella

La situazione è che in base a una condizione o al valore di una variabile devo fare cose diverse.

ma in concreto perchè ha un valore diverso questa variabile?
da cosa dipende?