Default Method 란

  • Interface 안에서 method 를 구현해놓아 상속받는 클래스에서 해당 method 를 따로 override 하지 않아도 된다.
  • 해당 Interface 를 상속받는 여러 클래스에서는 동일하게 동작하는 method 지만 하나의 클래스에서만 다르게 동작해야 할 경우
    Interface 내에서 default method 로 구현 후 다르게 동작할 클래스에서 override 하여 구현하면 된다.

JDK 내 예시

  • Collection.java (Interface)

      /**
       * Removes all of the elements of this collection that satisfy the given
       * predicate.  Errors or runtime exceptions thrown during iteration or by
       * the predicate are relayed to the caller.
       *
       * @implSpec
       * The default implementation traverses all elements of the collection using
       * its {@link #iterator}.  Each matching element is removed using
       * {@link Iterator#remove()}.  If the collection's iterator does not
       * support removal then an {@code UnsupportedOperationException} will be
       * thrown on the first matching element.
       *
       * @param filter a predicate which returns {@code true} for elements to be
       *        removed
       * @return {@code true} if any elements were removed
       * @throws NullPointerException if the specified filter is null
       * @throws UnsupportedOperationException if elements cannot be removed
       *         from this collection.  Implementations may throw this exception if a
       *         matching element cannot be removed or if, in general, removal is not
       *         supported.
       * @since 1.8
       */
      default boolean removeIf(Predicate<? super E> filter) {
          Objects.requireNonNull(filter);
          boolean removed = false;
          final Iterator<E> each = iterator();
          while (each.hasNext()) {
              if (filter.test(each.next())) {
                  each.remove();
                  removed = true;
              }
          }
          return removed;
      }
    
      /**
       * Creates a {@link Spliterator} over the elements in this collection.
       *
       * Implementations should document characteristic values reported by the
       * spliterator.  Such characteristic values are not required to be reported
       * if the spliterator reports {@link Spliterator#SIZED} and this collection
       * contains no elements.
       *
       * <p>The default implementation should be overridden by subclasses that
       * can return a more efficient spliterator.  In order to
       * preserve expected laziness behavior for the {@link #stream()} and
       * {@link #parallelStream()}} methods, spliterators should either have the
       * characteristic of {@code IMMUTABLE} or {@code CONCURRENT}, or be
       * <em><a href="Spliterator.html#binding">late-binding</a></em>.
       * If none of these is practical, the overriding class should describe the
       * spliterator's documented policy of binding and structural interference,
       * and should override the {@link #stream()} and {@link #parallelStream()}
       * methods to create streams using a {@code Supplier} of the spliterator,
       * as in:
       * <pre>{@code
       *     Stream<E> s = StreamSupport.stream(() -> spliterator(), spliteratorCharacteristics)
       * }</pre>
       * <p>These requirements ensure that streams produced by the
       * {@link #stream()} and {@link #parallelStream()} methods will reflect the
       * contents of the collection as of initiation of the terminal stream
       * operation.
       *
       * @implSpec
       * The default implementation creates a
       * <em><a href="Spliterator.html#binding">late-binding</a></em> spliterator
       * from the collections's {@code Iterator}.  The spliterator inherits the
       * <em>fail-fast</em> properties of the collection's iterator.
       * <p>
       * The created {@code Spliterator} reports {@link Spliterator#SIZED}.
       *
       * @implNote
       * The created {@code Spliterator} additionally reports
       * {@link Spliterator#SUBSIZED}.
       *
       * <p>If a spliterator covers no elements then the reporting of additional
       * characteristic values, beyond that of {@code SIZED} and {@code SUBSIZED},
       * does not aid clients to control, specialize or simplify computation.
       * However, this does enable shared use of an immutable and empty
       * spliterator instance (see {@link Spliterators#emptySpliterator()}) for
       * empty collections, and enables clients to determine if such a spliterator
       * covers no elements.
       *
       * @return a {@code Spliterator} over the elements in this collection
       * @since 1.8
       */
      @Override
      default Spliterator<E> spliterator() {
          return Spliterators.spliterator(this, 0);
      }
      default Stream<E> stream() {
          return StreamSupport.stream(spliterator(), false);
      }
      default Stream<E> parallelStream() {
          return StreamSupport.stream(spliterator(), true);
      }

+ Recent posts