인터페이스 기능

Java 8에 대한 인터페이스 기능은 다음과 같습니다. nas versões mais antigas, já era possível encontrar esse tipo de interface Mas foi no Java 8 que elas adquiriram maior importância, uma vez que elas são peças Fundamentais para a Implementação das expressões lambdas. Mas o que é uma 인터페이스 기능?

Uma interface funcional é uma interface que possui apenas um metodo abstrato. Ela pode ter mais de um metodo, mas se apenas um deles for abstrato, ela será será thinkada uma interface funcional. Vamos는 인터페이스 Comparator를 예시로 사용합니다.

@FunctionalInterface
public interface Comparator<T> {
  int compare(T o1, T o2);
}

Essa interface contém mais métodos do que apenas o transcrito acima, e ela é interessante por alguns motivos que vou explicando ao longo do artigo. Para criar as comparações criei uma classe Livro:

public class Livro{

    private String nome;
    private int qtdPaginas;

    public Livro(String nome, int qtdPaginas){
        this.nome = nome;
        this.qtdPaginas = qtdPaginas;
    }

    public String getNome() {
        return nome;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }
    public int getQtdPaginas() {
        return qtdPaginas;
    }
    public void setQtdPaginas(int qtdPaginas) {
        this.qtdPaginas = qtdPaginas;
    }
}

Acriação de um Comparator utilizando a classe Livro seria:

 Comparator<Livro> comparator = new Comparator<Livro>() {
            @Override
            public int compare(Livro o1, Livro o2) {
                return o1.getNome().compareTo(o2.getNome());
            }
        };

Utilizando lambda, podemos ainda escrever o 단순 형식 비교:

Comparator<Livro> porNome =
                (Livro o1, Livro o2)->o1.getNome().compareTo(o2.getNome());

Utilizando a classe anônima, vemos que o código fica um pouco confuso, porém o método que está sendo sobrescrito fica claro. Já quando utilizamos lambda, não fica explicito qual é o metodo da interface a ser sobrescrito, e é por isso que ela deve ser uma interface funcional: haverá apenas um metodo crito sobre que ser.

Uma utilização desse
비교기:

public static void main(String[] args){
        Comparator<Livro> porNome =
                (Livro o1, Livro o2)->o1.getNome().compareTo(o2.getNome());

        List<Livro> livros = new ArrayList<>();
        livros.add(new Livro("Morte e vida Severina", 240));
        livros.add(new Livro("Vidas Secas", 190));
        livros.add(new Livro("O Alienista", 150));
        livros.add(new Livro("Alice no País das Maravilhas", 300));

        livros.sort(porNome);
    }

Ou ainda de forma mais direta:

public static void main(String[] args){
        List<Livro> livros = new ArrayList<>();
        livros.add(new Livro("Morte e vida Severina", 240));
        livros.add(new Livro("Vidas Secas", 190));
        livros.add(new Livro("O Alienista", 150));
        livros.add(new Livro("Alice no País das Maravilhas", 300));

        livros.sort((Livro o1, Livro o2)->o1.getNome().compareTo(o2.getNome()));
    }

인터페이스에 대한 작업 메토도스 인터페이스 없음 Java são por padrão públicos e abstratos. Porém, em uma interface funcional também podem ser encontrados metodos default. 인터페이스 Comparator possui diversos metodos default, como:

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);

    boolean equals(Object obj);

    default java.util.Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    default <U> java.util.Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            java.util.Comparator<? super U> keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }
}

Como anteriormente dito, não transcrevi todos os metodos presentes na interface, apenas alguns para Mostrar que a ela pode possuir mais mes metodos, desde que sejam default methods.

O 메토도 부울 equals(Object obj); 인터페이스 설명 없음 Comparator como funcional porque ele é uma sobrescrita do metodo equals da classe Object.

Para evitar que uma interface funcional fosse descaracterizada acidentalmente causando prejuízo na utilização de expressões lambda, no Java 8 foi introduzida a anotação FunctionalInterface. É uma anotação opcional para manter as demais interfaces funcionais que já Existing antes da versão 8 do Java funcionando normalmente. Colocada mas ainda assim a interface tiver apenas um metodo abstrato, ela será thinkada funcional을 위한 Se não.

Java가 없는 인터페이스의 예:

유사한:

public interface Comparable<T> {
    public int compareTo(T o);
}

실행 가능:

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

인터페이스로 Comparator 및 Runnable conceitualmente já eram 고려 사항 인터페이스 기능은 Java 8에서 사용할 수 없습니다.

Esse artigo faz parte de uma série que estou escrevendo enquanto revejo as funcionalidades do Java 8. Se gostou ou tem melhorias para sugerir, vou adorar saber!