Non capisco a cosa ti serve dichiararla static...
Io ho capito che intendi fare una cosa del genere:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/** <b>IMPLEMENTARE I METODI SECONDO LE SPECIFICHE DATE NEI JAVADOC.</b>
* <br>
* Un oggetto {@code CmdManager} è un manager di un insieme di comandi (di tipo
* {@link hw1.cmd.Command}) che permette di ottenere la documentazione di ognuno e di
* eseguire stringhe di comando relative ai comandi gestiti. Un manager garantisce
* sempre che non ci siano due comandi gestiti che hanno un nome uguale. */
public class CmdManager {
List<Command> cmds;
/** Crea un manager di comandi con i comandi specificati. Il manager creato ha
* sempre un comando di help per ottenere informazioni sui comandi gestiti. Tale
* comando è così specificato:
* <pre>
* Nomi: "help","h"
* Doc: "h cmd --> documentazione del comando cmd"
* Esempi:
* "h" --> "h,help\npi,Pi,PI\n+,sum\n^,**,pow\nfactorize\n"
* "help" --> "h,help\npi,Pi,PI\n+,sum\n^,**,pow\nfactorize\n"
* "h sum" --> "+ x y ... z --> somma x+y+...+z"
* "help +" --> "+ x y ... z --> somma x+y+...+z"
* "h nocmd" --> IllegalArgumentException
* </pre>
*
* @param cc i comandi gestiti dal manager
* @throws NullPointerException se uno dei comandi è null
* @throws IllegalArgumentException se due comandi hanno un nome in comune
* (compreso il comando di help). */
public CmdManager(Command... cc) {
cmds = new ArrayList<>();
cmds.addAll(Arrays.asList(cc));
}
/** Aggiunge un comando al manager.
*
* @param c il comando da aggiungere
* @throws NullPointerException se il comando è null
* @throws IllegalArgumentException se il comando ha un nome che è di uno dei
* comandi già presenti (compreso il comando di help). */
public void add(Command c) {
throw new UnsupportedOperationException();
}
/** Ritorna una stringa con tante linee quanti sono i comandi del manager e in
* ogni linea elenca i nomi di uno dei comandi. Esempio
* <pre>
* "h,help\npi,Pi,PI\n+,sum\n^,**,pow\nfactorize\n"
* </pre>
* L'ordine è arbitrario.
*
* @return una stringa con i nomi dei comandi */
public String commands() {
StringBuilder builder = new StringBuilder();
cmds.stream().forEach((c) -> {
c.getNames().stream().forEach((s) -> {
builder.append(s);
builder.append(" ");
});
builder.append("\n");
});
return builder.toString();
}
/** Esegue la stringa di comando e ritorna il risultato. Esempi
* <pre>
* "h" --> "h,help\npi,Pi,PI\n+,sum\n^,**,pow\nfactorize\n"
* null --> NullPointerException
* "hh" --> IllegalArgumentException
* "sum 1 2" --> "3"
* "sum 1 2 x" --> IllegalArgumentException
* </pre>
*
* @param cmd un comando da eseguire
* @return il risultato dell'esecuzione della stringa di comando
* @throws NullPointerException se la stringa di comando è null
* @throws IllegalArgumentException se non c'è un comando con il nome dato o se
* la stringa di comando non è valida, cioè il
* metodo execute del relativo comando lancia l'eccezione */
public String execute(String cmd) {
throw new UnsupportedOperationException();
}
}
import java.util.Arrays;
import java.util.List;
/** <b>IMPLEMENTARE I METODI SECONDO LE SPECIFICHE DATE NEI JAVADOC.</b>
* <br>
* Una classe con factory methods per creare alcuni comandi. Ogni factory method
* ritorna uno specifico comando di tipo {@link hw1.cmd.Command}. Sarebbe bene che
* ognuno di questi ritorni ad ogni invocazione sempre lo stesso oggetto. */
public class CmdFactory {
/** Ritorna un comando per ottenere il valore di pigreco. Il metodo
* {@link hw1.cmd.Command#execute(String)} del comando ritornato lancia
* {@link java.lang.IllegalArgumentException} se la stringa di comando non è
* esattamente uno dei nomi del comando.
* <pre>
* Nomi: "pi", "Pi", "PI"
* Doc: "pi --> valore di Pi greco"
* Esempi:
* execute("pi") ritorna "3.141592653589793"
* execute("pi g") lancia IllegalArgumentException
* </pre>
* @return un comando per ottenere il valore di pigreco */
public static Command getPI() {
Command p = new Command() {
@Override
public List<String> getNames() {
List<String> pLista = Arrays.asList("pi","Pi","PI");
return pLista;
}
@Override
public String execute(String cmd) {
if (cmd.length()>3){throw new IllegalArgumentException();}
if (cmd.length()>2 && !cmd.substring(2, 3).equals(" ")){throw new IllegalArgumentException();}
return "3.141592653589793";
}
@Override
public String doc() {
return "pi --> valore di Pi greco";
}
};
return p;
}
/** Ritorna un comando per sommare una serie di numeri. Il metodo
* {@link hw1.cmd.Command#execute(String)} del comando ritornato lancia
* {@link java.lang.IllegalArgumentException} se nella stringa di comando ciò
* che segue il nome del comando non è interpretabile come una sequenza di
* numeri, interi o con virgola, separati da whitespaces.
* <pre>
* Nomi: "+", "sum"
* Doc: "+ x y ... z --> somma x+y+...+z"
* Esempi:
* execute("+ 1 2.5 -3") ritorna "0.5"
* execute("sum 1 2.5 -3") ritorna "0.5"
* execute("+1 2.5 -3") ritorna "0.5"
* execute("+") ritorna "0.0"
* execute("+ 1 2 3 4") ritorna "10.0"
* execute("+ 1 2 a") lancia IllegalArgumentException
* </pre>
* @return un comando per sommare una serie di numeri */
public static Command getSum() {
throw new UnsupportedOperationException();
}
/** Ritorna un comando per l'elevazione a potenza. Il metodo
* {@link hw1.cmd.Command#execute(String)} del comando ritornato lancia
* {@link java.lang.IllegalArgumentException} se nella stringa di comando ciò
* che segue il nome del comando non è interpretabile come due numeri,
* interi o con virgola, separati da whitespaces.
* <pre>
* Nomi: "^", "**", "pow"
* Doc: "pow x y --> x elevato a y"
* Esempi:
* execute("pow2 5") ritorna "32.0"
* execute("^ 1.2 -0.6") ritorna "0.8963781307771418"
* execute("** -1 0.5") ritorna "NaN"
* execute("pow 2") lancia IllegalArgumentException
* </pre>
* @return un comando per l'elevazione a potenza */
public static Command getPow() {
throw new UnsupportedOperationException();
}
/** Ritorna un comando per fattorizzare un intero. Il metodo
* {@link hw1.cmd.Command#execute(String)} del comando ritornato lancia
* {@link java.lang.IllegalArgumentException} se nella stringa di comando ciò
* che segue il nome del comando non è interpretabile come un numero intero
* maggiore od uguale a 2. Nell'output i fattori sono elencati in ordine crescente.
* <pre>
* Nomi: "factorize"
* Doc: "factorize n --> fattorizzazione di n"
* Esempi:
* execute("factorize 1504") ritorna "2(5) 47"
* execute("factorize 123400272626252672") ritorna "2(7) 29(2) 1097 1044969287"
* execute("factorize1000") ritorna "2(3) 5(3)"
* execute("factorize 15 s") lancia IllegalArgumentException
* </pre>
* @return un comando per fattorizzare un intero */
public static Command getFactorize() {
throw new UnsupportedOperationException();
}
/** @return un array con tutti i comandi ritornati dai metodi di questa classe */
public static Command[] getAll() {
throw new UnsupportedOperationException();
}
}
public class Loader {
public static void main(String[] args){
CmdManager cmdManager = new CmdManager(CmdFactory.getPI(), CmdFactory.getPI());
System.out.println(cmdManager.commands());
System.out.println("*****");
System.out.println(new CmdManager().commands());
}
}