"Olá, amigo! Hoje, Ellie falou sobre o padrão do adaptador."

A maioria das classes relacionadas a fluxos de E/S são implementadas como adaptadores. Eles convertem interfaces equivalentes ou as conectam, começando do simples e subindo para o complexo.

" InputStreamReader e BufferedReader também são adaptadores? No mínimo, eles são muito semelhantes aos adaptadores na maneira como são usados: depois que um objeto é criado, ele é passado para o construtor de outra classe."

"Sim, InputStreamReader converte a interface InputStream na interface Reader . BufferedReader não é um adaptador em sua forma mais pura, porque os criadores de Java decidiram não dar a seus métodos sua própria interface separada. Mas é uma alma gêmea."

Em vez de escrever um zilhão de classes diferentes, os criadores de Java escreveram duas dúzias de adaptadores e permitiram que eles se conectassem uns aos outros da maneira que um programador quisesse.

Java university

Essa abordagem é muito conveniente. Um programador sempre pode escrever sua classe e/ou adaptador, fazer com que ele implemente uma interface padrão e incluí-lo na cadeia de objetos do adaptador que está construindo.

"Então é assim que tudo funciona. Em vez de classes grandes e complexas, fazemos cadeias de objetos e adaptadores simples. E então é só criá-los e combiná-los na ordem certa!"

"E você implementa o que está faltando."

"Sim entendo."

"Mas, na verdade, eu queria falar sobre Reader e Writer hoje. Essas são duas classes abstratas muito semelhantes às classes InputStream e OutputStream. Mas, ao contrário dessas classes, essas duas classes trabalham com caracteres. Elas leem e escrevem caracteres. Elas são muito conveniente ao trabalhar com informações textuais. Vamos dar uma olhada nos métodos que eles têm:"

métodos de leitura O que o método faz 
int read(char[] cbuf);
 "Este método lê imediatamente vários caracteres no buffer ( char array ), até que o buffer esteja cheio ou até que a fonte não tenha mais caracteres para ler."
O método retorna o número de caracteres realmente lidos (que podem ser menores que o tamanho do array)		 
int read();
 "Este método lê um caractere e o retorna. O resultado é ampliado para um int para aparência. Se não houver caracteres disponíveis, o método retorna -1." 
boolean ready();
 Este método retorna verdadeiro se houver caracteres não lidos para os métodos de leitura 
void close();
 Este método «fecha» o stream. Você chama isso quando terminar de trabalhar com o fluxo.
O objeto então executa as operações de manutenção necessárias para fechar o arquivo, etc.
Neste ponto, você não pode ler mais dados do fluxo.

"Acontece que o método read(char [] cbuf) do Reader nos permite ler blocos inteiros de caracteres, em vez de um caractere por vez. Portanto, é mais rápido e mais conveniente."

"Exatamente. E agora vamos ver quais métodos o Writer tem:"

Método O que o método faz 
void write(int c);
 Este método escreve um caractere. O tipo int é reduzido a um char. A parte extra é simplesmente descartada. 
void write(char[] cbuff);
 Este método escreve uma matriz de caracteres. 
void write(String s);
 Este método escreve uma string. Ele é simplesmente convertido em um array de caracteres e então o segundo método é chamado. 
void flush();
 Se o fluxo estiver armazenando internamente quaisquer dados que ainda não foram gravados, esse método forçará a gravação. 
void close();
 Este método «fecha» o stream. Você chama isso quando terminar de trabalhar com o fluxo.
O objeto então executa as operações de limpeza necessárias para fechar o arquivo, etc. Você não pode mais gravar dados no fluxo, e o flush é chamado automaticamente.

É importante entender que Reader e Writer são classes abstratas. Eles não fazem nada e não contêm praticamente nenhum código. Todos os seus métodos precisarão ser implementados nas classes que os herdam. Seu trabalho é padronizar como as classes interagem . Os desenvolvedores não precisam inventar seus próprios padrões para interagir uns com os outros. É muito mais conveniente para todos manter alguns padrões básicos. Isso permite que classes escritas por diferentes programadores interajam facilmente não apenas com classes escritas pelos criadores de Java, mas também com classes escritas por outros programadores.

Os padrões são poderosos.

"Eu concordo. Apoiar padrões comuns é benéfico para todos."