[JAVA] Disperazione implementazione interface

[Rintrah84]

Ciao...in un vecchio compito di esame mi viene chiesto di implementare un tipo di dato Registro che rappresenta un GENERICO contenitore di una singola informazione che supporti le operazioni di lettura e scrittura.
Poi devo implementare un tipo di dato Archivio che rappresenta e gestisce una collezione di registri.

Infine devo implementare i tipi RegistroBinario che rappresenta un registro il cui campo informativo può contenere solo 0 o 1 e MemoriaRam che rappresenta la memoria Ram di un calcolatore

Io l'ho pensato così: realizzo Registro come un'interface che mi dice che tutti i sottotipi che implementano Registro devono poter leggere e scrivere su di un regiestro:

/** OVERVIEW: L'interface Registro rappresenta un GENERICO contenitore di una singola informazione. Tutte le implementazioni
			  dell'interface Registro devono poter accedere in lettura e scrittura all' informazione in esso contenuta */
			  
public interface Registro{
	
	public Object read();   		// Restituisce un Object al chiamante (il tipo effettivo dienderà dall'implementazione)
	public void write(Object x);  // Scrive un Object dentro ad un registro (il tipo effettivo dipende dall'implementazione)
	
}

Poi realizzo Archivio semplicemente come una collezione di dati di tipo Registro ed uso un Vector per implementare talecollezione...munendo tale classe Archivio di qualche operatore (tra cui un iteratore che veniva richiesto dalla proff):

import java.util.*;
import java.lang.*;

/** OVERVIEW: La classe Archivio rappresenta e gestisce una collezione di oggetti di tipo Registro. Un oggetto di tipo
			  Archivio potrà contenere al suo interno qualsiasi oggetto avente Registro come supertipo e dovrà supportare le
			  operazioni di: aggiungere un elemento in fondo alla collezione, rimuovere un elemento dalla collezione,
			  sostituire un particolare elemento della collezione co un'altro, un iteratore.
			  
			  V = {{r_1, r_2, r_3,...., r_n} : r_i è un oggetto di tipo Registro}
			  O = Add, Delete, Replace, Iterator
			  C = 0	(non ci sono costanti significative) */
			  
public class Archivio{
	
	private Vector archivio;		// Usa un Vector per rappresentare l'archivio
	
	/** COSTRUTTORE:
		EFFECTS: Costruisce un nuovo oggetto di tipo Archivio
		@param: void
		@return: Il riferimento ad un nuovo oggetto di tipo Archivio */
		
	public Archivio(){
		archivio = new Vector();		// Crea un nuovo archivio vuoto
	}
	
	/** Metodo Add():
		EFFECTS: Aggiunge il parametro in fondo all'archivio
		@param: r di tipo Registro
		@return: void */
	
	public void add(Registro r){
		archivio.addElement(r);			// Aggiunge il parametro all'archivio
	}
	
	/** Metodo Delete():
		EFFECTS: Rimuove l'i-esimo elemento dall'archivio
		@param: i di tipo int
		@return: void */
		
	public void delete(int i){
		
		if(i <= archivio.size())			// Se il valore del parametro i è una posizione esistente nel Vector archivio
			archivio.remove(i);				// l'elemento in posizione i viene rimosso
			
		else throw new FailureException();	// Altrimenti viene sollevata un'eccezione
	}
	
	
	/** Metodo Replace():
		EFFECTS: Sostituisce un particolare elemento della collezione con un altro elemento
		@param: i di tipo int che rappresenta la posizione nell'archivio dell'elemento da sostituire
		@param: r di tipo Registro che rappresenta il nuovo elemento che verrà inserito al posto del vecchio
		@return: void */
		
	public void replace(int i, Registro r){
		
		if(i <= archivio.size())			// Se il valore del parametro i è una posizione esistente nel Vector archivio
			archivio.set(i, r);				// allora sostituisce l'elemento in posizione i con il Registro r
			
		else throw new FailureException();	// Altrimenti viene sollevata un'eccezione
	}
	
	/** get():
		EFFECTS: Se possibile restituisce l'i-esimo elemento dall'archivio, non è possibile restituire un elemento avente 
				 posizione negativa o maggiore della dimensione della collezione
		REQUIRES: L'archivio non deve essere vuoto ed il parametro che indica la posizione dell'elemento da restituire
				  deve essere >=0 e < della dimensione della collezione
		@param: int indica la posizione dell'elemento da restituire
		@return: Un oggetto di tipo Registro */
		
	public Registro get(int i){
		
		if(i >= 0 && i <= archivio.size() && archivio != null)		// Se possibile restituire l'elemento lo restituisce
			return (Registro) archivio.elementAt(i);
			
		else throw new FailureException();		// Se invece non lo è solleva una FailureException
	
	}
	
	private class MioIteratore implements Iterator{		// E' la classe interna che implementa l'interfaccia Iterator
		
		private int dove;		// Variabile che indica dove ci si trova all'interno dell'archivio durante l'iterazione
		
		public MioIteratore(){		// Costruttore del generatore
			dove = 0;	// Imposto la variabile dove a 0 per far iniziare l'iterazione dal primo elemento dell'archivio
		}
		
		public Object next(){
			return archivio.elementAt(dove);	// Ritorna l'elemento corrente dell'archivio
		}
	
		public boolean hasNext(){
			return dove < archivio.size();	// Se dove non è l'ultimo elemento dell'archivio risponde true, altrimenti false
		}
		
		public void remove(){
			dove ++;		// Rimuove l'elemento dall'iteratore (non dall'archivio) spostando dove al successivo elemento
		}
	}
	
	public Iterator enumera(){		// Maschero l'implementazione di MioIterator usando un metodo enumera
		return new MioIteratore();
	}
	
	
	
}

Poi adesso voglio realizzare RegistroBinario che sarà un'implementazione di Registro e che dovrà implementare i 2 metodi dichiarati in Registro:

** La classe RegistroBinario implementa l'interface Registro per realizzare un particolare tipo di registro che può 
	contenere solo i valori binari 0 o 1 
	V = {i: i = 0 or i = 1}
	O = 1) Lettura del valore binario contenuto in un registro. 2) Scrittura di un valore binario in un registro.
	C = 0 (non ci sono costanti significative) */
	
public class RegistroBinario implements Registro{
	
	int valoreBinario;			// Conterrà al suo interno il campo informativo binario del registro binario
	
	/** COSTRUTTORE:
		EFFECTS: Costruisce un oggetto ditipo RegistroBinario inizianizzandolo con il valore del parametro, se il parametro
				 è un valore diverso da 0 o da 1 solleva un'eccezione.
		@param: Un int
		@return: Il riferimento ad un oggetto di tipo RegistroBinario */
		
	public RegistroBinario(int val){
		
		if(val != 0 || val != 1)				// Se il parametro non è valido solleva una FailureException
			throw new FailureException();
			
		else valoreBinario = val;				// Altrimenti metti il parametro nel campo informativo dell'oggetto
	}
	
	/** METODO READ():
		EFFECTS: Legge il contenuto binario del campo informativo di un oggetto RegistroBinario
		PARAM: void
		RETURN: Un int che può avere valore o 0 o 1 */
		
	public int read(){
		return valoreBinario;
	}
	
	/** METODO WRITE():
		EFFECTS: Scrive un valore binario ricevuto come parametro all'interno del campo informativo di un oggetto di tipo
			 RegistroBinario (se il parametro è valido, altrimenti solleva un'eccezione)
		PARAM: Un oggetto di tipo int
		RETURN: void */
		
	public void write(int val){
		if(val != 0 || val != 1)				// Se il parametro non è valido solleva una FailureException
			throw new FailureException();
			
		else valoreBinario = val;				// Altrimenti metti il parametro nel campo informativo dell'oggetto
	}
}

[b] PROBLEMA: Se compilo...leprime 2 classi no problem...mentre nella compilazione di RegistroBinario mi dà i seguenti errori:

C:\Programmi\Crimson Editor\template\esercizi\esami\Registro>javac RegistroBinario.java
RegistroBinario.java:7: RegistroBinario is not abstract and does not override abstract method write(java.lang.Object) in R
egistro
public class RegistroBinario implements Registro{
^
RegistroBinario.java:30: read() in RegistroBinario cannot implement read() in Registro; attempting to use incompatible ret
urn type
found : int
required: java.lang.Object
public int read(){
^
2 errors

Come mai? In Registro gli ho detto che il metodo read() restituisce un generico Object e nella sua implementazione RegistroBinario gli dico di restituire un sottotipo di Object cioè un int...ma non me lo fa fare? Forse dipende dal fatto che int è un tipo primitivo? mmm se gli faccio restituire un integer potrebbe andare? Ma come posso fargli restituire un integer mettendoci dentro il valore da restituire?

Poi per l'ultimo punto per implementare la classe MemoriaRam ho pensato: un Archivio è un file....allora creo una classe MemoriaRam che realizza una collezione di archivi ed ho fatto...

Ci può stare come raggionamento? Secondo voi sarebbe promossuto ad un compito del genere (è su carta) doh

Tnx

[morskott]

se usi i generics?

public interface Registro<T>{
    public T read();
    public void write(T x);
}

public class RegistroBinario implements Registro<Integer>{
    public Integer read(){
         //Implementazione
    }

    public void write(Integer x){
          //Implementazione
    }
}

e l'archivio conterra un

private Vector<Registro<?>> regs; //non so se il ? va bene

Francamente non son sicuro al 100% che funziona.

Comunque senza i generics sei obbligato nelle classi che implementano le interfaccie a implementare i metodi dell'interfaccia così come sono, non puoi sostituire con sottotipi (per come so io, poi non ci metterei la mano sul fuoco), dovrai castare ogni volta, cosa che con i generics ti eviteresti.

[Rintrah84]

Originariamente inviato da morskott

se usi i generics?

public interface Registro<T>{
    public T read();
    public void write(T x);
}

public class RegistroBinario implements Registro<Integer>{
    public Integer read(){
         //Implementazione
    }

    public void write(Integer x){
          //Implementazione
    }
}

e l'archivio conterra un

private Vector<Registro<?>> regs; //non so se il ? va bene

Francamente non son sicuro al 100% che funziona.

Comunque senza i generics sei obbligato nelle classi che implementano le interfaccie a implementare i metodi dell'interfaccia così come sono, non puoi sostituire con sottotipi (per come so io, poi non ci metterei la mano sul fuoco), dovrai castare ogni volta, cosa che con i generics ti eviteresti.

I generics non sono programma d'esame...intendi dire che dovrei castare nella classe RegistroBinario?

Ad occhio credo che il problema sia che nel metodo read() della classe RegistroBinario gli faccio ritornare un int che non è un Object ma un tipo primitivo.
E se gli impacchetto il valore di ritorno dentro un Integer che è un Object?Eventualmente come posso impacchettare un int in un Integer?

Cmq come logica il mio esercizio è corretto? Visto che è un esame su carta e non al pc pensi che potrei passarlo? (magari non con il massimo...)

Grazie
Andrea

[malocchio]

Originariamente inviato da Rintrah84

I generics non sono programma d'esame...intendi dire che dovrei castare nella classe RegistroBinario?

Ad occhio credo che il problema sia che nel metodo read() della classe RegistroBinario gli faccio ritornare un int che non è un Object ma un tipo primitivo.
E se gli impacchetto il valore di ritorno dentro un Integer che è un Object?Eventualmente come posso impacchettare un int in un Integer?

Cmq come logica il mio esercizio è corretto? Visto che è un esame su carta e non al pc pensi che potrei passarlo? (magari non con il massimo...)

Grazie
Andrea

Premettendo che non ho letto proprio TUTTO il codice, il problema è proprio quello. Se vuoi sovrascrivere un metodo covariante devi dichiarare un Integer come tipo di ritorno. Con Java5 (credo) non c'è questa grande differenza nell'usare int o Integer (almeno nella parte del codice), in quanto l'auto(un)boxing fa il suo sporco lavoro e ti lascia libero di fregartene di convertire da tipo primitivo a classe wrapper e viceversa.

Comunque dichiarando il metodo read in RegistroBinario con tipo di ritorno sottotipo di Object non ha questa grande utilità, perché quando vai ad utilizzare oggetto RegistroBinario, molto probabilmente (le variabili reference in Java sono preferibilmente dichiarate con un tipo di interfaccia, piuttosto che con un'implementazione della stessa) vi accederai tramite una variabile di tipo Registro, e quindi richiamando il metodo read avrai un reference di tipo Object. Potrai castarlo ovviamente a Integer dopo un opportuno controllo con l'instanceof.

Ovviamente l'uso dei generics qui è altamente consigliato, se non addirittura la scelta giusta da operare. In questo modo ti eviti controlli e cast.

Penso che questa scrittura

private Vector<Registro<?>> regs; //non so se il ? va bene

non sia accettata. Devi dichiarare il tipo del template.

[banryu79]

Originariamente inviato da malocchio

.
Penso che questa scrittura

private Vector<Registro<?>> regs; //non so se il ? va bene

non sia accettata. Devi dichiarare il tipo del template.

Invece è accettata dal compilatore.
E' al momento dell'istanziazione di un oggetto concreto che andrà specificato il parametro generico per Registro.

Vector<Registro<?>> r = new Vector<Registro<String>>();

Una buona fonte di consultazione, molto completa e ben organizzata, per il sistema dei Generics la trovate qui

[malocchio]

Originariamente inviato da banryu79

Invece è accettata dal compilatore.
E' al momento dell'istanziazione di un oggetto concreto che andrà specificato il parametro generico per Registro.

Vector<Registro<?>> r = new Vector<Registro<String>>();

Una buona fonte di consultazione, molto completa e ben organizzata, per il sistema dei Generics la trovate qui

OK, su queste cose allora sono un po' arrugginito.
Quindi il tipo di ritorno del metodo read di Registro è determinato dal tipo specificato nel template dell'instanziazione (brutta parola), invece che dal tipo dichiarato del reference?

Magari l'ho visto qualche volta, senza sapere precisamente come funziona.
Vabbè mi andrò a rileggere il capitolo generics, che fa sempre bene!

[Rintrah84]

Vi ringrazio...certo che sti generics potevano anche metterli nel programma d'esame che sembrano molto utili...

Cmq come logica generale ci può stare il mio esercizio?
Anche se non perfetto secondo voi avrei la pssibilità di passare l'esame impostandolo in tale modo?

Tnx

[banryu79]

Originariamente inviato da malocchio

OK, su queste cose allora sono un po' arrugginito.
Quindi il tipo di ritorno del metodo read di Registro è determinato dal tipo specificato nel template dell'instanziazione (brutta parola), invece che dal tipo dichiarato del reference?

La parola "brutta", in questo contesto, è la parola "template", che con il sistema dei Generics di Java non ha niente a che vedere (la parola "template" come concetto rimanda più cha altro ai template del C++, ma sono appunto tutta un'altra cosa).

Quel "?" nel tipo dichiarato è un "wildcard", cioè un costrutto sintattico che descrive una famiglia di tipi.
Nello specifico, da solo, significa "tutti i tipi", e si chiama "unbounded wildcard".

Ecco una tabellina riassuntiva:

<?> - unbounded wildcard

<? extends Type> - un wildcard con un "upper bound". Significa: la famiglia di tutti i tipi che sono sottotipi di Type.

<? super Type> - un wildcard con un "lower bound". Significa: la famiglia di tutti i tipi che sono supertipi di Type.

I wildcards sono usati, come già detto, per dichiarare "wildcard parametrized types", in tutti quei casi in cui non si hanno informazioni complete su quale sarà l'esatto tipo generico richiesto per un dato tipo parametrico.

[malocchio]

Originariamente inviato da banryu79

La parola "brutta", in questo contesto, è la parola "template", che con il sistema dei Generics di Java non ha niente a che vedere (la parola "template" come concetto rimanda più cha altro ai template del C++, ma sono appunto tutta un'altra cosa).

Quel "?" nel tipo dichiarato è un "wildcard", cioè un costrutto sintattico che descrive una famiglia di tipi.
Nello specifico, da solo, significa "tutti i tipi", e si chiama "unbounded wildcard".

Ecco una tabellina riassuntiva:

<?> - unbounded wildcard

<? extends Type> - un wildcard con un "upper bound". Significa: la famiglia di tutti i tipi che sono sottotipi di Type.

<? super Type> - un wildcard con un "lower bound". Significa: la famiglia di tutti i tipi che sono supertipi di Type.

I wildcards sono usati, come già detto, per dichiarare "wildcard parametrized types", in tutti quei casi in cui non si hanno informazioni complete su quale sarà l'esatto tipo generico richiesto per un dato tipo parametrico.

Heheh lo so che i template son relativi al C++ ma ormai ci ho fatto un'abitudine ad usarla come parola!


Comunque prima pensavo che quel genere di dichiarazioni di tipo si potesse fare solo per i parametri dei metodi...