Eseguibile con un parametro?

Ho bisogno di un "Runnable che accetta un parametro" anche se so che tale runnable non esiste davvero.

Ciò può indicare un difetto fondamentale nella progettazione della mia app e / o un blocco mentale nel mio cervello stanco, quindi spero di trovare qui alcuni consigli su come realizzare qualcosa di simile al seguente, senza violare i principi fondamentali di OO:

  private Runnable mOneShotTask = new Runnable(String str) {
    public void run(String str) {
       someFunc(str);
    }
  };  

Qualche idea su come realizzare qualcosa di simile a quanto sopra?

Beh, sono passati quasi 9 anni da quando ho pubblicato questo post e, ad essere sinceri, Java ha apportato un paio di miglioramenti da allora. Lascerò la mia risposta originale qui sotto, ma non c'è bisogno che le persone facciano quello che c'è dentro. 9 anni fa, durante la revisione del codice avrei messo in dubbio il motivo per cui l'hanno fatto e forse l'hanno approvato, forse no. Con i lambda moderni disponibili, è irresponsabile avere una risposta così votata che consigli un approccio antiquato (che, in tutta onestà, era discutibile per cominciare ...) Nella moderna Java, quella revisione del codice sarebbe stata immediatamente respinta, e questo sarebbe suggerito:

void foo(final String str) {
    Thread t = new Thread(() -> someFunc(str));
    t.start();
}

Come in precedenza, dettagli come la gestione di quel thread in modo significativo vengono lasciati come esercizio al lettore. Ma per dirla senza mezzi termini, se hai paura di usare lambda, dovresti avere ancora più paura dei sistemi multi-thread.

Risposta originale, solo perché:

Puoi dichiarare una classe nel metodo

void Foo(String str) {
    class OneShotTask implements Runnable {
        String str;
        OneShotTask(String s) { str = s; }
        public void run() {
            someFunc(str);
        }
    }
    Thread t = new Thread(new OneShotTask(str));
    t.start();
}

Potresti metterlo in una funzione.

String paramStr = "a parameter";
Runnable myRunnable = createRunnable(paramStr);

private Runnable createRunnable(final String paramStr){

    Runnable aRunnable = new Runnable(){
        public void run(){
            someFunc(paramStr);
        }
    };

    return aRunnable;

}

(Quando l'ho usato, il mio parametro era un ID intero, che ho usato per creare una hashmap di ID -> myRunnables. In questo modo, posso usare l'hashmap per pubblicare / rimuovere diversi oggetti myRunnable in un gestore.)

theView.post(new Runnable() {
    String str;
    @Override                            
    public void run() {
        par.Log(str);                              
    }
    public Runnable init(String pstr) {
        this.str=pstr;
        return(this);
    }
}.init(str));

Crea la funzione init che restituisce l'oggetto stesso e inizializza i parametri con esso.

Uso la seguente classe che implementa l' interfaccia Runnable . Con questa classe puoi facilmente creare nuovi thread con argomenti

public abstract class RunnableArg implements Runnable {

    Object[] m_args;

    public RunnableArg() {
    }

    public void run(Object... args) {
        setArgs(args);
        run();
    }

    public void setArgs(Object... args) {
        m_args = args;
    }

    public int getArgCount() {
        return m_args == null ? 0 : m_args.length;
    }

    public Object[] getArgs() {
        return m_args;
    }
}

Hai due opzioni:

1. Definire una classe con nome. Passa il tuo parametro al costruttore della classe indicata.

2. Fai chiudere la tua classe anonima al tuo "parametro". Assicurati di contrassegnarlo come final.

Da Java 8, la risposta migliore è usare Consumer<T>:

https://docs.oracle.com/javase/8/docs/api/java/util/function/Consumer.html

È una delle interfacce funzionali, il che significa che puoi chiamarla come espressione lambda:

void doSomething(Consumer<String> something) {
    something.accept("hello!");
}

...

doSomething( (something) -> System.out.println(something) )

...

Vorrei prima sapere cosa stai cercando di realizzare qui per avere bisogno di un argomento da passare a nuovo Runnable () o run (). Il modo normale dovrebbe essere quello di avere un oggetto Runnable che passi i dati (str) ai suoi thread impostando le variabili membro prima di iniziare. Il metodo run () utilizza quindi questi valori delle variabili membro per eseguire someFunc ()