[JAVA] evitare ridondanza del codice

[kiowa91]

Ciao a tutti, vi espongo subito il mio problema.
Ho scritto un programmino che gestisce un libretto universitario.
Il programma ordina in maniera crescente a seconda della materia(Stringa), del voto(intero) o dei crediti(intero) maturati in quell'esame (la scelta è a carico dell'utente).
L'ordinamento viene fatto mediante il semplice BubbleSort prendendo in input oggetti di tipo "Libretto" con i relativi metodi per recuperare materia, voto e crediti.
il mio problema nasce qui: per ordinare tipi diversi di dato copio più volte l'algoritmo di ordinamento causando ridondanza del codice che vorrei evitare.
Vi posto la classe contenente l'oggetto, e la classe contenente l'algoritmo di ordinamento per chiarirvi cosa voglio dire:

Questo è l'oggetto.

/*
 * Crea un libretto universitario.
 */
public class Libretto {
	private static final int VOTO_MINIMO = 18;
	private static final int VOTO_MASSIMO = 30;
	String materia;
	int voto;
	int crediti;

	public Libretto() {
		this.materia = inserisceMateria();
		this.voto = inserisceVoto();
		this.crediti = inserisciCrediti();
	}
	
	/*
	 * Inserisce la materia.
	 * @return materia: il valore corrente della materia inserita.
	 */
	public String inserisceMateria() {
		System.out.println("inserisci materia");
		Scanner in = new Scanner(System.in);
		return this.materia = in.next();
	}
	
	/*
	 * Inserisce il voto.
	 * Controlla che il voto sia compreso tra 18 e 30,
	 * se inferiore o superiore restituisce un valore negativo.
	 * @return votoValido: il valore corrente del voto inserito.
	 */
	public int inserisceVoto() {
		System.out.println("inserisci voto");
		Scanner in = new Scanner(System.in);
		this.voto = in.nextInt();
		int votoValido; //valore di ritorno

		if ((this.voto >= VOTO_MINIMO) && (this.voto <= VOTO_MASSIMO)) {
			votoValido = this.voto;
		} else {
			votoValido = -1;
		}
		return votoValido;
	}
	
	/*
	 * Inserisce i crediti.
	 * @return crediti: il valore corrente dei crediti inseriti.
	 */
	public int inserisciCrediti() {
		System.out.println("inserisci crediti");
		Scanner in = new Scanner(System.in);
		return this.crediti = in.nextInt();
	}

	public String restituisciMateria() {
		return materia;
	}

	public int restituisciVoto() {
		return voto;
	}

	public int restituisciCrediti() {
		return crediti;
	}
}

Questa è la classe che lo gestisce.

/*
 * Simula il comportamento di un libretto universitario.
 */
public class GestioneLibretto {
	/*
	 * contiene gli oggetti di tipo libretto creati dall'utente.
	 */
	Libretto[] arrLibretto;

	/*
	 * Definisce la dimensione massima del libretto.
	 * 
	 * @param dimensione
	 *            : dimensione massima inserita dall'utente.
	 */
	public void definisciDimensione(int dimensione) {
		arrLibretto = new Libretto[dimensione];
	}

	/*
	 * Popola il libretto in base alla dimensione del libretto inizializzato
	 * dall'utente.
	 */
	public void aggiungiElementi() {
		for (int i = 0; i < arrLibretto.length; i++) {
			Libretto libretto = new Libretto();
			arrLibretto[i] = libretto;
		}
	}

	/*
	 * Visualizza gli elementi presenti nel libretto; Visualizza la materia, il
	 * voto e i crediti relativi all'elemento appartenente al libretto; la
	 * variabile "j" inizializza l'indice della lista di elementi.
	 */
	public void visualizzaElementi() {
		for (int i = 0, j = 1; i < arrLibretto.length; i++, j++) {
			System.out.println(j + ") " + arrLibretto[i].restituisciMateria()
					+ " " + arrLibretto[i].restituisciVoto() + " "
					+ arrLibretto[i].restituisciCrediti());
		}
	}

	public void ordinaElementi(String elemento) {
		if (elemento.compareToIgnoreCase("MATERIA") == 0) {
[I]
			int dimension = arrLibretto.length;
			int counter = 0;
			boolean sorted = false;

			while ((counter < dimension) && (!sorted)) {
				counter++;
				sorted = true;

				for (int i = dimension - 1; i >= counter; i--) {
					if (((arrLibretto[i - 1].restituisciMateria())
							.compareTo(arrLibretto.restituisciMateria())) > 0) {
						swap(i, (i - 1));
						sorted = false;
					}
				}
			}

		} else if (elemento.compareToIgnoreCase("VOTO") == 0) {
[I]
			int dimension = arrLibretto.length;
			int counter = 0;
			boolean sorted = false;

			while ((counter < dimension) && (!sorted)) {
				counter++;
				sorted = true;

				for (int i = dimension - 1; i >= counter; i--) {
					int a = arrLibretto.restituisciVoto();
					int b = arrLibretto[i - 1].restituisciVoto();
					if (b > a) {
						swap(i, (i - 1));
						sorted = false;
					}
				}
			}

		} else if (elemento.compareToIgnoreCase("CREDITI") == 0) {
[I]
			int dimension = arrLibretto.length;
			int counter = 0;
			boolean sorted = false;

			while ((counter < dimension) && (!sorted)) {
				counter++;
				sorted = true;

				for (int i = dimension - 1; i >= counter; i--) {
					int a = arrLibretto.restituisciCrediti();
					int b = arrLibretto[i - 1].restituisciCrediti();
					if (b > a) {
						swap(i, (i - 1));
						sorted = false;
					}
				}
			}
		}

	}

	private void swap(int index1, int index2) {
		Libretto temp = arrLibretto[index1];
		arrLibretto[index1] = arrLibretto[index2];
		arrLibretto[index2] = temp;
	}
}

noterete che il codice viene ripetuto 3 volte, una per ogni attributo dell'oggetto, ed è proprio questo che vorrei evitare.
Come posso fare?
P.S. Spero di aver postato nella sezione giusta essendo il mio primo post, altrimenti chiedo gentilmente ai moderatori di avvertirmi.
Grazie in anticipo a tutti.

[VincenzoTheBest]

Originariamente inviato da kiowa91
Ciao a tutti, vi espongo subito il mio problema.
Ho scritto un programmino che gestisce un libretto universitario.
Il programma ordina in maniera crescente a seconda della materia(Stringa), del voto(intero) o dei crediti(intero) maturati in quell'esame (la scelta è a carico dell'utente).
L'ordinamento viene fatto mediante il semplice BubbleSort prendendo in input oggetti di tipo "Libretto" con i relativi metodi per recuperare materia, voto e crediti.
il mio problema nasce qui: per ordinare tipi diversi di dato copio più volte l'algoritmo di ordinamento causando ridondanza del codice che vorrei evitare.

La soluzione sta nel definire 3 comparatori diversi (magari volendo solo 2), ognuno dei quali induce un determinato ordinamento.
Quindi, ti conviene organizzare il metodo così

public void ordinaElementi(Comparator<Libretto> ordinamento) {
         // ... quindi nel bubble sort usi il metodo compare 
         // ridefinito ad hoc per fare i confronti
}

in modo tale che a seconda del tipo di ordinamento richiesto, istanzi e passi a questo metodo il relativo comparatore, appunto definito ad hoc.

Ecco il link alla relativa documentazione ufficiale: java.util.Comparator.

N.B. Io ti consiglio di rivederti meglio l'astrazione di Libretto e la relativa classe (ad esempio il metodo aggiungiElementi). Inoltre, potresti introdurre ulteriori classi, in modo tale da gestire più facilmente la rappresentazione stessa di un Libretto.

[kiowa91]

Innanzi tutto ti ringrazio per l'aiuto ed i consigli datomi,
in secondo luogo non ho capito bene cosa intendi il il N.B. sia l'argomento relativo alla classe libretto, sia l'aggiunta di più classi!

N.B. Io ti consiglio di rivederti meglio l'astrazione di Libretto e la relativa classe (ad esempio il metodo aggiungiElementi). Inoltre, potresti introdurre ulteriori classi, in modo tale da gestire più facilmente la rappresentazione stessa di un Libretto.

[kiowa91]

ah, poi avrei un altro dubbio;
anzichè utilizzare dei comparatori o l'interfaccia comparable (non ancora spiegati a lezione, pertanto ci vietano di usarli), potrei implementare un metodo comune per i 3 ordinamenti?
mi spiego:

           public void ordinaElementi(String elemento){
		if (elemento.compareToIgnoreCase("MATERIA") == 0) {

bubbleSort(arrLibretto[]);
/*
* però non so come implementare il metodo arrLibretto[i].restituisciMateria
*/


		} else if (elemento.compareToIgnoreCase("VOTO") == 0) {

bubbleSort(arrLibretto[]);
*/
* però non so come implementare il metodo arrLibretto[i].restituisciVoto
*/


		} else if (elemento.compareToIgnoreCase("CREDITI") == 0) {

bubbleSort(arrLibretto[]);
*/
* però non so come implementare il metodo arrLibretto[i].restituisciCrediti
*/

	}


private void bubbleSort(Libretto[] arrayLibretto) {
			int dimension = arrayLibretto.length;
			int counter = 0;
			boolean sorted = false;

			while ((counter < dimension) && (!sorted)) {
				counter++;
				sorted = true;

				for (int i = dimension - 1; i >= counter; i--) {
					if (((arrayLibretto[i - 1])   
							.compareTo(arrayLibretto[i])) > 0) {
						swap(i, (i - 1));
						sorted = false;
					}
				}
			}
               }

Avevo pensato di fare qualcosa del genere:

           public void ordinaElementi(String elemento){
		if (elemento.compareToIgnoreCase("MATERIA") == 0) {

bubbleSort(arrLibretto[], arrLibretto[i].restituisciMateria(), arrLibretto[i-1].restituisciMateria());
/*
* però non so come implementare il metodo arrLibretto[i].restituisciMateria
*/


		} else if (elemento.compareToIgnoreCase("VOTO") == 0) {

bubbleSort(arrLibretto[], arrLibretto[i].restituisciVoto(), arrLibretto[i-1].restituisciVoto());
*/
* però non so come implementare il metodo arrLibretto[i].restituisciVoto
*/


		} else if (elemento.compareToIgnoreCase("CREDITI") == 0) {

bubbleSort(arrLibretto[], arrLibretto[i].restituisciCrediti(), arrLibretto[i-1].restituisciCrediti());
*/
* però non so come implementare il metodo arrLibretto[i].restituisciCrediti
*/

	}


private void bubbleSort(Libretto[] arrayLibretto) {
			.......
}

Che non riesco a implementare correttamente.

[VincenzoTheBest]

Originariamente inviato da kiowa91
ah, poi avrei un altro dubbio;
anzichè utilizzare dei comparatori o l'interfaccia comparable (non ancora spiegati a lezione, pertanto ci vietano di usarli)

Però puoi sicuramente farne un uso diverso, perciò un' alternativa può essere questa:
introdurre un metodo che ti restituisce la chiave secondo cui effettuare l'ordinamento

    private Comparable getElemento(String elemento, Libretto libretto) {
    	// String e Integer sono istanze di Comparable ...
    }

Dunque, il confronto che andrai a fare nel bubble sort è il seguente:

if ( getElemento(elemento, arrLibretto[i - 1]).compareTo(getElemento(elemento, arrLibretto[i])) > 0 ) {
    // ...
}

[kiowa91]

Non mi è molto chiaro cosa debba fare questo metodo.
La chiave di ricerca viene inserita da parte dell'utente nel main accedendo al metodo ordinaElementi().

public void ordinaElementi(String elemento) {
		if (elemento.compareToIgnoreCase("MATERIA") == 0) {
                   ....
                 } else if (elemento.compareToIgnoreCase("VOTO") == 0) {
                   ....
                 } else if (elemento.compareToIgnoreCase("CREDITI") == 0) {
                   ....
                 }

dove String elemento è la chiave.
Non so se ho inteso bene quello che volevi dirmi

[VincenzoTheBest]

Originariamente inviato da kiowa91
Non so se ho inteso bene quello che volevi dirmi

No, infatti non hai capito.
Prova ad implementare l'ultima soluzione che ti ho suggerito.

Si tratta semplicemente di aggiungere il metodo getElemento in GestioneLibretto e cambiare come indicato il controllo nel bubble sort.

[kiowa91]

Lo farei, ma non ho capito cosa deve fare questo mentodo!e di conseguenza come implementarlo

[VincenzoTheBest]

Originariamente inviato da kiowa91
Lo farei, ma non ho capito cosa deve fare questo mentodo!e di conseguenza come implementarlo

Deve restituire il campo dell'istanza Libretto indicato dalla stringa elemento.

Se, ad esempio, elemento è uguale a "materia" allora getElemento deve restituire il campo di istanza materia dell'oggetto libretto.

[kiowa91]

allora ho risolto così:
Oggetto Libretto:

public class Libretto {
	private static final int VOTO_MINIMO = 18;
	private static final int VOTO_MASSIMO = 30;
	String materia;
	int voto;
	int crediti;

	public Libretto() {
		this.materia = inserisceMateria();
		this.voto = inserisceVoto();
		this.crediti = inserisciCrediti();
	}
	
	/**
	 * Inserisce la materia.
	 * @return materia: il valore corrente della materia inserita.
	 */
	public String inserisceMateria() {
		System.out.println("inserisci materia");
		Scanner in = new Scanner(System.in);
		return this.materia = in.next();
	}
	
	/**
	 * Inserisce il voto.
	 * Controlla che il voto sia compreso tra 18 e 30,
	 * se inferiore o superiore restituisce un valore negativo.
	 * @return votoValido: il valore corrente del voto inserito.
	 */
	public int inserisceVoto() {
		System.out.println("inserisci voto");
		Scanner in = new Scanner(System.in);
		this.voto = in.nextInt();
		int votoValido; //valore di ritorno

		if ((this.voto >= VOTO_MINIMO) && (this.voto <= VOTO_MASSIMO)) {
			votoValido = this.voto;
		} else {
			votoValido = -1;
		}
		return votoValido;
	}
	
	/**
	 * Inserisce i crediti.
	 * @return crediti: il valore corrente dei crediti inseriti.
	 */
	public int inserisciCrediti() {
		System.out.println("inserisci crediti");
		Scanner in = new Scanner(System.in);
		return this.crediti = in.nextInt();
	}

	public String restituisciMateria() {
		return materia;
	}

	public int restituisciVoto() {
		return voto;
	}

	public int restituisciCrediti() {
		return crediti;
	}

	public boolean compareTo(Libretto libretto) {
		if (this.restituisciMateria().compareTo(libretto.restituisciMateria()) == 0) {
			if (Integer.toString(this.restituisciVoto()).compareTo(Integer.toString(libretto.restituisciVoto())) == 0) {
				return Integer.toString(this.restituisciCrediti()).compareTo(Integer.toString(libretto.restituisciCrediti())) ==  0;
			}
			else return Integer.toString(this.restituisciVoto()).compareTo(Integer.toString(libretto.restituisciVoto())) > 0;
		}
		else return this.restituisciMateria().compareTo(libretto.restituisciMateria()) > 0;
	}
}

Gestione dell'oggetto:

public class GestioneLibretto {
	/*
	 * contiene gli oggetti di tipo libretto creati dall'utente.
	 */
	Libretto[] arrLibretto;

	/**
	 * Definisce la dimensione massima del libretto.
	 * 
	 * @param dimensione
	 *            : dimensione massima inserita dall'utente.
	 */
	public void definisciDimensione(int dimensione) {
		arrLibretto = new Libretto[dimensione];
	}

	/**
	 * Popola il libretto in base alla dimensione del libretto inizializzato
	 * dall'utente.
	 */
	public void aggiungiElementi() {
		for (int i = 0; i < arrLibretto.length; i++) {
			Libretto libretto = new Libretto();
			arrLibretto[i] = libretto;
		}
	}

	/**
	 * Visualizza gli elementi presenti nel libretto; Visualizza la materia, il
	 * voto e i crediti relativi all'elemento appartenente al libretto; la
	 * variabile "j" inizializza l'indice della lista di elementi.
	 */
	public void visualizzaElementi() {
		for (int i = 0, j = 1; i < arrLibretto.length; i++, j++) {
			System.out.println(j + ") " + arrLibretto[i].restituisciMateria()
					+ " " + arrLibretto[i].restituisciVoto() + " "
					+ arrLibretto[i].restituisciCrediti());
		}
	}

	public void ordinaElementi() {
		int dimension = arrLibretto.length;
		int counter = 0;
		boolean sorted = false;
		
		while ((counter < dimension) && (!sorted)) {
			counter++;
			sorted = true;
			
			for (int i = dimension -1; i >= counter; i--) {
				if (arrLibretto[i - 1].compareTo(arrLibretto[i])) {
					swap(i,(i-1));
					sorted = false;
				}
			}
		}
	}

	private void swap(int index1, int index2) {
		Libretto temp = arrLibretto[index1];
		arrLibretto[index1] = arrLibretto[index2];
		arrLibretto[index2] = temp;
	}
}

Anzichè dare all'utente la possibilità di scegliere come ordinare il libretto, ho creato un metodo che ordina in base a una priorità da me stabilita, evitando di fare copie inutili del codice (ho preso spunto dai tuoi consigli).
Direi problema risolto, ti ringrazio Vincenzo
Se hai qualche altro consiglio per come ottimizzare il software è ben accolto, grazie ancora.