Diário de aulas

Aula 1 - 30/07/14: Apresentação da disciplina e Introdução ao Java

Introdução ao Java
1. Surgimento

Slides aula 1

Aula 2 - 31/07/14: Introdução ao Ambiente de Desenvolvimento Integrado - IDE
Slides aula 2

Aula 3 - 06/08/14: Revisão dos conceitos: classes, métodos e atributos
Slides aula 3

Aula 4 - 07/08/14: Revisão portas lógicas, estruturas de controle, repetição e vetores.

Revisão
1. Revisão Portas .E. e .OU.
2. Revisão Estruturas de Controle (if e switch).
3. Revisão Estruturas de Repetição (for e while).
4. Revisão Vetores.

Possível solução para o exercício da classe Vetor

Aula 5 - 13/08/14: Revisão exercícios.
Media:AulaRevisao.pdf

Aula 6 - 14/08/14: Sobre carga de métodos e palavras reservadas: this, static e final.
Slides aula 6

Aula 7 - 20 e 21/08/14: Trabalho

Trabalho para fazer:

Pense em um problema para resolver utilizando os conceitos aprendidos em sala de aula. O problema deve ser simples, uma calculadora, um relógio, um carro, qualquer coisa.

Para resolução deve-se seguir os seguintes passos.

Quantidade mínima de atributos: 4-8 sendo que é necessário um vetor[]. Para o atributo vetor é necessário poder (adicionar, remover, listar e verificar existência).

Pense em atributos estáticos (static) e normais quando e porque usar.

Utilize sempre que possível this para referenciar variáveis locais a classe.

Quantidade mínima de métodos:

Construtor padrão e construtor modificado.
3 - Métodos para recuperar informação (usar getNomeDoMetodo()).
3 - Métodos para definir informações (usar setNomeDoMetodo(parâmetros)).

UML:

Desenhar o diagrama de classes.

Entrega: A definir.

obs: utilizar exemplos diferentes dos aprendidos em sala

Programas:

Utilizar o seguinte programa para geração do diagrama de classe.
http://www.genmymodel.com/

Aula 8 - 28/08/14: Estrutura de dados HashMap<Integer, Classe>

Baixar projeto e descompactar.

Abrir com o NetBeans.

Analisar o arquivo Main.java do pacote herancaAgregacao

Projeto Até Aula 8

Aula 9 - 11/09/14: Composição, Agregação, Variáveis Primitivas e Escopo de Variáveis

Variáveis Primitivas, Escopo de Variáveis e Operadoes.

Agregação e Composição.

Aula 10 - 17/09/14: A classe Serializable. Leitura e Escrita em arquivos

Utilize uma das classes que aprendemos, e tente transformá-la para serializable. 
As classes podem sem: Motor, Bicicleta, Triângulo, Calculadora, etc...
Após isso, salve o objeto em um arquivo e recupere as informações, faça uma chamada a algum método.

Slides Aula java.io.Serializable.

Para Exercício 2 (ver slides):

public static void main(String[] args) {
       Principal2 p = new Principal2();
       System.out.println("Chamando salvarEmDisco.");
       p.salvarEmDisco();
       System.out.println("Chamando lerDoDisco.");
       p.lerDoDisco();
}

Aula 11 - 18/09/14: Sockets.

Lembrar de definir o diretório de trabalho no NetBeans;
Lembrar de criar o arquivo socketData.txt dentro do diretório de trabalho.

Projeto Servidor.

Slides Aula Cliente Servidor.

Aula 12 - 24/09/14: Sockets, Servidor de eco.

Baixe o servidor e cliente de eco. Crie um projeto no NetBeans com o nome ecoServer. Insira os dois .java dentro da pasta src. Leia a descrição do código abaixo, entenda e modifique conforme o necessário.

 Servidor e Clientes de Eco

Vamos entender o código do CLIENTE.

Declara a criação de um novo socket e dá o nome de echoSocket. O construtor do socket necessita que passe como parâmetro o hostName e número da porta.

Socket echoSocket = new Socket(hostName, portNumber);

Obtém a saída do socket e abre um canal de escrita (PrintWriter).

PrintWriter out = new PrintWriter(echoSocket.getOutputStream(), true);

Inverso do anterior, obtém a entrada do socket e abre um canal de leitura (BufferedReader)

BufferedReader in = new BufferedReader( new InputStreamReader(echoSocket.getInputStream()));

Para enviar dados através do socket, usa-se o PrintWriter. Para obter a resposta do servidor de eco, usa-se BufferedReader.

BufferedReader stdIn = new BufferedReader( new InputStreamReader(System.in))

A próxima parte interessante é o laço (while). O laço lê uma linha por vez do fluxo de entrada padrão do usuário (teclado) e imediatamente envia para o servidor. Para isso escreve-se no PrintWriter conectado ao socket, a saber out.println(userInput);.

String userInput;
while ((userInput = stdIn.readLine()) != null) {
   out.println(userInput);
   System.out.println("echo: " + in.readLine());
}

Passos necessários:

# 1 Abrir o socket.
# 2 Abrir o fluxo de entrada e saída do socket.
# 3 Ler de e Escrever para no fluxo conforme o protocolo utilizado.
# 4 Fechar o fluxo.
# 5 Fechar o socket.

Vamos entender o código do SERVIDOR.

ServerSocket inicia tentativa de escutar a porta definida, caso não seja possível uma excessão é lançada (ex.: caso a porta já esteja em uso).

ServerSocket serverSocket = new ServerSocket(portNumber);

É preciso alterar o código do servidor para que int portNumber = Integer.parseInt(args[0]); Ou seja definido estaticamente, ou através do argumento (args[0]) como está. Se não quiser fazer alterações use: java echoServer 5000

Se o servidor conseguiu fazer a ligação com a porta definida, o objeto do servidor (ServerSocket) é criado com sucesso e o servidor continua no próximo passo. Que é aceitar a conexão com o cliente. O método serverSocket.accept() vai esperar até que uma conexão seja estabelecida (somente uma).

Socket clientSocket = serverSocket.accept();

Os métodos PrintWriter e BufferedReader seguem a mesma lógica de PrintWriter e BufferedReader do cliente.

PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader( new InputStreamReader(clientSocket.getInputStream()));

O laço while, retorna ao cliente todos dados recebidos.

Como a comunicação acontece:

Para testar:

Compile os códigos.

Execute o servidor usando: java EchoServer <port number>

Execute o cliente usando: java EchoClient <host name> <port number>

Para verificar utilize: $ netstat -na|head -n 20 e verifique se a porta que você endereçou está aberta. Para filtrar de forma mais refinada utilize: netstat -na|grep :<portNumber> onde <portNumbe> deve ser substituido pela porta utilizada.

Lembrando que a porta deve ser a mesma.

Logo após executar o cliente digite algo e pressione enter.

Se você recebeu de volta o que escreveu, está ok.

Faça as atividades.

Atividades:

Lembrando da aula de escrita e leitura de arquivos:

Faça com que cada mensagem enviada pelo cliente de eco seja salva em disco (no servidor).

Faça com que a mensagem seja salva no servidor em um arquivo chamado reqEco.txt.

Possível Solução, verifique através do arquivo:

 Projeto Servidor, possível Solução.

Ou altere o código do servidor, o método while:

String inputLine;
           while ((inputLine = in.readLine()) != null) {
               out.println(inputLine);
               try {
                   OutputStream os = new FileOutputStream("meusDados.txt");
                   OutputStreamWriter osw = new OutputStreamWriter(os);
                   BufferedWriter bw = new BufferedWriter(osw);
                   bw.write("Info: " + inputLine);
                   bw.close();
               } catch (IOException ex) {
                   System.err.println("erro: " + ex.toString());
               }
               out.println("Informação Salva!");
               System.out.println("Informação: "+inputLine+ " salva!");
           }

Se a versão do Java for menor que 1.7 ocorrerá incompatibilidade. Para resolver, faça o downgrade do código. Utilize o try sem os ();

Dessa forma:

try { ... } 
catch () { ... }

Ao invés de:

try ( ... ) { ... } 
catch () { ... }

Aula 13 - 25/09/14, 01/10/2014: Sockets, Servidor de eco, continuação.

Pré-requisito: Ler, fazer e entender aulas 10 e 12.

Modificações no servidor.

1

Faça com que ao digitar "quit" ou "exit" a conexão e o servidor sejam fechados. 
Faça o tratamento das palavras reservadas quit e exit, para que as mesmas não sejam salvas.

Possível solução para a modificação 1:

Tratamento para não salvar palavras reservadas (quit, exit...)

if(!inputLine.equalsIgnoreCase("quit") 
   && !inputLine.equalsIgnoreCase("exit") 
   && !inputLine.equalsIgnoreCase("saveData")                        
   && !inputLine.equalsIgnoreCase("cleanData") 
   && !inputLine.equalsIgnoreCase("showData") ){
   buffer[i++] = inputLine.toString();
   System.out.println("Bufferizando: \""+inputLine.toString()+ "\"");
}

Tratamento para término do servidor.

if(inputLine.equalsIgnoreCase("exit") || 
   inputLine.equalsIgnoreCase("quit")){
   System.exit(0);
}

2

Transforme em um método privado a parte que faz a gravação dos dados dentro do while (servidor).
O método deve retornar um boolean informando se a gravação foi efetuada com sucesso.
Verifique o método FileOutputStream() para ver se é possível salvar concatenando o arquivo
ao invés de apagar como está sendo feito.

Possível solução para a modificação 2:

Método privado para salvar dados no disco. Esse método deve estar na mesma classe do servidor. Perceba que o método recebe dois parâmetros, o primeiro consiste do dado a ser salvo, e o segundo onde deve ser salvo.

O método deve ser chamado da seguinte forma:

salvaDadoNoDisco(buffer[x], "arquivo.txt");

Sendo que buffer[x] é o elemento do vetor que contém a informação a ser salva. O segundo parâmetro "arquivo.txt" contém o nome do arquivo onde deve ser salvo o dado.

private static boolean salvaDadoNoDisco(String inputLine, String file) {
   try {
       OutputStream os = new FileOutputStream(file, true);
       OutputStreamWriter osw = new OutputStreamWriter(os);
       BufferedWriter bw = new BufferedWriter(osw);
       bw.write("\n" + inputLine.toString());
       bw.close();
       return true;
   } catch (IOException ex) {
       System.err.println("erro: " + ex.toString());
       return false;
   }
}

3

Crie um vetor chamado "buffer" com 4 posições. 
Nele devem ser armazenadas as informações que o cliente enviar por telnet (somente as válidas, ou seja, não salvar as palavras reservadas nem dados vazios). 
Quando o cliente enviar o comando "SaveData" os dados contidos no buffer devem ser salvos em disco.
Quando o buffer encher, deve-se salvar automaticamente os dados em disco. 
Obs.: somente os valores devem ser salvos em disco.

4

Para os apaixonados que terminaram a etapa anterior, adicione a palavra reservada "showData".
O cliente ao digitar "showData", todas as informações contidas no arquivo devem ser retornadas ao cliente.

5

Finalizando, adicione a palavra reservada "cleanData", quando o servidor receber o comando
"cleanData" o conteúdo do arquivo meusDados.txt deve ser apagado.

Aula 14 - 02/10/2014: Classe java.lang.String.

É necessário ler a apostila ou outras fontes para resolução.

Baixe o arquivo abaixo, crie um projeto no NetBeans e resolva o que está comentado.

Exercício manipulação de String

Obs.: o exercício está comentado dentro do código java. Abra e veja.

Coloquei aqui numerado:

   #1 Separe os nomes da frase f1 utilizando o caracter : como separador
   e mostre os valores separados.
   #2 Substitua na frase f2 a palavra Java por C++    
   #3 Verifique na frase f2 se existe a palavra Java
   #4 Verifique na frase f2 se existe a palavra C++
   #5 Verifique se a frase f3 inicia com Meu pé
   #6 Verifique se a frase f3 inicia com Me
   #7 Verifique se a frase f3 termina com lima.
   #8 Verifique se a frase f3 termina com ma.    
   #9 Faça com que a frase f4 fique com todas as palavras em maiúsculas.    
   #10 Faça com que a frase f5 fique com todas as palavras em minúsculas.    
   #11 Retornar o valor ASCII de cada elemento do vetor ascii
   #12 Verificar igualdade da frase f6, respeitando maiúsculas e minúsculas (utilizar a palavra João)
   #13 e sem respeitar maiúsculas e minúsculas (utilizar a palavra João)