interface의 default method와 static method

  Java8부터 interface에 default method와 static method를 사용할 수 있게 되었다. Default method와 static method는 해당 interface를 implements하는 모든 인스턴스가 같은 기능이 있었으면 좋겠다는 이유로 추가되었다.

public interface Foo {
 
    /**
     * 이름을 출력하는 추상 메서드
     */
    void printName();
 
    /**
     * 이름을 대문자로 출력하는 메서드
     */
    default void printNameUpperCase() {
        System.out.println(getName().toUpperCase());
    }
 
    /**
     * 이름을 가져오는 메서드
     * @return String 이름을 반환
     */
    String getName();
}
 
public class DefaultFoo implements Foo{
 
    /**이름을 저장*/
    String name;
 
    /**
     * DefaultFoo 생성자
     * @param name 이름을 받는 파라미터
     */
    public DefaultFoo(String name) {
        this.name = name;
    }
 
    /**
     * implements한 Foo 인터페이스의 getName 추상 메서드 구현체
     * @return String 멤버 변수 name을 반환
     */
    @Override
    public String getName() {
        return this.name;
    }
 
    /**
     * implements한 Foo 인터페이스의 printName 추상 메서드 구현체
     */
    @Override
    public void printName() {
        System.out.println(this.name);
    }
}
 
public class App {
 
    /**
     * 실습에 필요한 DefaultFoo의 인스턴스를 만들고 결과를 출력한다
     * @param args Unused
     */
    public static void main(String[] args) {
       Foo foo = new DefaultFoo("yunki");
       foo.printName();
       foo.printNameUpperCase();
    }
}

  Default method를 사용하게 되면 해당 인터페이스를 implements한 모든 객체에서 사용 가능하지만 이 기능을 제대로 동작할 것이라는 보장이 없다. 왜냐면 getName()의 구현체에서 어떤 값이 실제로 반환될지 모르기 때문이다. 따라서 이를 방지하기 위해 문서화를 철저히 해야한다. 이때 java8에서 추가된 @impleSpec을 사용한다.

/**
 * @implSpec
 * 이름을 대문자로 출력하는 메서드
 */
default void printNameUpperCase() {
    System.out.println(getName().toUpperCase());
}

  만약 이런 식으로 문서화를 했음에도 문제가 된다면 override를 하면 된다.

  Object에서 제공하는 메서드들은 default method로 재정의할 수 없다(추상 메서드는 가능).

//Default method 'toString' overrides a member of 'java.lang.Object'
default String toString() {}

  만약 인터페이스가 제공하는 default method를 사용하고 싶지 않다면 다른 인터페이스를 만들고 해당 인터페이스를 extends 한뒤 defualt method를 추상 메서드로 만들면 된다.

public interface Bar extends Foo{
    void printNameUpperCase();
}

  만약 Foo interface, Bar interface가 둘 다 같은  default method를 가지고 있다면 두가지를 동시에 implements할 수 없다. 해야 한다면 implements를 한 클래스에서 override를 해야 한다.

 

static method

해당 인터페이스를 implements하는 객체가 helper mthod(메서드의 작업을 도와주는, 반복적으로 사용되는 짧은 메서드)나 유틸리티가 필요할 경우 사용된다.

static void printAnyThing() {
    System.out.println("Foo");
}

public static void main(String[] args) {
    Foo foo = new DefaultFoo("yunki");
    foo.printName();
    foo.printNameUpperCase();
    Foo.printAnyThing();
}

 

java 8에서 추가된 default method

  Iterable의 default method

    forEach(): js의 forEach처럼 리스트를 순회한다. forEach는 Consumer를 인자로 받는다.

public static void main(String[] args) {
    List<String> names = new ArrayList<>();
    names.add("yunki");
    names.add("skull");
    names.add("keesun");
    names.add("toby");
 
    names.forEach(System.out::println);
}

    spliterator(): forEach같이 순회를 할 수도 있고 리스트를 여러개로 쪼갤 수 도 있다.

public static void main(String[] args) {
    List<String> names = new ArrayList<>();
    names.add("yunki");
    names.add("skull");
    names.add("keesun");
    names.add("toby");
 
    Spliterator<String> spliterator = names.spliterator();
    Spliterator<String> spliterator1 = spliterator.trySplit();
    //tryAdvance역시 Consumer를 인자로 받는다.
    while(spliterator.tryAdvance(System.out::println)); //keesun, toby
    System.out.println("=======");
    while(spliterator1.tryAdvance(System.out::println)); //yunki, skull
}

 

  Collection의 default method

    stream() / parallelStream() : Collection의 모든 하위 인터페이스들은 stream을 가지고 있다.

      stream은 내부적으로 spliterator를 사용한다. stream은 리스트 내부의 엘리먼트들을 스트림으로 만들어서 functional하게 처리를 할 수 있다.

public static void main(String[] args) {
    List<String> names = new ArrayList<>();
    names.add("yunki");
    names.add("skull");
    names.add("keesun");
    names.add("toby");
 
    Set<String> streamResult = names.stream()
        .map(String::toUpperCase)
        .filter(s -> s.startsWith("K"))
        .collect(Collectors.toSet());
 
    streamResult.forEach(System.out::println);
 
}

    removeIf(Predicate): 조건에 만족하는 엘리먼트를 제거한다. 인가로 Predicate를 받는다.

public class App {
 
    /**
     * java8 공식 API에서 추가된 default method 실습
     * @param args Unused
     */
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("yunki");
        names.add("skull");
        names.add("keesun");
        names.add("toby");
 
       names.removeIf(name -> name.startsWith("k"));
       names.forEach(System.out::println);
 
    }
}

  Comparator의 default method, static method

    reversed(): 내림차순으로 엘리먼트를 비교한다

public class App {
 
    /**
     * java8 공식 API에서 추가된 default method 실습
     * @param args Unused
     */
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("yunki");
        names.add("skull");
        names.add("keesun");
        names.add("toby");
 
        //오름차순 정렬
        names.sort(String::compareToIgnoreCase);
        names.forEach(System.out::println);
 
        System.out.println("==========");
 
        //내림차순 정렬
        Comparator<String> compareToIgnoreCase = String::compareToIgnoreCase;
        names.sort(compareToIgnoreCase.reversed());
 
        names.forEach(System.out::println);
    }
}
 

 

    thenComparing(): 기본적인 비교를 한 뒤 또 다른 조건으로 비교를 하고 싶을때 사용한다

    static reverseOrder() / naturalOrder()

    static nullsFirst() / nullLast(): null이 우선순위를 가진다 / null의 우선순위가 가장 뒤이다.

    static comparing()

 

Default method가 java api에 가져온 변화

  하나의 인터페이스가 있다고 해보자. java8이전에는 서로 다른 객체가 이 인터페이스를 조금 더 편리하게 상요하기 위해 아래 그림과 같이 인터페이스를 implements하는 추상 클래스를 만들고 이 추상클래스를 상속받아 사용했다.

  이런방식을 사용하면 굳이 구현이 필요없는 추상 메서드의 구현체를 구현할 필요가 없어진다. 하지만 자바에서는 오직 하나의 객체만을 상속받을 수 있기 때문에 상속을 더이상 받을 수 없는 문제가 발생하게 된다.

  java 8이상을 사용하게 되면 default method를 이용이 이 문제를 해결할 수 있다.