Ok, vi posto il codice della classe Lemma che contiene leggilemma() e get Termine().
Grazie 
codice:
import java.util.Vector;
/**
* Classe Lemma
*
* Legge il termine secondo i dati forniti dall'utente. Definisce la lista dei sinonimi e dei contrari
*/
public class Lemma
{ private Termine termine;
private Vector<String> sinonimi;
private Vector<String> contrari;
private String nome;
private String descrizione;
public Lemma(Termine ilTermine){
}
/**
* Costruttore
* @param nome
* @param descrizione
* @param sinonimi
* @param contrari
*/
public Lemma(String nome, String descrizione, Vector sinonimi, Vector contrari){
this.nome=nome;
this.descrizione=descrizione;
this.sinonimi=sinonimi;
this.contrari=contrari;
}
/**
* Legge il lemma.
* @return nome e descrizione del lemma
*/
public static Lemma leggiLemma(){
return new Lemma(getParola_Descrizione("Inserisci il nome del termine: ", "Nome"), getParola_Descrizione("Inserisci la descrizione del termine: ", "Descrizione"), leggiSinonimi("Inserisci i sinonimi", "Sinonimi"), leggiContrari("Inserisci i contrari", "Contrari"));
}
/**
* Controlla che la stringa immessa sia corretta
* @param la stringa con il testo da controllare
* @param la stringa riferimento
* @return <code>true</code> se la stringa contiene solo caratteri alfabetici
* @return <code>false</code> se la stringa non contiene solo caratteri alfabetici
*/
public static String getParola_Descrizione(String testo, String rif){
String parolaInserita="";
boolean controllo=true;
String riferimento=rif.trim();
do{
parolaInserita=Input.readString(testo).toLowerCase().trim();
controllo=Parola.controlla(parolaInserita);
if(controllo){
System.out.println(riferimento + " Corretto/a");
}else{
System.out.println(riferimento + " Errato/a");
}
}while(!controllo);
return parolaInserita;
}
/**
* Legge i sinonimi del termine
* @param testo
* @param rif
* @return i sinonimi del termine
*/
public static Vector<String> leggiSinonimi(String testo, String rif){
Vector<String> sinonimi = new Vector<String>();
String sinonimiInseriti="";
boolean controllo=true;
String riferimento=rif.trim();
char uscita=Input.readChar("Vuoi inserire i sinonimi? s/n: ");
if(uscita=='s')
do{
if(controllo){
sinonimiInseriti=Input.readString(testo).toLowerCase().trim();
controllo=Parola.controlla(sinonimiInseriti);
sinonimi.add(sinonimiInseriti);
System.out.println(riferimento + " Corretto/a");
}
else{
System.out.println(riferimento + " Errato/a");
}uscita=Input.readChar("Vuoi inserire altri sinonimi? s/n: ");
}while(!controllo || uscita!='n'); System.out.println();System.out.println("Procedi all'inserimento dei contrari");
return sinonimi;
}
/**
* Legge i contrari del termine
* @param testo
* @param rif
* @return i contrari del termine
*/
public static Vector<String> leggiContrari(String testo, String rif){
Vector<String> contrari = new Vector<String>();
String contrariInseriti="";
boolean controllo=true;
String riferimento=rif.trim();
char uscita=Input.readChar("Vuoi inserire i contrari? s/n: ");
if(uscita=='s')
do{
contrariInseriti=Input.readString(testo).toLowerCase().trim();
controllo=Parola.controlla(contrariInseriti);
if(controllo){
contrari.add(contrariInseriti);
System.out.println(riferimento + " Corretto/a");
}else{
System.out.println(riferimento + " Errato/a");
}uscita=Input.readChar("Vuoi inserire altri contrari? s/n: ");
}while(!controllo || uscita!='n');System.out.println();
return contrari;
}
/**
* restituisce il vettore sinonimi, di tipo stringa
* @return sinonimi
*/
public Vector<String> getSinonimi(){
return sinonimi;
}
/**
* restituisce il vettore contrari, di tipo stringa
* @return contrari
*/
public Vector<String> getContrari(){
return contrari;
}
/**
* restituisce il termine
* @return termine
*/
public Termine getTermine() {
// TODO Auto-generated method stub
return termine;
}
/**
* restituisce la dimensione di lemma
* @return la dimensione
*/
public static int size() {
// TODO Auto-generated method stub
return Lemma.size();
}
/**
* controlla la presenza di sinonimi nel vettore Lemma
* @return <code>true</code> se il vettore contiene sinonimi
* @return <code>false</code> se il vettore non contiene sinonimi
*/
public static boolean checkSinonimi(){
Lemma nuovolemma=Lemma.leggiLemma();
if(nuovolemma.sinonimi.isEmpty())
return false;
else
return true;
}
// inserire controlli di consistenza
public boolean isSinonimo(String parola) {
return sinonimi.contains(parola);
}
public boolean isContrario(String parola) {
return contrari.contains(parola);
}
public boolean isSinonimoEContrario(String parola) {
return sinonimi.contains(parola) && contrari.contains(parola);
}
public boolean isSinonimoOContrario(String parola) {
return sinonimi.contains(parola) || contrari.contains(parola);
}
/**
* controlla la presenza di contrari nel vettore Lemma
* @return <code>true</code> se il vettore contiene contrari
* @return <code>false</code> se il vettore non contiene contrari
*/
public static boolean checkContrari(){
Lemma nuovolemma=Lemma.leggiLemma();
if(nuovolemma.contrari.isEmpty())
return false;
else
return true;
}
public int compareTo(Lemma other) {
return termine.compareTo(other.termine);
}
}
.
Rispondi quotando
