Ejecutable con un parámetro?

Necesito un "Ejecutable que acepte un parámetro" aunque sé que dicho ejecutable realmente no existe.

Esto puede indicar un defecto fundamental en el diseño de mi aplicación y / o un bloqueo mental en mi cerebro cansado, por lo que espero encontrar aquí algunos consejos sobre cómo lograr algo como lo siguiente, sin violar los principios fundamentales de OO:

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

¿Alguna idea de cómo lograr algo como lo anterior?

Bueno, han pasado casi 9 años desde que publiqué esto originalmente y, para ser honesto, Java ha realizado un par de mejoras desde entonces. Dejaré mi respuesta original a continuación, pero no hay necesidad de que la gente haga lo que contiene. Hace 9 años, durante la revisión del código, habría cuestionado por qué lo hicieron y tal vez lo aprobó, tal vez no. Con las lambdas modernas disponibles, es irresponsable tener una respuesta tan votada que recomiende un enfoque anticuado (que, para ser justos, era dudoso al principio ...) En Java moderno, esa revisión de código sería rechazada de inmediato, y esto sería sugirió:

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

Como antes, detalles como manejar ese hilo de manera significativa se dejan como ejercicio para el lector. Pero para decirlo sin rodeos, si tiene miedo de usar lambdas, debería tener aún más miedo de los sistemas de subprocesos múltiples.

Respuesta original, solo porque:

Puedes declarar una clase directamente en el método

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();
}

Podrías ponerlo en una función.

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;

}

(Cuando usé esto, mi parámetro era un ID entero, que usé para hacer un hashmap de ID -> myRunnables. De esa manera, puedo usar el hashmap para publicar / eliminar diferentes objetos myRunnable en un controlador).

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));

Cree una función de inicio que devuelva el objeto e inicialice los parámetros con él.

Yo uso la siguiente clase que implementa la interfaz Runnable . Con esta clase puedes crear fácilmente nuevos hilos con argumentos

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;
    }
}

Tienes dos opciones:

1. Definir una clase con nombre. Pase su parámetro al constructor de la clase nombrada.

2. Haga que su clase anónima se cierre sobre su "parámetro". Asegúrese de marcarlo como final.

Desde Java 8, la mejor respuesta es usar Consumer<T>:

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

Es una de las interfaces funcionales, lo que significa que puede llamarla como una expresión lambda:

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

...

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

...

Primero me gustaría saber qué está tratando de lograr aquí para necesitar un argumento que se pase al nuevo Runnable () o al run (). La forma habitual debería ser tener un objeto Runnable que pase datos (str) a sus subprocesos estableciendo variables miembro antes de comenzar. El método run () luego usa estos valores de variables miembro para ejecutar someFunc ()