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.
codice:
/*
 * 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.

codice:
/*
 * 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.