[JAVA] Errore che non riesco a capire

[Rocoat82]

Salve,
dovrei implementare una lista che contiene oggetti qualsiasi, solo che ho un problema a tempo di compilazione e non riesco a comprendere ciò che mi viene detto. Il messaggio di errore lo riporto qui di seguito:

C:\Documents and Settings\Administrator\Desktop\betaProg>javac -d *.java
Cellular.java:7: error while writing Cellular: BubbleSorter.java\Cellular.class
(Impossibile trovare il percorso specificato)
public interface Cellular extends Telephone {}
^
1 error

Io mi sono limitato a creare una Lista di elementi, strutturati nel seguente modo:

public interface Element {}
public interface Telephone extends Element{metodi da implementare}
public interface Cellular extends Telephone {}
public class ConcreteCellular implements Cellular {metodi dell'interfaccia Telephone implementati}

Ringrazio anticipatamente
Rocoat82

[MaverickNumber1]

Ciao!! Scusami ma non riesco a capire a cosa serva quella
public interface Cellular extends Telephone {}

Non ho ben chiaro l' algoritmo che utilizzi.....e l' interfaccia Cellular non ha metodi??

Ciao

[Johnny_Depp]

nel titolo (delle discussioni) bisogna specificare anche il linguaggio utilizzato.

[anx721]

javac -d nomeCartella *

per posizionare i file .class prodotti dalla compilazione in nomeCartella che deve gia esistere

[Rocoat82]

il mio compito è quello di creare una lista contenente oggetti qualsiasi senza utilizzare le classi del package java.util.
Vi allego sotto il codice che ho scritto:

Element.java
public interface Element {}

Telephone.java
public interface Telephone extends Element {

/**
* Ritorna il nome del componente.
*
* @return Il nome del componente.
*/
public String getName();

/**
* Ritorna il tipo del componente.
*
* @return Il tipo del componente.
*/
public String getType();

/**
* Ritorna il prezzo del componente.
*
* @return Il prezzo del componente.
*/
public float getPrice();

}

Cellular.java
public interface Cellular extends Telephone {}

ConcreteCellular.java
public class ConcreteCellular implements Cellular {

/**
* Ritorna il tipo del componente.
*
* @return Il tipo del componente.
*/
public String getType() {
return "CellularTelephone";
}

/**
* Costruttore per i telefoni cellulari.
*
* @param name il nome del componente.
* @param price il prezzo del componente.
*/
public ConcreteCellular(String cName, float cPrice) {
name = cName;
price = cPrice;
}

/**
* Ritorna il nome del componente.
*
* @return Il nome del componente.
*/
public String getName() {
return name;
}

/**
* Ritorna il prezzo del componente.
*
* @return Il prezzo del componente.
*/
public float getPrice() {
return price;
}


/**
* Il nome del componente.
*/
private String name = "";

/**
* Il prezzo del componente.
*/
private float price = 0;

}

List.java
public interface List {
/**
* Aggiunge un elemento in fondo alla lista.
*
* @param r Elemento da aggiungere alla lista.
*/
public void addElement(Element e);

/**
* Mette un elemento in posizione <code>i</code>.
*
* @param i Posizione in cui aggiungere l'elemento.
* @param r Elemento da aggiungere alla lista.
*/
public void setElement(int i, Element r);

/**
* Ritorna l'elemento della lista in posizione <code>i</code>.
*
* @param i Posizione dell'elemento da leggere all'interno della lista.
* @return Elemento della lista in posizione <code>i</code>.
*/
public Element getElement(int i);

/**
* Ritorna la dimensione corrente della lista.
*
* @return Dimensione corrente della lista.
*/
public int getSize();

// Manca la rimozione dell'elemnto (si può fare con SetElement())
/**
* Rimuove un elemento dalla lista.
*
* @param r Elemento da rimuovere dalla lista.
*/
public void rmElement(int i, Element r);

}

ListOfTelephone.java
public class ListOfTelephones implements List {
/**
* Aggiunge un telefono in fondo alla lista.
*
* @param r Telefono da aggiungere alla lista.
*/
public void addElement(Element r) {
elements[size++] = (Telephone)r;
}

/**
* Mette un componente in posizione <code>i</code>.
*
* @param i Posizione in cui aggiungere il telefono.
* @param r Telefono da aggiungere alla lista.
*/
public void setElement(int i, Element r) {
elements[i] = (Telephone)r;
}

/**
* Rimuove un elemento dalla lista.
*
* @param r Elemento da rimuovere dalla lista.
*/
public void rmElement(int i, Element r) {
for (; i < size-1; i++)
elements[i] = elements[i+1];
/* elements[i] = 0; ripulisco la cella precedentemente occupata. */
}

/**
* Ritorna l'elemento della lista in posizione <code>i</code>.
*
* @param i Posizione dell'elemento da leggere all'interno della lista.
* @return Elemento della lista in posizione <code>i</code>.
*/
public Element getElement(int i) {
return elements[i];
}

/**
* Ritorna la dimensione corrente della lista.
*
* @return Dimensione corrente della lista.
*/
public int getSize() {
return size;
}

/**
* Costruttore per le liste di telefoni.
*/
public ListOfTelephones(int maxSize) {
elements = new Telephone[maxSize];
}

/**
* Dimensione corrente della lista.
*/
private int size = 0;

/**
* Array che implementa la lista.
*/
private Telephone[] elements;
}

BubbleSorter.java
public class BubbleSorter {
/**
* Ordina la lista in base all'oggetto comparatore.
* Qui serve l'iteratore.
* @param La lista da ordinare.
*/
public void sort() {
for(int i = 0; i < list.getSize(); i++)
for(int j = i + 1; j < list.getSize(); j++) {
Element left = list.getElement(i);
Element right = list.getElement(j);

if(!comparator.lessThan(left, right)) swap(i, j);
}
}

/**
* Costruttore per gli ordinatori.
*
* @param l La lista da ordinare.
* @param c L'oggetto comparatore da utilizzare nell'ordinamento.
*/
public BubbleSorter(List l, Comparator c) {
list = l;
comparator = c;
}

/**
* Scambia due elementi della lista che si vuole ordinare.
*
* @param La lista su cui lavorare.
* @param i Posizione del primo elemento.
* @param j Posizione del secondo elemento.
*/
private void swap(int i, int j) {
Element t = list.getElement(i);

list.setElement(i, list.getElement(j));
list.setElement(j, t);
}

/**
* L'oggetto comparatore da utilizzare durante l'ordinamento.
*/
private Comparator comparator = null;

/**
* La lista da ordinare.
*/
private List list = null;
}

Comparator.java
public interface Comparator {
public boolean lessThan(Element e1, Element e2);
}

PriceComparator.java
public class PriceComparator implements Comparator {
public boolean lessThan(Element e1, Element e2) {
Telephone t1 = (Telephone)e1;
Telephone t2 = (Telephone)e2;

return t1.getPrice() < t2.getPrice();
}
}

Main.java
/**
* Programma che crea una lista contenente 4 telefoni cellulari, 2 telefoni fissi.
*/
public class Main {
/**
* Metodo principale del programma.
*
* @param args Parametri passati sulla linea di comando.
*/
public static void main(String[] args) {
// Creazione della lista dei telefoni.
ListOfTelephones list = new ListOfTelephones(100);

// Creazione dei poligoni e aggiunta alla lista.
list.addElement(new ConcreteCellular("C25", 20));
list.addElement(new ConcreteCellular("", 15));
list.addElement(new ConcreteCellular("V51", 45));
list.addElement(new ConcreteCellular("TRIUM", 13));
list.addElement(new ConcreteFixedTelephone("COBRA", 18));
list.addElement(new ConcreteFixedTelephone("MIRO", 40));


// Creazione di un oggetto ordinatore
BubbleSorter sorter = new BubbleSorter(list, new PriceComparator());

// Stampa dei nomi e dei prezzi degli elementi della lista.
System.out.println("List (unsorted):");

Printer printer = new Printer();
printer.print(list);

// Ordinamento della lista.
sorter.sort();

System.out.println();

// Stampa dei nomi e dei prezzi degli elementi della lista.
System.out.println("List (sorted by price):");

printer = new Printer();
printer.print(list);
}
}

P.S.
Scusate per la lunghezza

[Rocoat82]

Scusate ancora, lo sò mi dovrei frustare, ma non sò per quale motivo, ho provato ha ricompilare il codice che vi ho presentato qui sopra e adesso il compilatore non dà più problemi.... misteri della vita o cosa.

Già che ci siamo, vorrei chiedervi se qualcuno di voi può suggerirmi un aiutino per ordinare una lista non per prezzo (che è il più semplice ordinamento), ma magari per Nome alfabeticamente. Vi ricordo che non posso utilizzare il pacchetto java.util.

Non c'è un sito che contiene esempi di codice utili per java relativi a liste e ordinamenti vari.

Ringrazio

[kateetak]

Se nome è una stringa esiste il metodo compareTo che ti dice quale stringa è maggiore dell'altra... e può essere un'inizio.

Per fare l'ordinamento usa il metodo sort della classe Arrays che in poche righe fa questo:

public static void sort(Object[] a)Sorts the specified array of objects into ascending order, according to the natural ordering of its elements.

[Rocoat82]

Il problema che mi è stato specificatamente chiesto di non utilizzare il pacchetto java.util e la classe Arrays.java col metodo sort fa propio parte del pacchetto.

Un'altra cosa, non ho capito come compareTo possa restituire un numero positivo, negativo o uguale a zero a seconda della stringfa che gli faccio. Lo posso utilizzare per ordinare alfabeticamente una lista?
Non fa percaso parte anche lui di java.util

Grazie

[LeleFT]

Il metodo compareTo() è un metodo della classe String (che fa parte di java.lang).
Ti esplicito il suo prototipo (per il confronto fra stringhe) e i valori di ritorno:

public int compareTo(String anotherString)

anotherString è la stringa da confrontare

Questi i possibili valori di ritorno:

0   --> La stringa passata come argomento è uguale alla stringa
        su cui è richiamato il metodo

< 0 --> La stringa su cui è chiamato il metodo è più piccola
        lessicograficamente a quella passata come argomento

> 0 --> La stringa su cui è chiamato il metodo è più grande
        lessicograficamente a quella passata come argomento

Ti faccio degli esempi:

String s = "Ciao";

// Caso 1:
System.out.println( s.compareTo("Ciao") );

// Caso 2:
System.out.println( s.compareTo("Qualcosa") );

// Caso 3:
System.out.println( s.compareTo("Abcde") );

Nel caso 1 verrà stampato il valore 0: le due stringhe sono uguali.

Nel caso 2 verrà stampato un valore negativo: "Ciao", infatti, è lessicograficamente più piccola di "Qualcosa".

Nel caso 3 verrà stampato un valore positivo: "Ciao", infatti, è lessicograficamente più grande di "Abcde".


Ciao.

[Rocoat82]

Grazie LeleFT, adesso provo subito
Ciao