Definição de padrão de iterador
O modo Iterator (Iterator) fornece uma maneira de acessar sequencialmente vários elementos em um objeto agregado sem expor a representação interna do objeto.
Traversal é comumente usado durante o desenvolvimento Java. O seguinte programa paralelo:
for(int i =0 ;i<arr.length;i++){
System.out.println(arr[i]);
}
Na instrução for, i ++ é incrementado em 1 cada vez que faz um loop e itera para o próximo elemento. O padrão formado após abstrair e generalizar o papel das variáveis de loop torna-se o padrão Iterator no padrão de design.
Cenário de realização
Coloque o livro (Book) na estante (BookShelf) e exiba os títulos dos livros em ordem.
Exemplo de programa
Interface agregada:
a interface da coleção a ser percorrida. Uma classe que implementa essa interface se tornará uma coleção que pode armazenar vários elementos, semelhante a um array.
public interface Aggregate{
public abstract Iterator iterator();
}
O método declarado na interface Aggregate é iterator, que é usado para gerar um iterador para travessia.
Interface do iterador:
é usada para percorrer os elementos na coleção, que é equivalente à variável de loop na instrução de loop (para (int i = 0; i <arr.lenth; i ++), que implementa especificamente um iterador de passagem sequencial.
public interface Iterator{
public abstract boolean hasNext();
public abstract Object next();
}
O método hasNext () determina se há um próximo, e o método next () obtém o próximo elemento.
Sob instruções especiais, quando o próximo método obtém o elemento, ele adiciona um à contagem do próximo elemento. Obtenha o elemento atual e aponte para o próximo elemento.
Classe do livro: classe
geral, método getName () do campo do título do livro para obter o título do livro. O construtor inicializa o título do livro.
public class Book{
private String name ;
public Book(String name){
this.name=name;
}
public String getName(){
return name;
}
}
Classe BookShelf: a
classe bookshelf, como uma classe de coleção para armazenar livros, implementa a interface Aggregate. Ele implementa o método iterador da interface Aggregate.
public class BookShelf implements Aggregate {
private List<Book> books;
public BookShelf() {
this.books = new ArrayList<Book>();
}
public Book getBookAt(int index) {
return books.get(index);
}
public void appendBook(Book book) {
books.add(book);
}
public int getLength() {
return books.size();
}
public Iterator iterator() {
return new BookShelfIterator(this);
}
}
O ponto principal é o método iterador, que retorna a classe BookShelfIterator a ser usada ao percorrer a estante como o iterador da estante. Este método será chamado quando o mundo externo quiser atravessar a estante.
Classe BookShelfIterator:
public class BookShelfIterator implements Iterator {
private BookShelf bookShelf;
private int index;
public BookShelfIterator(BookShelf bookShelf) {
this.bookShelf = bookShelf;
this.index = 0;
}
public boolean hasNext() {
if (index < bookShelf.getLength()) {
return true;
} else {
return false;
}
}
public Object next() {
Book book = bookShelf.getBookAt(index);
index++;
return book;
}
}
Como um iterador, ele precisa implementar a interface Iterator. índice é o índice atualmente apontado pelo iterador.
hasNext determina se há um próximo livro. Julgue comparando o subscrito e o total.
Em seguida, pega o livro atual e aponta para o próximo.
Classe principal:
public class Main {
public static void main(String[] args) {
BookShelf bookShelf = new BookShelf();
bookShelf.appendBook(new Book("Around the World in 80 Days"));
bookShelf.appendBook(new Book("Bible"));
bookShelf.appendBook(new Book("Cinderella"));
bookShelf.appendBook(new Book("Daddy-Long-Legs"));
Iterator it = bookShelf.iterator();
while (it.hasNext()) {
Book book = (Book) it.next();
System.out.println(book.getName());
}
}
}
控制台：
----------------------------------
Around the World in 80 Days
Bible
Cinderella
Daddy-Long-Legs
----------------------------------
A função de cada função no modo Iterator
- Iterador: esta função é responsável por definir a interface de elementos de passagem, um por um, em ordem. No programa, executado pela interface Iterator, dois métodos haveNext e next são definidos.
- Concretelterator (iterador específico): Esta função é responsável por implementar a interface definida pela função Iterator, que contém as informações necessárias para percorrer a coleção.
- Agregar: esta função é responsável por definir a interface para criar a função Iterator. Essa interface é um método que cria um e acessa as pessoas armazenadas em meus elementos internos em ordem.
- ConcreteAggregate (coleção específica): Esta função é responsável por implementar a interface definida pela função Aggregate. Ele criará uma função Iterator específica, que é ConcreteIterator, que é BookShelf no exemplo.
Diagrama de classes do modo Iterator:
O foco do aprendizado de padrões de design.
Iterator pode ser usado independentemente de como a implementação muda.
Por que devemos considerar a introdução do padrão de design complexo do Iterator?
Se for um array, não pode ser percorrido diretamente com a instrução for fantasy?
Por que introduzir a função Iterator fora da coleção?
Um motivo importante: a introdução do Iterator pode separar a travessia da implementação.
while (it.hasNext ()) { Book book = (Book) it.next () ; System.out.println (book.getName ()); } Os métodos hasNext e next do iterador são usados aqui, e BookShelf não é chamado Métodos. Em outras palavras, o loop while aqui não depende da implementação do BookShelf.
Por exemplo, os desenvolvedores da BookShelf decidiram abandonar o uso de arrays para gerenciar livros e, em vez disso, usar Java.util.Vector, o que acontecerá. Não importa como o BookShelf muda, contanto que o método iterador do BookShelf possa retornar corretamente a força do Iterator, o código pode funcionar normalmente mesmo sem qualquer modificação no loop while acima.
É realmente conveniente para o chamador de BookShelf.
O papel dos padrões de projeto é nos ajudar a escrever classes reutilizáveis.
O denominado reutilizável refere-se à realização de uma classe como um componente, quando um componente muda, outros componentes não precisam ser modificados ou apenas uma pequena modificação é necessária para lidar com ele.
Isso também pode compreender porque o valor de retorno do método iterador no programa de amostra não é a classe bookshelfiter, mas o tipo iter. Isso mostra que o programa deve usar o método iterador para programação em vez do método bookshelfiterator.
Difícil de
entender classes e interfaces abstratas Pessoas que têm dificuldade em entender classes e interfaces abstratas geralmente consomem funções ConcreteAggregate e programação de funções ConcreteIterator em vez de interfaces Aggregate e Iterator. Elas sempre desejam usar classes concretas para resolver todos os problemas.
No entanto, se apenas classes específicas forem usadas para resolver o problema, é fácil causar forte acoplamento entre as classes, e essas classes também são difíceis de serem reutilizadas como componentes. A fim de enfraquecer o acoplamento entre as classes e tornar mais fácil para as classes ser reutilizados como componentes, precisamos introduzir classes abstratas e interfaces.
Esse tipo de pensamento deve percorrer todo o padrão de design.
Correspondência entre Aggregate e Iterator É um recurso do modo Iterator que
vários Iterators
percorrerão funções fora da função de Aggregate. Este recurso pode escrever várias funções ConcreteIterator para uma função ConcreteAggregate.
Apresente vários padrões de design com antecedência:
O modo
iterador do modo Vistor remove os elementos um a um da coleção para a travessia, mas não faz nenhum processamento nos elementos retirados na interface do Iterator.
O modo Vistor executa o mesmo processamento nos elementos no processo de atravessar a coleção de elementos.
No processo de percorrer a coleção, geralmente é necessário executar um processamento fixo nos elementos. O modelo de visitante surgiu em resposta a essa demanda. O mesmo processo é realizado nos elementos no processo de coleta dos elementos quadrados.Este modo é o modo Vistor.
Modo composto O modo
composto é um modo com uma estrutura recursiva, em que o modo iterador é mais difícil de usar.
Modo Método de Fábrica O modo Método de Fábrica
pode ser usado ao gerar a potência do Iterador no método do iterador.
Autor: toot bumper rattled
link: https: //www.jianshu.com/p/3dd7b4e73561
Fonte: Os livros de Jane
são de propriedade do autor. Para reimpressões comerciais, entre em contato com o autor para obter autorização e, para reimpressões não comerciais, indique a fonte.