Início / coding / Perguntas / 79342974
Accepted
Alper ARSLAN
Asked: 2025-01-09 22:28:37 +0800 CST

A substituição da interface estendendo o método de interface funcional como padrão e tendo um método abstrato funciona abruptamente

  • 772
@FunctionalInterface
interface StringConsumer extends Consumer<String> {
    @Override
    public default void accept(String s) {
        System.out.println(s.toUpperCase());
    }
    void print(String s);
}

public class Test {
    public static void main(String[] args) {
        StringConsumer stringConsumerImpl= s -> System.out.println(s.toLowerCase());
        List<String> list = Arrays.asList("Dr", "Mr", "Miss", "Mrs");
        list.forEach(stringConsumerImpl);
    }
}

Saída: DR MR MISS MRS

Então o que está acontecendo neste código é realmente estranho para mim. Na verdade, estou fornecendo a implementação do método print, mas quando executo o código, ele na verdade usa a implementação do método default.

Eu esperava que a implementação de impressão funcionasse. Editar: quando o método de impressão é excluído do StringConsumer, ele causa um erro de compilação no método principal

java

2 respostas

  1. Você tem

    StringConsumer stringConsumerImpl= s -> System.out.println(s.toLowerCase());

    Que é a abreviação de:

    class Tmp implements StringConsumer {
    @Override
    public default void accept(String s) {
        System.out.println(s.toUpperCase());
    }
    @Override
    void print(String s) {
        System.out.println(s.toLowerCase());
    } 
}
StringConsumer stringConsumerImpl = new Tmp();

    Ele tem dois métodos: accepteprint

    list.forEach(stringConsumerImpl);

    solicita stringConsumerImpl.accept()todos os elementos de list.

    Não sabe sobre print.

    Para obter o resultado desejado você precisa chamá-lo assim

    list.forEach(stringConsumerImpl::print);
    • 5
  2. Best Answer

    Iterable.forEaché implementado assim :

    default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

    Ele chama o acceptmétodo do que Consumervocê passou, então é por isso que accepté chamado e não print. É simples assim.

    Você pode ter pensado que isso forEachchamará qualquer expressão lambda que você passou. Isso não é verdade. Expressões lambda são apenas uma maneira sofisticada de criar uma implementação de uma interface que tem um único método abstrato. O corpo da expressão lambda é a implementação desse único método abstrato ( print). Isso apenas poupa o trabalho de escrever uma classe como essa e criar uma instância dela:

    class Foo implements StringConsumer {
    @Override
    public void print(String s) {
        System.out.println(s.toLowerCase());
    }
}

    Essa interface é livre para ter outros métodos padrões e outros métodos podem escolher chamar esses métodos padrões, em vez do método abstrato que o lambda implementa. É como qualquer outra variável de um tipo de interface.

    • 3

relate perguntas