Programing

파라미터로서의 Java 패스 메소드

lottogame 2020. 4. 6. 07:56
반응형

파라미터로서의 Java 패스 메소드

참조로 메서드를 전달하는 방법을 찾고 있습니다. Java가 메소드를 매개 변수로 전달하지 않는다는 것을 이해하지만 대안을 원합니다.

인터페이스가 메소드를 매개 변수로 전달하는 대신 인터페이스가 있다고 들었지만 인터페이스가 참조로 메소드로 작동하는 방법을 이해하지 못합니다. 내가 올바르게 이해하면 인터페이스는 정의되지 않은 추상 메소드 집합입니다. 여러 가지 다른 메소드가 동일한 매개 변수를 사용하여 동일한 메소드를 호출 할 수 있기 때문에 매번 정의 해야하는 인터페이스를 보내고 싶지 않습니다.

내가 성취하고 싶은 것은 이와 비슷한 것입니다.

public void setAllComponents(Component[] myComponentArray, Method myMethod) {
    for (Component leaf : myComponentArray) {
        if (leaf instanceof Container) { //recursive call if Container
            Container node = (Container) leaf;
            setAllComponents(node.getComponents(), myMethod);
        } //end if node
        myMethod(leaf);
    } //end looping through components
}

다음과 같이 호출되었습니다.

setAllComponents(this.getComponents(), changeColor());
setAllComponents(this.getComponents(), changeSize());

편집 : Java 8부터 다른 답변 이 지적한 것처럼 람다 식은 훌륭한 솔루션 입니다. 아래 답변은 Java 7 및 이전 버전 용으로 작성된 것입니다 ...

명령 패턴을 살펴보십시오 .

// NOTE: code not tested, but I believe this is valid java...
public class CommandExample 
{
    public interface Command 
    {
        public void execute(Object data);
    }

    public class PrintCommand implements Command 
    {
        public void execute(Object data) 
        {
            System.out.println(data.toString());
        }    
    }

    public static void callCommand(Command command, Object data) 
    {
        command.execute(data);
    }

    public static void main(String... args) 
    {
        callCommand(new PrintCommand(), "hello world");
    }
}

편집 : 로 피트 Kirkham가 지적 하는 사용하여이 일을 다른 방법이 방문자가 . 방문자 접근 방식은 조금 더 복잡합니다. 노드는 모두 acceptVisitor()방법을 사용하여 방문자를 인식 해야하지만 더 복잡한 객체 그래프를 통과 해야하는 경우 검사 할 가치가 있습니다.

Java 8에서는 Lambda Expressions 및 Method References를 사용하여보다 쉽게 ​​메서드를 전달할 수 있습니다 . 첫째, 몇 가지 배경 : 기능적 인터페이스는 하나의 추상 메소드 만있는 인터페이스이지만, 여러 개의 기본 메소드 (Java 8의 새로운 기능)와 정적 메소드를 포함 할 수 있습니다 . 람다 식을 사용하지 않으면 필요한 모든 구문없이 람다 식을 사용하여 추상 메서드를 빠르게 구현할 수 있습니다.

람다식이 없으면 :

obj.aMethod(new AFunctionalInterface() {
    @Override
    public boolean anotherMethod(int i)
    {
        return i == 982
    }
});

람다 식의 경우 :

obj.aMethod(i -> i == 982);

다음은 Lambda Expressions에 대한 Java 자습서에서 발췌 한 내용입니다 .

람다 식의 구문

람다 식은 다음과 같이 구성됩니다.

  • 괄호로 묶인 쉼표로 구분 된 공식 매개 변수 목록입니다. CheckPerson.test 메소드에는 Person 클래스의 인스턴스를 나타내는 하나의 매개 변수 p가 있습니다.

    참고 : 람다 식에서 매개 변수의 데이터 형식을 생략 할 수 있습니다. 또한 매개 변수가 하나만 있으면 괄호를 생략 할 수 있습니다. 예를 들어 다음 람다 식도 유효합니다.

    p -> p.getGender() == Person.Sex.MALE 
    && p.getAge() >= 18
    && p.getAge() <= 25

  • 화살표 토큰 ->

  • 본문은 단일 표현식 또는 명령문 블록으로 구성됩니다. 이 예제는 다음 표현식을 사용합니다.

    p.getGender() == Person.Sex.MALE 
    && p.getAge() >= 18
    && p.getAge() <= 25

    단일 표현식을 지정하면 Java 런타임이 표현식을 평가 한 후 해당 값을 리턴합니다. 또는 return 문을 사용할 수 있습니다.

    p -> {
    return p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25;
}

    리턴 문은 표현식이 아닙니다. 람다 식에서는 중괄호 ({})로 문을 묶어야합니다. 그러나 void 메소드 호출을 중괄호로 묶을 필요는 없습니다. 예를 들어 다음은 유효한 람다 식입니다.

    email -> System.out.println(email)

람다 식은 메서드 선언과 매우 비슷합니다. 람다 식을 이름없는 메서드 인 익명 메서드로 간주 할 수 있습니다.

람다 식을 사용하여 "메소드를 전달하는"방법은 다음과 같습니다.

interface I {
    public void myMethod(Component component);
}

class A {
    public void changeColor(Component component) {
        // code here
    }

    public void changeSize(Component component) {
        // code here
    }
}

class B {
    public void setAllComponents(Component[] myComponentArray, I myMethodsInterface) {
        for(Component leaf : myComponentArray) {
            if(leaf instanceof Container) { // recursive call if Container
                Container node = (Container)leaf;
                setAllComponents(node.getComponents(), myMethodInterface);
            } // end if node
            myMethodsInterface.myMethod(leaf);
        } // end looping through components
    }
}

class C {
    A a = new A();
    B b = new B();

    public C() {
        b.setAllComponents(this.getComponents(), component -> a.changeColor(component));
        b.setAllComponents(this.getComponents(), component -> a.changeSize(component));
    }
}

다음 C과 같이 메소드 참조를 사용하면 클래스 를 조금 더 단축 할 수 있습니다.

class C {
    A a = new A();
    B b = new B();

    public C() {
        b.setAllComponents(this.getComponents(), a::changeColor);
        b.setAllComponents(this.getComponents(), a::changeSize);
    }
}

java.lang.reflect.Method개체를 사용하여 전화invoke

먼저 매개 변수로 전달할 메소드로 인터페이스를 정의하십시오.

public interface Callable {
  public void call(int param);
}

메소드를 사용하여 클래스 구현

class Test implements Callable {
  public void call(int param) {
    System.out.println( param );
  }
}

// 그렇게 불러

Callable cmd = new Test();

이를 통해 cmd를 매개 변수로 전달하고 인터페이스에 정의 된 메소드 호출을 호출 할 수 있습니다.

public invoke( Callable callable ) {
  callable.call( 5 );
}

마지막으로 확인했을 때 Java는 원하는 것을 기본적으로 수행 할 수 없습니다. 이러한 한계를 극복하려면 '해결 방법'을 사용해야합니다. 내가 아는 한, 인터페이스는 대안이지만 좋은 대안은 아닙니다. 아마도 당신에게 말한 사람은 다음과 같은 의미 일 것입니다.

public interface ComponentMethod {
  public abstract void PerfromMethod(Container c);
}

public class ChangeColor implements ComponentMethod {
  @Override
  public void PerfromMethod(Container c) {
    // do color change stuff
  }
}

public class ChangeSize implements ComponentMethod {
  @Override
  public void PerfromMethod(Container c) {
    // do color change stuff
  }
}

public void setAllComponents(Component[] myComponentArray, ComponentMethod myMethod) {
    for (Component leaf : myComponentArray) {
        if (leaf instanceof Container) { //recursive call if Container
            Container node = (Container) leaf;
            setAllComponents(node.getComponents(), myMethod);
        } //end if node
        myMethod.PerfromMethod(leaf);
    } //end looping through components
}

그런 다음 호출 할 내용 :

setAllComponents(this.getComponents(), new ChangeColor());
setAllComponents(this.getComponents(), new ChangeSize());

이것이 Java 7 이하에서는 아직 유효하지 않지만, 나는 미래를 바라 봐야하고 최소한 Java 8과 같은 새로운 버전에서 오는 변경 사항 을 인식해야한다고 생각합니다 .

즉,이 새로운 버전은 Java에 대한 람다 및 메소드 참조를 제공합니다 ( 새로운 API 와 함께이 문제에 대한 또 다른 유효한 솔루션입니다. 여전히 인터페이스가 필요하지만 새 오브젝트가 작성되지 않고 추가 클래스 파일이 다른 이유로 인해 출력 디렉토리를 오염시킬 필요가 없습니다. JVM에 의한 처리.

두 특징 (람다 및 메소드 참조)에는 서명이 사용되는 단일 메소드로 사용 가능한 인터페이스가 필요합니다.

public interface NewVersionTest{
    String returnAString(Object oIn, String str);
}

방법의 이름은 여기서부터 중요하지 않습니다. 람다가 허용되는 경우 메소드 참조도 가능합니다. 예를 들어 여기에서 서명을 사용하려면

public static void printOutput(NewVersionTest t, Object o, String s){
    System.out.println(t.returnAString(o, s));
}

이것은 람다 1 이 전달 될 때까지 간단한 인터페이스 호출입니다 .

public static void main(String[] args){
    printOutput( (Object oIn, String sIn) -> {
        System.out.println("Lambda reached!");
        return "lambda return";
    }
    );
}

출력됩니다 :

Lambda reached!
lambda return

메소드 참조는 유사합니다. 주어진:

public class HelperClass{
    public static String testOtherSig(Object o, String s){
        return "real static method";
    }
}

그리고 주요 :

public static void main(String[] args){
    printOutput(HelperClass::testOtherSig);
}

출력은입니다 real static method. 메소드 참조는 정적, 인스턴스, 임의의 인스턴스가있는 비 정적 및 생성자 일 수 있습니다. 생성자에는 비슷한 ClassName::new것이 사용됩니다.

1 부작용이 있기 때문에 일부에서는 람다로 간주되지 않습니다. 그러나보다 직관적 인 방식으로 사용하는 방법을 보여줍니다.

Java 8부터 메소드 가있는 Function<T, R>인터페이스 ( docs )가 있습니다.

R apply(T t);

이를 사용하여 함수를 다른 함수에 매개 변수로 전달할 수 있습니다. T는 함수의 입력 유형이고 R은 반환 유형입니다.

귀하의 예에서 Componenttype을 입력으로 사용하고 아무것도 반환하지 않는 함수를 전달해야합니다 Void. 이 경우 Function<T, R>Void 유형의 자동 박스가 없으므로 최선의 선택이 아닙니다. 찾고있는 인터페이스를 메소드와 함께 Consumer<T>( docs ) 라고합니다.

void accept(T t);

다음과 같이 보일 것입니다 :

public void setAllComponents(Component[] myComponentArray, Consumer<Component> myMethod) {
    for (Component leaf : myComponentArray) {
        if (leaf instanceof Container) { 
            Container node = (Container) leaf;
            setAllComponents(node.getComponents(), myMethod);
        } 
        myMethod.accept(leaf);
    } 
}

그리고 메소드 참조를 사용하여 호출합니다.

setAllComponents(this.getComponents(), this::changeColor);
setAllComponents(this.getComponents(), this::changeSize);

동일한 클래스에서 changeColor () 및 changeSize () 메소드를 정의했다고 가정하십시오.

메소드가 둘 이상의 매개 변수를 승인하는 경우 BiFunction<T, U, R>입력 매개 변수의 유형 인 T와 U를 사용 하고 리턴 유형 인 R을 사용할 수 있습니다 . 또한 BiConsumer<T, U>두 개의 인수, 반환 유형 없음이 있습니다. 불행히도 3 개 이상의 입력 매개 변수의 경우, 직접 인터페이스를 작성해야합니다. 예를 들면 다음과 같습니다.

public interface Function4<A, B, C, D, R> {

    R apply(A a, B b, C c, D d);
}

무언가를 반환하기 위해 이러한 메소드가 필요하지 않으면 Runnable 객체를 반환하도록 할 수 있습니다.

private Runnable methodName (final int arg){
    return new Runnable(){
       public void run(){
          // do stuff with arg
       }
    }
}

그런 다음 다음과 같이 사용하십시오.

private void otherMethodName (Runnable arg){
    arg.run();
}

관찰자 패턴을 사용하십시오 (때로는 리스너 패턴이라고도 함).

interface ComponentDelegate {
    void doSomething(Component component);
}

public void setAllComponents(Component[] myComponentArray, ComponentDelegate delegate) {
    // ...
    delegate.doSomething(leaf);
}

setAllComponents(this.getComponents(), new ComponentDelegate() {
                                            void doSomething(Component component) {
                                                changeColor(component); // or do directly what you want
                                            }
                                       });

new ComponentDelegate()... 인터페이스를 구현하는 익명 형식을 선언합니다.

Java에는 이름을 전달하고 호출하는 메커니즘이 있습니다. 반사 메커니즘의 일부입니다. 함수는 Method 클래스의 추가 매개 변수를 가져야합니다.

public void YouMethod(..... Method methodToCall, Object objWithAllMethodsToBeCalled)
{
...
Object retobj = methodToCall.invoke(objWithAllMethodsToBeCalled, arglist);
...
}

java.util.function.Function간단한 메소드를 매개 변수 함수로 사용하는 방법에 대한 명확한 예를 찾지 못했습니다 . 다음은 간단한 예입니다.

import java.util.function.Function;

public class Foo {

  private Foo(String parameter) {
    System.out.println("I'm a Foo " + parameter);
  }

  public static Foo method(final String parameter) {
    return new Foo(parameter);
  }

  private static Function parametrisedMethod(Function<String, Foo> function) {
    return function;
  }

  public static void main(String[] args) {
    parametrisedMethod(Foo::method).apply("from a method");
  }
}

기본적으로 Foo기본 생성자 가있는 객체가 있습니다. method로부터 매개 변수로 호출됩니다 parametrisedMethod타입이다 Function<String, Foo>.

  • Function<String, Foo>함수가 String매개 변수로 매개 변수를 사용하고 a 를 반환 한다는 것을 의미합니다 Foo.
  • Foo::Method같은 람다 대응x -> Foo.method(x);
  • parametrisedMethod(Foo::method) 로 볼 수 있었다 x -> parametrisedMethod(Foo.method(x))
  • 는 .apply("from a method")할 기본적으로parametrisedMethod(Foo.method("from a method"))

그러면 출력으로 돌아갑니다.

>> I'm a Foo from a method

예제는 그대로 실행되어야하며, 다른 클래스와 인터페이스를 사용하여 위의 답변에서 더 복잡한 작업을 시도 할 수 있습니다.

기본 예는 다음과 같습니다.

public class TestMethodPassing
{
    private static void println()
    {
        System.out.println("Do println");
    }

    private static void print()
    {
        System.out.print("Do print");
    }

    private static void performTask(BasicFunctionalInterface functionalInterface)
    {
        functionalInterface.performTask();
    }

    @FunctionalInterface
    interface BasicFunctionalInterface
    {
        void performTask();
    }

    public static void main(String[] arguments)
    {
        performTask(TestMethodPassing::println);
        performTask(TestMethodPassing::print);
    }
}

산출:

Do println
Do print

나는 자바 전문가는 아니지만 다음과 같이 문제를 해결합니다.

@FunctionalInterface
public interface AutoCompleteCallable<T> {
  String call(T model) throws Exception;
}

내 특수 인터페이스에서 매개 변수를 정의합니다

public <T> void initialize(List<T> entries, AutoCompleteCallable getSearchText) {.......
//call here
String value = getSearchText.call(item);
...
}

마지막으로, initialize 메소드 를 호출하는 동안 getSearchText 메소드를 구현 합니다.

initialize(getMessageContactModelList(), new AutoCompleteCallable() {
          @Override
          public String call(Object model) throws Exception {
            return "custom string" + ((xxxModel)model.getTitle());
          }
        })

람다는 이것이 의미가 있다고 생각하지 않습니다 ... Java는 함수형 프로그래밍 언어가 아니며 절대 그렇게 될 수 없으므로 메소드를 매개 변수로 전달하지 않습니다. 즉, Java는 객체 지향적이며,이를 염두에두고 원하는대로 무엇이든 할 수 있습니다. 첫 번째 아이디어는 단순히 "메소드를 포함하는 객체"를 매개 변수로 전달하는 것입니다. 따라서 메소드를 '전달'해야 할 때마다 해당 클래스의 인스턴스를 전달하십시오. 메소드를 정의 할 때 메소드를 포함하는 클래스의 인스턴스를 매개 변수로 추가해야합니다. 이것은 작동해야하지만 클래스 코드에 액세스 할 수 없다면 메소드를 재정의 할 수 없기 때문에 원하는 것은 아닙니다. 많은 경우에는 불가능합니다. 게다가, 누군가가 메소드를 매개 변수로 전달 해야하는 경우 메소드의 동작이 동적이어야하기 때문이라고 생각합니다. 내 말은 클래스를 사용하는 프로그래머는 메소드가 반환해야하지만 유형은 반환하지 않아야 할 것을 선택할 수 있어야한다는 것입니다. 운 좋게도 Java에는 아름답고 간단한 솔루션 인 추상 클래스가 있습니다. 요약하자면 추상 클래스는 메소드의 "서명"을 알고 있지만 동작은 알지 못하는 경우에 사용됩니다. 메소드의 이름과 유형을 추상 클래스로 랩핑하고 해당 클래스의 인스턴스를 다음과 같이 전달할 수 있습니다. 메서드에 대한 매개 변수 ... 잠깐만 ... 이전과 같은 것이 아니고 추상 클래스의 인스턴스를 가질 수 있습니까? 아니오, 아니요 ...뿐만 아니라 예 ... 추상 메서드를 만들 때 또한 추상 클래스를 확장하는 클래스에서 java를 정의하여 재정의해야합니다. 동적 바인딩 Java는 정적, 개인 및 기타 사항을 선언하지 않는 한 항상 재정의 된 버전을 사용합니다. 다음은 예입니다 ... 숫자 배열에 함수를 적용하려고한다고 가정합니다. 따라서 제곱을 수행하려면 입력 [1,2,3,4, ...]-> [ 1,4,9,16, ...] (haskell과 같은 기능적 프로그래밍 언어에서는 'map'과 같은 일부 도구 덕분에 쉬운 일입니다 ...) 숫자를 제곱하는 데 특별한 것은 없으므로 원하는 기능을 적용 할 수 있습니다. 따라서 코드는 [args], f-> [f (args)]와 같아야합니다. java =>로 돌아 가기 함수는 단지 메소드이므로 다른 함수를 배열에 적용하는 함수입니다. 간단히 말해서 메서드를 매개 변수로 전달해야합니다. 여기 내가 어떻게 할 것입니다 ==> 개인 및 다른 것들)은 재정의 된 버전을 사용합니다. 다음은 예입니다 ... 숫자 배열에 함수를 적용하려고한다고 가정합니다. 따라서 제곱을 수행하려면 입력 [1,2,3,4, ...]-> [ 1,4,9,16, ...] (haskell과 같은 기능적 프로그래밍 언어에서는 'map'과 같은 일부 도구 덕분에 쉬운 일입니다 ...) 숫자를 제곱하는 데 특별한 것은 없으므로 원하는 기능을 적용 할 수 있습니다. 따라서 코드는 [args], f-> [f (args)]와 같아야합니다. java =>로 돌아 가기 함수는 단지 메소드이므로 다른 함수를 배열에 적용하는 함수입니다. 간단히 말해서 메서드를 매개 변수로 전달해야합니다. 여기 내가 어떻게 할 것입니다 ==> 개인 및 다른 것들)은 재정의 된 버전을 사용합니다. 다음은 예입니다 ... 숫자 배열에 함수를 적용하려고한다고 가정합니다. 따라서 제곱을 수행하려면 입력 [1,2,3,4, ...]-> [ 1,4,9,16, ...] (haskell과 같은 기능적 프로그래밍 언어에서는 'map'과 같은 일부 도구 덕분에 쉬운 일입니다 ...) 숫자를 제곱하는 데 특별한 것은 없으므로 원하는 기능을 적용 할 수 있습니다. 따라서 코드는 [args], f-> [f (args)]와 같아야합니다. java =>로 돌아 가기 함수는 단지 메소드이므로 다른 함수를 배열에 적용하는 함수입니다. 간단히 말해서 메서드를 매개 변수로 전달해야합니다. 여기 내가 어떻게 할 것입니다 ==> 숫자 배열에 함수를 적용한다고 가정합니다. 따라서 제곱을 수행하려면 입력 [1,2,3,4, ...]-> [1,4,9,16 , ...] (haskell과 같은 기능적 프로그래밍 언어에서는 'map'과 같은 일부 도구 덕분에 쉬운 일입니다 ...). 숫자를 제곱하는 데 특별한 것은 없으므로 원하는 기능을 적용 할 수 있습니다. 따라서 코드는 [args], f-> [f (args)]와 같아야합니다. java =>로 돌아 가기 함수는 단지 메소드이므로 다른 함수를 배열에 적용하는 함수입니다. 간단히 말해서 메서드를 매개 변수로 전달해야합니다. 여기 내가 어떻게 할 것입니다 ==> 숫자 배열에 함수를 적용한다고 가정합니다. 따라서 제곱을 수행하려면 입력 [1,2,3,4, ...]-> [1,4,9,16 , ...] (haskell과 같은 기능적 프로그래밍 언어에서는 'map'과 같은 일부 도구 덕분에 쉬운 일입니다 ...). 숫자를 제곱하는 데 특별한 것은 없으므로 원하는 기능을 적용 할 수 있습니다. 따라서 코드는 [args], f-> [f (args)]와 같아야합니다. java =>로 돌아 가기 함수는 단지 메소드이므로 다른 함수를 배열에 적용하는 함수입니다. 간단히 말해서 메서드를 매개 변수로 전달해야합니다. 여기 내가 어떻게 할 것입니다 ==> ). 숫자를 제곱하는 데 특별한 것은 없으므로 원하는 기능을 적용 할 수 있습니다. 따라서 코드는 [args], f-> [f (args)]와 같아야합니다. java =>로 돌아 가기 함수는 단지 메소드이므로 다른 함수를 배열에 적용하는 함수입니다. 간단히 말해서 메서드를 매개 변수로 전달해야합니다. 여기 내가 어떻게 할 것입니다 ==> ). 숫자를 제곱하는 데 특별한 것은 없으므로 원하는 기능을 적용 할 수 있습니다. 따라서 코드는 [args], f-> [f (args)]와 같아야합니다. java =>로 돌아 가기 함수는 단지 메소드이므로 다른 함수를 배열에 적용하는 함수입니다. 간단히 말해서 메서드를 매개 변수로 전달해야합니다. 여기 내가 어떻게 할 것입니다 ==>

1) 랩퍼 추상 클래스와 방법 정의

public  abstract class Function 
{
    public abstract double f(double x);
}

2) APPLY_TO_ARRAY 방법으로 클래스 정의 

public class ArrayMap 
{
public static double[] apply_to_array(double[] arr, Function fun)
{
    for(int i=0; i<arr.length;i++)
    {
        arr[i]=fun.f(arr[i]);
    }
    return arr;
}
}

3) 테스터 급을 만들고 재미있는 시간을 보내십시오

public class Testclass extends Function
{
    public static void main(String[] args) 
    {
        double[] myarr = {1,2,3,4};
        ArrayMap.apply_to_array(myarr, new Testclass());
        for (double k : myarr)
        {
        System.out.println(k);
        }

    }

    @Override
    public double f(double x) 
    {

        return Math.log(x);
    }   
}

우리는 Function 타입의 객체를 전달할 필요가 있으며 Testclass는 Function 클래스를 확장 할 수 있으므로 캐스트는 자동입니다.

여기에 매개 변수가 바인딩 된 메서드를 메서드의 매개 변수로 전달하는 방법을 보여주는 해결책을 찾지 못했습니다. Bellow는 이미 바인딩 된 매개 변수 값을 가진 메서드를 전달하는 방법의 예입니다.

  1. 1 단계 : 리턴 유형이있는 인터페이스 하나와없는 인터페이스를 두 개 작성하십시오. Java는 비슷한 인터페이스를 가지고 있지만 예외 처리를 지원하지 않기 때문에 실용성이 거의 없습니다.


    public interface Do {
    void run() throws Exception;
    }


    public interface Return {
        R run() throws Exception;
    }
  1. 트랜잭션에서 메소드 호출을 랩핑하기 위해 두 인터페이스를 사용하는 방법의 예. 실제 매개 변수와 함께 메소드를 전달합니다.


    //example - when passed method does not return any value
    public void tx(final Do func) throws Exception {
        connectionScope.beginTransaction();
        try {
            func.run();
            connectionScope.commit();
        } catch (Exception e) {
            connectionScope.rollback();
            throw e;
        } finally {
            connectionScope.close();
        }
    }

    //Invoke code above by 
    tx(() -> api.delete(6));

또 다른 예는 실제로 무언가를 반환하는 메소드를 전달하는 방법을 보여줍니다.



        public  R tx(final Return func) throws Exception {
    R r=null;
    connectionScope.beginTransaction();
    try {
                r=func.run();
                connectionScope.commit();
            } catch (Exception e) {
                connectionScope.rollback();
                throw e;
            } finally {
                connectionScope.close();
            }
        return r;
        }
        //Invoke code above by 
        Object x= tx(() -> api.get(id));

리플렉션이있는 솔루션의 예, 전달 된 방법은 공용이어야합니다

import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;

public class Program {
    int i;

    public static void main(String[] args) {
        Program   obj = new Program();    //some object

        try {
            Method method = obj.getClass().getMethod("target");
            repeatMethod( 5, obj, method );
        } 
        catch ( NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            System.out.println( e ); 
        }
    }

    static void repeatMethod (int times, Object object, Method method)
        throws IllegalAccessException, InvocationTargetException {

        for (int i=0; i<times; i++)
            method.invoke(object);
    }
    public void target() {                 //public is necessary
        System.out.println("target(): "+ ++i);
    }
}

참고 URL : https://stackoverflow.com/questions/2186931/java-pass-method-as-parameter

반응형

'Programing' 카테고리의 다른 글

numpy 배열을 역전시키는 가장 효율적인 방법  (0) 2020.04.06
'X-Frame-Options'를 'SAMEORIGIN'으로 설정하여 프레임에 표시하지 않습니다.  (0) 2020.04.06
NTFS의 최대 파일 이름 길이 (Windows XP 및 Windows Vista)?  (0) 2020.04.06
Xcode 5에 iOS 6 SDK를 설치할 수 있습니까?  (0) 2020.04.06
내부 조인 대 위치  (0) 2020.04.06

'Programing'의 다른글

  • 현재글파라미터로서의 Java 패스 메소드

관련글

댓글

티스토리툴바