Callable과 유사한 인터페이스가 있지만 인수가 있습니까?

Callable과 유사한 인터페이스가 있지만 인수가 있습니까?

---

Callable호출 메소드에 대한 인수를 허용 할 수 있는 인터페이스 와 유사한 Java 인터페이스가 있습니까?

이렇게 :

public interface MyCallable<V> {
  V call(String s) throws Exception;
}

내가 사용할 수있는 것이 이미 존재한다면 새로운 유형을 만드는 것을 피하고 싶습니다. 아니면 여러 클라이언트가 호출 가능한 루틴을 구현하고 연결하도록하는 더 나은 전략이 있습니까?

여기 http://www.programmingforums.org/thread27905.html 에서 복사

---

자바 8 때문에 함수와 같은 인터페이스의 전체 세트가 패키지 . 구체적으로 요청하는 것은 단순히 .java.util.functionFunction

Java 8 이전에는이를위한 범용 내장 인터페이스가 없었지만 일부 라이브러리에서이를 제공했습니다.

예를 들어 구아바 갖는다 인터페이스 방법에이 . 또한 여러 곳에서 해당 인터페이스 를 많이 사용 합니다.Function<F,T>T apply(F input)

---

처음에는 이것이 인터페이스로 수행된다고 생각했지만 추상 클래스를 사용하여 수행해야한다는 것을 알았습니다.

이 방법으로 해결했습니다.

---

편집 : 최근 나는 이것을 사용합니다 :

    public static abstract class callback1<T>{
         public abstract  void run(T value);
    }

    public static abstract class callback2<T,J>{
         public abstract  void run(T value,J value2);
    }

    public static abstract class callback3<T,J,Z>{
         public abstract  void run(T value,J value2,Z value3);
    }


    public static abstract class callbackret1<R,T>{
         public abstract  R run(T value);
    }

    public static abstract class callbackret2<R,T,J>{
         public abstract  R run(T value,J value2);
    }

    public static abstract class callbackret3<R,T,J,Z>{
         public abstract  R run(T value,J value2,Z value3);
    }

---

CallBack.java

public abstract class CallBack<TRet,TArg> {
    public abstract TRet call(TArg val);
}

방법을 정의하십시오 :

class Sample2 
{
    CallBack<Void,String> cb;
    void callcb(CallBack<Void,String> CB)
    {
     cb=CB; //save the callback
     cb.call("yes!"); // call the callback
    }
}

사용 방법 :

sample2.callcb(new CallBack<Void,String>(){
        @Override
        public Void call(String val) {
            // TODO Auto-generated method stub
            return null;
        }
    });

두 개의 인수 샘플 : CallBack2.java

public abstract class CallBack2<TRet,TArg1,TArg2> {
    public abstract TRet call(TArg1 val1,TArg2 val2);
}

Void 반환 유형을 사용할 때는 return null을 사용해야합니다. 일반적으로 콜백이 값을 반환하지 않기 때문에 수정해야 할 변형이 있습니다.

반환 유형으로 무효 : SimpleCallBack.java

public abstract class SimpleCallBack<TArg> {
    public abstract void call(TArg val);
}

반환 유형 2 인수로 무효 : SimpleCallBack2.java

public abstract class SimpleCallBack<TArg1,TArg2> {
    public abstract void call(TArg1 val1,TArg2 val2);
}

인터페이스는 이것에 유용하지 않습니다.

interfaces allow multiple types match same type. by having a shared predefined set of functions.

abstract classes allow empty functions inside them to be completed later. at extending or instantiation.

---

I've had the same requirement recently. As others have explained many libs do provide 'functional' methods, but these do not throw exceptions.

An example of how some projects have provided a solution is the RxJava library where they use interfaces such as ActionX where 'X' is 0 ... N, the number of arguments to the call method. They even have a varargs interface, ActionN.

My current approach is to use a simple generic interface:

public interface Invoke<T,V>  {     
    public T call(V data) throws Exception;     
//  public T call(V... data) throws Exception;    
}

The second method is preferable in my case but it exhibits that dreaded "Type safety: Potential heap pollution via varargs parameter data" in my IDE, and that is a whole other issue.

Another approach I am looking at is to use existing interfaces such as java.util.concurrent.Callable that do not throw Exception, and in my implementation wrap exceptions in unchecked exceptions.

---

The answer is ambiguous. Strictly speaking, that is, "for the same purpose of the Callable interface", there is not.

There are similar classes, and depending on what you want, they may or may not be convenient. One of them is the SwingWorker. However, as the name implies, it was designed for use within the Swing framework. It could be used for other purposes, but this would be a poor design choice.

My best advice is to use one provided by an extension library (Jakarta-Commons, Guava, and so on), depending on what libraries you already use in your system.

---

Since Java 1.8 there is a Supplier<T> interface. It has a get() method instead of call() and it does not declare any Exception thrown.

---

Normally arguments are not required as the method can have any number of arguments in its constructor.

final int i = 5;
final String word = "hello";

Future<String> future = service.submit(new Callable<String>() {
    public String call() {
        return word + i;
    }
});

In this example i and word have been used, but you can "pass" any number of parameters.

---

I just had the same issue. you can wrap any method to return a callable, and execute it's returned value. i.e.

 main {    
    Callable<Integer> integerCallable = getIntegerCallable(400);
    Future<Integer> future = executor.submit(integerCallable);
}

private Callable<Integer> getIntegerCallable(int n) {
    return () -> {
            try {
                TimeUnit.SECONDS.sleep(n);
                return 123;
            } catch (InterruptedException e) {
                throw new IllegalStateException("task interrupted", e);
            }
        };
}

---

Define an interface like so:

interface MyFunction<I, O> {
    O call(I input);
}

Define a method:

void getOrderData(final Function<JSONArray, Void> func){
    ...
    JSONArray json = getJSONArray();
    if(func!=null) func.call(json);           
}

Usage example:

//call getOrderData somewhere in your code
getOrderData(new Function<JSONArray, Void>() {
        @Override
        public Void call(JSONArray input) {
            parseJSON(input);                
            return null;
        }
});

ReferenceURL : https://stackoverflow.com/questions/11083868/is-there-an-interface-similar-to-callable-but-with-arguments