Propagazione di una eccezione

[capcla]

Scusate, non riesco a capire come svolgere l'ultima parte di questa traccia

Definire una classe OutOfRangeSampleSize per modellare una eccezione
controllata da considerare qualora il numero k di cluster inserito da tastiera
è maggiore maggiore rispetto al numero di centroidi generabili dall'insieme di
transazioni.
In tale case l'oggetto eccezione va creato e sollevato nella implementazione
del metodo sampling(...).
public int[] sampling(int k) throws OutOfRangeSampleSize // da Modificare
Comportamento: Se k<=0 or k>distinctTuples allora si crea ed espelle un
oggetto istanza di OutRangeSampleSize. Altrimenti si procede con
implementazione definite in precedenza
L'oggetto eccezione deve essere propagato fino al main (seguendo lo stack
delle chiamate). Il gestore di tale eccezione deve essere opportunamente
definito nel main della classe MainTest.

Allora, io ho creato la classe OutOfRangeSampleSize

public class OutOfRangeSampleSize extends Exception{
   public OutOfRangeSampleSize() {}
   public OutOfRangeSampleSize(String msg) {
   super(msg);}
}

e nel metodo sampling ho aggiunto il seguente codice riguardante l'eccezione

public int[] sampling(int k) throws OutOfRangeSampleSize{
			
	if(k <= 0)
                throw new OutOfRangeSampleSize("k <= 0");
			
	if(k>distinctTuples)
		throw new OutOfRangeSampleSize("k>distinctTuples");

 ........(resto del codice)

Come faccio ora a prorogare l'oggetto eccezione?
La classe dove devo prorogare l'oggetto in questione, è la seguente

import mining.KMeansMiner;
import data.Data;
import keyboardinput.Keyboard;


public class MainTest {

        /**
	 * @param args
	 */
	public static void main(String[] args) {
		
		
	        Data data =new Data();
		System.out.println(data);
		char continua;
		boolean uscita = true;
		//int k=3;
		do{
			
		
			System.out.print("Inserisci k: ");
//*****QUI VIENE INSERITO IL k CHE VIENE RICHIESTO NEL METODO sampling******//			

                        int k = Keyboard.readInt();
			KMeansMiner kmeans=new KMeansMiner(k);
			int numIter=kmeans.kmeans(data);
			System.out.println("Numero di Iterazione:"+numIter);
			System.out.println(kmeans.getC().toString(data));
			
			do{
				System.out.print("Vuoi ripetere l'esecuzione? y/n: ");
				continua = Keyboard.readChar();
				System.out.println("continua: " + continua);
								
				switch(continua){
					case 'y':
					case 'Y':
					case 'n':
					case 'N':
						uscita = true;
						break;
					default: {
						uscita = false;
						System.out.println("Inserire il carattere corretto");
						}
					
				}
			
			}while(uscita == false);
			
			
		}while(continua == 'y' || continua == 'Y');
		
	}

}

Grazie

[robbie89]

Così ad occhio ti direi che devi richiamare il metodo sampling nella classe main, e nel caso venisse lanciata l'eccezione, tu debba gestirla con un try e catch.

Nella traccia c'è scritto di gestirla fino al main, io quindi procederei in questo modo.

[capcla]

Non credo che vada implementato così. È vero che il metodo sampling non viene direttamente richiamato da MainTest ma questo perché ci sono tutta una serie di richiami di altre classi le quali non ho riportato per semplicità. Richiamare il metodo sampling in MainTest significherebbe, semplicemente, non far lavorare il programma come previsto

[robbie89]

ok va bene, questo però non l'hai detto.

ci sono tutta una serie di richiami di altre classi le quali non ho riportato per semplicità

è lì che devi lanciare l'eccezione, fino ad arrivare al main test.

classe A con metodo sampling (quì devi lanciare l'eccezione)

classe B che chiama il metodo sampling di A (il tuo metodo deve gestire l'eccezione, magari lanciandola a sua volta)

classe C che chiama il metodo di B che chiama sampling (il tuo metodo deve gestire l'eccezione, magari lanciandola a sua volta)

classe MAIN chiama la classe C che chiama sampling

La logica è sempre la stessa, sia se il main chiama direttamente la funzione sia indirettamente.

[capcla]

E come la lancio? Come ho fatto in sampling

[robbie89]

Originariamente inviato da capcla
E come la lancio? Come ho fatto in sampling

si esatto.

in un metodo, nel quale può essere scatenata un'eccezione ci sono 2 modi per gestirla:

- racchiuderla in un try e catch gestendola subito
- lanciandola a sua volta con una throw

nel tuo caso devi rilanciarla con una throw, in questo modo il controllo ritorna al metodo chiamante, che dovrà gestire l'eccezione, nel tuo caso dovrai continuare a rilanciarla fino a quando non sarai nel punto in cui ti è stato detto che devi gestirla.

[capcla]

Allora, ho risolto in questo modo
Il metodo sampling l'ho modificato in questo modo visto che dopo il blocco try mi richiedeva necessariamente una clausola finally anche se non avevo niente da eseguire

public int[] sampling(int k) throws OutOfRangeSampleSize{
			
			try{
				if(k <= 0)
					throw new OutOfRangeSampleSize("k <= 0");
			
				if(k>distinctTuples)
					throw new OutOfRangeSampleSize("k>distinctTuples");	
			} finally{};
...

Successivamente, in ogni metodo delle altre classi che richiamava il metodo sampling, ho aggiunto dopo l'intestazione del metodo stesso la scritta throws OutOfRangeSampleSize. Viene quindi qualcosa del tipo

intestazioneDelMetodoESuoiParametri throws OutOfRangeSampleSize{
...

Infine, il MainTest l'ho modificato in questo modo

public class MainTest {

	public static void main(String[] args) throws OutOfRangeSampleSize{
		
		
		Data data =new Data();
		System.out.println(data);
		char continua;
		boolean uscitaDo = true;
		//int k=3;
		do{
			
		
			System.out.print("Inserisci k: ");
			int k = Keyboard.readInt();
			KMeansMiner kmeans=new KMeansMiner(k);

/////////////////MODIFICA DEL METODO APPORTATA
			try{
				int numIter=kmeans.kmeans(data);
				System.out.println("Numero di Iterazione:"+numIter);
			} catch(OutOfRangeSampleSize e){
				System.err.println("Caught an exception: "+ e);
			}
/////////////////FINE DELLA MODIFICA DEL METODO
...

Grazie a tutti

PS: Domanda: ma se avessi avuto una chiamata a sampling da un metodo della sua stessa classe, lo avrei dovuto gestire come le chiamate dei metodi delle classi superiori?

[robbie89]

PS: Domanda: ma se avessi avuto una chiamata a sampling da un metodo della sua stessa classe, lo avrei dovuto gestire come le chiamate dei metodi delle classi superiori?

dipende da cosa devi fare, puoi farlo in tutti e 2 i modi, dipende da cosa devi fare.

nel tuo esercizio ti veniva esplicitamente chiesto di propagare l'eccezione