티스토리 뷰

시작하는 글

1편에서 설명했던 제네릭의 개념을 바탕으로 하여 람다와 인터섹션에 대해 학습해보자.


람다란?

람다 표현식은 익명 클래스와 익명 메소드, 함수형 인터페이스를 단순화하여 표현한 것이다.

public class LambdaAndIntersection { 

    public static void main(String[] args) { 
        hello(o -> o); 

        hello(o -> { 
            return o; 
        }); 

        hello( 
            new Function(){ 

                @Override 
                public Object apply(Object o) { 
                    return o; 
                } 
        }); 
    } 

    private static void hello(Function o) { 
    } 
} 

위 예제를 보면 hello 란 정적 메소드에 할당된 파라미터 들은 람다에 익숙하지 않은 분들께는 다소 이상해 보일 수 있다.

놀라운 것은 메인 메소드 내 hello 메소드의 파라미터는 외형만 다른 모두 같은 메소드 이다.

1번째 메소드와 3번째 메소드를 비교했을 때 코드가 정말 간견해진 것을 알 수 있다.

참고로 람다를 쓰게 되면 관련 라이브러리에 의해 클래스가 내부적으로 생성되게 된다.

이러한 특성을 가진 Function과 같은 인터페이스를 함수형 인터페이스라고 한다.


함수형 인터페이스

함수형 인터페이스는 default 메소드, 정적 메소드가 아닌 메소드가 하나 뿐인 인터페이스. @FunctionalInterface란 어노테이션을 붙이지 않아도 괜찮다. 아래는 가장 대표적인 함수형 인터페이스인 Function 이다.

 @FunctionalInterface 
public interface Function<T, R> { 

    R apply(T t); 

    default  Function<V, R> compose(Function<? super V, ? extends T> before) { 
        Objects.requireNonNull(before); 
        return (V v) -> apply(before.apply(v)); 
    } 


    default  Function<T, V> andThen(Function<? super R, ? extends V> after) { 
        Objects.requireNonNull(after); 
        return (T t) -> after.apply(apply(t)); 
    } 

    static  Function<T, T> identity() { 
        return t -> t; 
    } 
} 

위 인터페이스에는 4개의 메소드가 있지만, non-static, non-default 메소드는 하나 뿐이므로 함수형 인터페이스 인 것이다.


인터섹션(Intersection)

람다 사용시 여러 인터페이스 교차시킴으로써 쉽고 빠르게 함수를 구현하는 방법이다.

public class LambdaAndIntersection { 

    public static void main(String[] args) { 
        hello((Function & Serializable & Cloneable) o -> o); 
    } 

    private static void hello(Function o) { 
    } 
} 

위 코드 대로면 Fucntion과 Serializable 그리고 Cloneable의 기능이 교차된 함수가 탄생하게 되며, 여러 인터페이스를 교차시킬 때 non-static, non-default 메소드가 한 개 이기만 하면 된다.

public class LambdaAndIntersection { 

    public interface Hello { 
        default void hello() { 
            System.out.println("hello"); 
        } 
    } 

    public interface Hi { 
        default void hi() { 
            System.out.println("hi"); 
        } 
    } 

    public static void main(String[] args) { 
        run((Function & Hello & Hi) o -> o, s -> { 
            s.hello(); 
            s.hi(); 
        }); 
    } 

    private static  void run(T t, Consumer c) { 
        c.accept(t); 
    } 
} 

이 예제는 default 메소드를 가지는 Hello와 Hi 인터페이스를 Function과 인터섹션 한 예제다.

대략적인 흐름을 보면 Function, Hello, Hi 인터페이스의 모든 기능이 혼합된 Function o가 Consumer에 accept 되고, 그래서 컨슈머 내에서 그 기능을 활용한다.

앞서 말했 듯이 인터섹션은 인덕션이라는 과정을 거치는데 그 과정에서 non-static, non-default 메소드가 한 개면 된다.

public class LambdaAndIntersection { 

    public interface BestNinizMember  { 
        T who(); 
    } 

    public interface CallBestNinizMember extends BestNinizMember { 
        default void call() { 
            System.out.println("Best Niniz Member is : " + who()); 
        } 
    } 

    public static void main(String[] args) { 
        run((BestNinizMember & CallBestNinizMember) () -> "죠르디", s -> { 
            s.call(); 
        }); 
    } 

    private static  void run(T t, Consumer c) { 
        c.accept(t); 
    } 
} 

위와 같은 것도 가능하다.

끝판왕

아래 예제와 같은 인터섹션을 구현할 수 있으면 마스터했다고 봐도 무방하다.

한번 유사하게 구현 해보자.

public class LambdaAndIntersection { 

    public interface JordyProfileTemplate  { 
        T getName(); 
        void setName(T t); 
        T getRace(); 
        void setRace(T s); 
    } 
    static class JordyProfile implements JordyProfileTemplate { 
        String name; 
        String race; 

        @Override 
        public String getName() { 
            return name; 
        } 

        @Override 
        public void setName(String name) { 
            this.name = name; 
        } 

        @Override 
        public String getRace() { 
            return race; 
        } 

        @Override 
        public void setRace(String race) { 
            this.race = race; 
        } 

        public JordyProfile(String name, String race) { 
            this.name = name; 
            this.race = race; 
        } 
    } 

    public interface DelegateTo { 
        T delegate(); 
    } 

    public interface ForwardingJordyProfileTemplate  extends DelegateTo<JordyProfileTemplate>, JordyProfileTemplate { 
        default T getName(){ 
            return delegate().getName(); 
        } 
        default void setName(T t){ 
            delegate().setName(t); 
        } 
        default T getRace(){ 
            return delegate().getRace(); 
        } 
        default void setRace(T t){ 
            delegate().setRace(t); 
        } 

    } 

    interface Printable  extends DelegateTo<JordyProfileTemplate> { 
        default void print() { 
            System.out.println(delegate().getName() + "  " + delegate().getRace()); 
        } 

    } 

    interface Convertable  extends DelegateTo<JordyProfileTemplate> { 
        default void convert(Function<T,T> mapper) { 
            JordyProfileTemplate jordyProfileTemplate = delegate(); 

            delegate().setName(mapper.apply(jordyProfileTemplate.getName())); 
            delegate().setRace(mapper.apply(jordyProfileTemplate.getRace())); 
        } 
    } 

    public static void main(String[] args) { 
        JordyProfile jordyProfile  = new JordyProfile("jordy","dino"); 
        run((ForwardingJordyProfileTemplate & Printable & Convertable) ()->jordyProfile , o -> { 
            o.print(); 
            o.convert(s -> s.toUpperCase()); 
            o.print(); 
            o.convert(s->s.substring(0,2)); 
            o.print(); 
        }); 
    } 
    public static ,S> void run(T t, Consumer c){ 
        c.accept(t); 
    } 
}
댓글
댓글쓰기 폼
공지사항
Total
3,233
Today
0
Yesterday
11
링크
TAG more
«   2020/05   »
          1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31            
글 보관함