[Java] Wrong number of type arguments su progetto

[ashely]

Devo fare un progetto in cui devo implemetare i metodi di un dizionario ordinato con un albero 234 e nella classe di test tree234test vengono fuori qusti errori come si risolvono?
E' un progetto di algoritmi e strutture dati, la classe è quasi completa mi mancano alcuni metosi che non ho ancora messo, volevo provare a vedere se fa quelo che dovrebbe se i metodi scritti sono giusti secondo quello che ha detto il prof ma, ad esempio inserire un entry e stampare il risultato con una rappresentazione parentetica identata ma non posso sapere se è giusto come l'ho fatta fino ad addeso se non funziona la classe di test.
Se qualcuno può guardare il codice e dirmi cosa devo correggere e se ha consigli su come devo finire i metodi perchè sono un pò a corto di idee. Grazie
C:\Tree234\Tree\Tree234Test.java:46: wrong number of type arguments; required 3
private static void lancia (int s, Tree24<Integer,String> a){
^
C:\Tree234\Tree\Tree234Test.java:17: wrong number of type arguments; required 3
Tree24<Integer,String> theTree = new Tree24<Integer,String>();
^
C:\Tree234\Tree\Tree234Test.java:17: wrong number of type arguments; required 3
Tree24<Integer,String> theTree = new Tree24<Integer,String>();
^
C:\Tree234\Tree\Tree234Test.java:48: wrong number of type arguments; required 3
Tree24<Integer,String> theTree = new Tree24<Integer,String>();
^
C:\Tree234\Tree\Tree234Test.java:48: wrong number of type arguments; required 3
Tree24<Integer,String> theTree = new Tree24<Integer,String>();
^
C:\Tree234\Tree\Tree234Test.java:51: wrong number of type arguments; required 1
Node24<Integer,String> node;
^
6 errors

Process completed.

A chi mi aiuta invierò il rar con il progetto e tutte le classi.
Grazie in anticipo

[simo7784]

Il tuo tree24 va tipizzato con 3 argomenti, il tuo Node24 con uno.
Per l'aiuto, come da regolamento implementati il codice, poi quando incontri problemi fai una discussione con un tipolo esplicativo(non come questo!!!) ed una descrizione esauriente del problema. Poi aspetta le risposte.

[LeleFT]

Per il regolamento ti invito a leggerlo fra i link in rilievo.

Il titolo lo correggo io.


Ciao.

[ashely]

import java.io.*;
import java.util.Scanner;
/**
 * @(#)Tree234Test.java
 *
 * Tree234 application
 *
 * @author Scaggion Elisabetta
 * @version 1.00 2007/3/5
 */
 
public class Tree234Test {
    
    public static void main(String[] args) {
    	String value;
        Tree24<Integer,String> theTree = new Tree24<Integer,String>();
    	
        Scanner in = new Scanner(System.in);
        System.out.println("Comincia il test:");
        int scelta;
        do{
        	menu();
        	scelta = in.nextInt();
        	lancia(scelta, theTree);
        } while(scelta !=0);
        System.out.println("Arrivederci");
        
    
        } 
    
        private static void menu(){
    
                System.out.println(" [0] uscita");
                System.out.println(" [1] Inserisci un elemento");
                System.out.println(" [2] Elimina un elemento");
                System.out.println(" [3] Trova tutti gli elementi");
                System.out.println(" [4] Trova tutti gli elementi con una certa chiave");
                System.out.println(" [5] Rappresentazione parentetica identata dell'albero");
                System.out.println(" [6] N° elementi");
                System.out.println(" [7] Voce dell'albero con la chiave più piccola");
                System.out.println(" [8] lVoce dell'albero con la chiave più grande");
                System.out.println(" [9] Ritorna la prma voce dell'albero sucessiva a key");
                System.out.println(" [10] Ritorna la voce prima di key");
        } 
        private static void lancia (int s, Tree24<Integer,String> a){
                   
                   Tree24<Integer,String> theTree = new Tree24<Integer,String>();
    	
                   Scanner in = new Scanner(System.in);
                   Node24<Integer,String> node;
                switch(s) {
                	    case 1:
                	    	  
                	    	  System.out.print("Entra value da inserire: ");
                              String valu = in.nextLine();
                              theTree.insert(valu);
                              break;
                	    case 2: 
                	    	  	  
                              System.out.println("Elemento?");
                              int key = in.nextInt();
                              theTree.remove(valu);
                              System.out.println("Fatto");
                              break;
                        case 3:
                        	  System.out.println("Gli Elementi nell'albero");
                        	       theTree.findAll();
                        
                              break;
                              
                        case 4:
                        	   System.out.print("Entra value da trovare: ");
                                     String value = in.nextLine();
                                      int found = theTree.find(valu);
                                      if(found != -1)
                                        System.out.println("Found "+valu);
                                       else
                                        System.out.println("Could not find "+valu);
                               break;
                        
                        
                        case 5: System.out.println("Mostra l'albero");
                        	    theTree.print();                    
                              break;
                        
                        case 6:
                        	  System.out.println("Elementi" + a.size());
                        	  break;	  	        	    
                        case 7: System.out.println("Mostra ");
                        	    theTree.first(); 
                        	break;
                        case 8: System.out.println("Mostra ");
                        	      theTree.last(); 
                        	break;
                        case 9: System.out.println("Mostra ");
                        	    theTree.sucessor(); 
                        	break;
                        case 10: System.out.println("Mostra ");
                        	    theTree.predecessor();  			
                            break;    
    }
  }
}

[ashely]

Come detto prima devo completare un progetto che ho quasi finito di implementare, ma mi mancano alcuni metodi, quindi se mi aiutaste ve ne sarei grata. Devo finirlo entro l'8 luglio.
Nel messaggio non mi sta il codice quindi per farlo visionare ve lo devo mandare via e-mail.
Quello che devo fare c'è scritto nel post all'inizio.
Il codice è commentato.
Nel file che vi manderei c'è anche una relazione con le spiegazioni dettaglite di cosa devo fare.

[ashely]

Ho finito la classe ma continua ad esserci lo stesso errore e non capisco che cosa devo mettere dove dice wrong number of type: required...
Qualcuno può dirmi cosa devo mettere esattamente? Io non saprei proprio e devo consegnarla oggi via email. Grazie.

[simo7784]

Tree24 va tipizzato con tre argomenti <pippo,paperino,pluto> e non due. Quali siano i tipi non te lo so dire, il programma l'hai scritto tu.
Stesso dicorso per node:un parametro e non due, visto che e' un dizionario, immagino String.

[LeleFT]

Come ti hanno già detto, tu passi 2 argomenti alla classe Tree24 e 2 alla classe Node24, mentre il compilatore ti segnala che ne vuole 3 per la classe Tree24 e uno solo per la classe Node24.
Siccome non hai postato una sola riga di codice di queste 2 classi, non ci possiamo che fidare del compilatore (e io mi fiderei lo stesso, anche se tu avessi postato il codice): stai passando un numero di argomenti che non coincide con quanto richiesto.

Quanti argomenti vuole il costruttore della classe Tree24? (Io scommetto che ne vuole 3).
Quanti argomenti vuole il costruttore della classe Node24? (Io scommetto che ne vuole 1).


Ciao.

[ashely]

//realizzazione del nodo il dizionario � l'elemento del nodo

public class Node24<E extends OrderedDictionary> implements Position24<E>{

//costruttore principale
public Node24(E elem,Position24<E> par){
element=elem;
parent=par;
}

public Node24(Position24<E> par){ this(null,par); }

public Node24(E e){ this(e,null); }

public Node24(){ this(null,null); }
/**Restituisce l'elemento del nodo
*@return elemento del nodo*/
public E element(){ return element; }
/*Setta l'elemento nel nodo
*@param e dizionario**/
public void setElement(E o){ element=o; }
/**Restituisce il padre del nodo
*@return Position24 padre del nodo*/
public Position24<E> getParent(){ return parent; }
/**setta il padre
*@param padre del nodo*/
public void setParent(Position24<E> v){ parent=v; }

private Position24<E> parent;
private E element;
}

[ashely]

import java.util.Iterator;
import java.util.Comparator;

public class Tree24<E extends OrderedDictionary,K,V extends Value> implements Tree<E>,Dictionary<K,V>{

/**Costruttore principale*/
public Tree24(){
root=(Position24<E>)addRoot(null);
size=0;
}

/** Restituisce il numero di elementi dell'albero
@return int dimensione dell'albero*/
public int size(){ return size; }

/** Informa se l'albero � vuoto
@return true se l'labero � vuoto false altrimenti */
public boolean isEmpty(){ return (size==0); }

/** Restituisce un iteratore di elementi immagazzinati nell'albero
@return iteratore contenente gli elementi immagazzinati nell'albero */
public Iterator<E> iterator(){
PositionList<E> p=new NodePositionList<E>();
iterator(root,p);
return p.iterator();
}

private void iterator(Position24 v,PositionList<E> p){
//caso base foglia
if (v==null) return;
//caso base nodo esterno
E dict=(E)v.element();
if(isExternal(v)){
p.addLast(dict);
return;
}
for(int i=0;i<dict.size();i++){
// Entry temp=dict.getEntry(i);
iterator(dict.getChildAt(i),p);
}
p.addLast(dict);
}

/** Restituisce una collezzione iterabile dei nodi
@return Iterable<Position<E>> collezzione iterabile dei nodi */
public Iterable<Position<E>> positions(){
PositionList<Position<E>> p=new NodePositionList<Position<E>>();
positions(root,p);
return p;
}

/** Crea un collezzione iterabile dei nodi */
private void positions(Position24 v,PositionList<Position<E>> p){
E dict=(E)v.element();
//caso base foglia
if (v==null) return;
//caso base nodo esterno
if(isExternal(v)){
p.addLast(v);
return;
}
for(int i=0;i<dict.size();i++){
// Entry temp=dict.getEntry(i);
positions(dict.getChildAt(i),p);
}
p.addLast(v);
}


/** Modifica un elemento posizionato a un determinato nodo
@param v nodo di cui si desidera modificare l'elemento
@param e
* @return E elemento modificato
@exception InvalidPositionException se la posizione del nodo non � valida
*/
public E replace(Position<E> v, E e)throws InvalidPositionException{
Position24<E> temp=checkPosition(v);
E t=temp.element(); //Dizionario precedente
temp.setElement(e);
return t;
}

/** Ritorna il nodo root dell'albero
@return Position<E> nodo root dell'abero
@exception EmptyTreeException se l'albero � vuoto
*/
public Position<E> root() throws EmptyTreeException{
if(root==null)
throw new EmptyTreeException("Albero vuoto");
return root;
}

/** Ritorna il padre di un determinato nodo
@param v nodo di cui si vuole conoscere il padre
@return Position<E> posizione del nodo padre
@exception InvalidPositionException se la posizione del nodo non � valida
@throws BoundaryViolationException
*/
public Position<E> parent(Position<E> v)
throws InvalidPositionException, BoundaryViolationException{
Position24<E> temp=checkPosition(v);
return temp.getParent();
}

/** Ritorna una collezzione iterabile di figli di un determinato nodo
@param v posizione del nodo
@return Iterable<Position<E> collezzione iterabile dei figli del nodo v
@exception InvalidPositionException se la posizione del nodo non � valida
*/
public Iterable<Position<E>> children(Position<E> v) throws InvalidPositionException{
Position24 pos=checkPosition(v);
PositionList<Position<E>> p=new NodePositionList<Position<E>>();
E dict=(E)pos.element();
for(int i=0;i<dict.size();i++)
p.addLast(dict.getChildAt(i));
return p;
}

/** Informa se il nodo � interno
@param v nodo dell'albero
@return true se il nodo ha dei figli false altrimenti
@exception InvalidPositionException se la posizione del nodo non � valida
*/
//E' internal se ha figli e quindi se il riferimento al primo figlio non � vuoto
public boolean isInternal(Position<E> v) throws InvalidPositionException{
Position24<E> temp=checkPosition(v);
//So che l'elemento estratto � di tipo Value
Value x=(Value)temp.element().getEntry(0).getValue();
return (x.getChild()!=null);
}

/** Informa se il nodo � esterno
@param v nodo dell'albero
@return true se il nodo non ha figli false altrimenti
* @throws InvalidPositionException
*/
public boolean isExternal(Position<E> v)
throws InvalidPositionException{ return (!isInternal(v)); }

/** Informa se un determinato nodo � il nodo root dell'albero
@param v nodo dell'albero
@return true se il nodo � il root dell'albero false altrimenti
@exception InvalidPositionException se la posizione del nodo non � valida
*/
public boolean isRoot(Position<E> v) throws InvalidPositionException{
checkPosition(v);
return (v==root());
}

/**Aggiunge una radice
@param e elemento da inserire nel nodo
@exception NonEmptyTreeException se la radice � gi� presente
@return posizione della nuova radice creata
*/
public Position<E> addRoot(E e) throws NonEmptyTreeException{
if(!isEmpty())
throw new NonEmptyTreeException("L'alberto ha gi� una radice");
size=1;
root=createNode(e,null);
return root;
}

/**Crea un nuovo nodo
@param element elemento del nodo
@param parent posizone del padre
@return Position24<E> posizione del nuovo nodo
*/
//se non passo nulla come argomento o un dizionario vuoto inserisco un infinito come elemento
public Position24<E> createNode(E element,Position24<E> parent){
//Nodo vuoto
E temp=element;
if(element==null||temp.size()==0){
if(element==null)
temp=(E)new ArrayDictionary();
//inserisco l'elemento con chiave infinita
temp.insert(Integer.MAX_VALUE,new Value());
}
return new Node24(temp,parent);

}

/**crea un nuovo nodo con padre settato a null
@param element elemento da inserire nel nodo
@return posizione del nuovo nodeo creato*/
private Position24<E> createNode(E element){
return createNode(element,null);
}

/**Converte un riferimento di Position in Position24
@param v nodo da convertire
@return Position24<E> posizione convertita del nodo
@exception InvalidPositionException se v punta a null o non � di tipo Position24*/
private Position24<E> checkPosition(Position<E> v) throws InvalidPositionException{
if(v==null || !(v instanceof Position24))
throw new InvalidPositionException("Posizione non valida");
return (Position24<E>)v;
}