UFPB - Campus IV - Curso de Licenciatura em Ciência da Computação
Carga Horária: 60h
Período: 2012.1
Horário:
Segunda: 13h-15h (BC ou Laboratório)
Terça: 10h-12h (BC )
Horários de Atendimento: Segunda 8-10h, Quinta 8-12h (Sempre combinar antes com a professora)
Horários de Atendimento Presencial dos Monitores: (Sempre tentar entrar em contato com os monitores antes para agendar)
Fagner (fagner.silva@dce.ufpb.br)
Segunda 13-17
Quarta 10-12
Sexta 18-22
Rennan Felizardo (rennan.felizardo@dce.ufpb.br)
Segunda 10-12 e 13-15
Quarta 8-10 e 13-15
Qualquer dia a noite (sempre agendar)
Grupo de Discussões: https://groups.google.com/a/dce.ufpb.br/group/poo_comp?hl=pt
Plano de Curso: Baixe aqui.
Notas dos Alunos: Clique aqui.
Ementa: Práticas avançadas e aplicação de programação Orientada a Objetos na construção de um software. Uso de ambiente integrado de desenvolvimento. Técnicas de depuração. Exploração de bibliotecas de uma linguagem OO.
Objetivos Programáticos: Discutir e exercitar boas práticas no desenvolvimento de software Orientado a Objetos como modularização de código, uso de testes automáticos e técnicas de depuração e refatoramento de código. Introduzir programação concorrente na Linguagem Java. Fazer com que os alunos vivenciem na prática a investigação e uso de novas tecnologias e bibliotecas para a linguagem OO a ser utilizada (Java).
Objetivos Específicos: Capacitar os alunos a desenvolverem software orientado a objetos utilizando boas práticas de programação. Ao final do curso espera-se que o aluno:
Reconheça problemas no design de programas orientados a objetos;
Saiba desenvolver um software orientado a objetos, testá-lo, depurá-lo e melhorar a estrutura de seu código;
Saiba aprender uma tecnologia ou biblioteca OO com que nunca lidou anteriormente;
Saiba desenvolver sistemas concorrentes simples.
Conteúdo Programático:
Unidade I: Revisão de Orientação a Objetos; Uso do Framework de Coleções de Java e Generics; Composição x Herança; Enums e Annotations; Documentação de Código; Teste Automático de Software utilizando JUnit e ambientes integrados de desenvolvimento (IDEs).
Unidade II: Regras básicas de design e refatoramento; Padrões GRASP e Padrão Facade; Separação de interesses; Uso de tecnologias e bibliotecas para a linguagem Java (ex: Android, Swing, Java FX, JSF, Servlets, J2ME).
Unidade III: Programação Concorrente em Java.
Avaliação
Três avaliações escritas principais e um projeto prático ao fim da disciplina cuja defesa será também avaliada. Exercícios individuais ou em grupo, incluindo minitestes e seminários, além da participação do aluno na aula, serão também utilizados em cada unidade e estes poderão valer até 40% da pontuação máxima de cada estágio.
Bibliografia Básica:
BLAHA, M. Modelagem e projetos baseados em objetos com UML 2. 2.ed., Elsevier, 2006. 9 exemplares
BLOCH, J. Java Efetivo. 2.ed. Alta Books, 2010. 5 exemplares (português) e 3 exemplares (inglês/ 2008)
DEITEL, H. M. JAVA como programar. H. M Deitel e P. J. Deitel - 6a ed. Porto Alegre: Prentice-Hall, 2005. 5 exemplares
FOWLER, Martin. Refatoração - Aperfeiçoando o Projeto de Código Existente. Bookman, 2004. 0 exemplares
FURGERI, Sérgio. Java 6 – Ensino Didático: Desenvolvendo e Implementando Aplicações. 2a ed. São Paulo : Érica, 2010. 5 exemplares
HORSTMANN, C. S e Cornell, G. Core Java 2: Volume I – Fundamentos. 7a Edição. Editora Alta Books, 2005. 5 exemplares
HORSTMANN, C. Core Java 2 - Volume 2 – Recursos Avançados. Makron Books, 2002. 1 exemplar
LARMAN, C. Utilizando UML e Padrões - 3a. ed. Bookman, 2007.
ZAKHOUR et al. The Java Tutorial: A Short Course on the Basics. 4th Edition (Java Series). Prentice Hall, 2006. Versão online: http://java.sun.com/docs /books/tutorial/ 10 exemplares
Bibliografia Complementar:
ARAUJO, Kleitor Franklint Correa de. Java EE 5. 2a. ed. Erica, 2007. 5 exemplares
BARNES, David J.; KÖLLING, Michael. Programação Orientada a Objetos em JAVA: uma introdução prática usando o BLUEJ. Pearson, 2004. 9 exemplares
ECKEL, B. Thinking in java. 4th ed. 2008. 3 exemplares
FREEMAN, E. Use a cabeça: padrões e projetos. 2.ed. Rio de Janeiro: Alta Books, 2007. 5 exemplares
GOODRICH, Michael T., TAMASSIA, Roberto. Estruturas de dados e algoritmos em Java. 2.ed Bookman, 2006. 4 exemplares
MESZAROS, Gerard. XUnit Test Patterns. Addison-Wesley, 2007. 7 exemplares
ORAM, Andy. Beautiful Code. O’Reilly, 2007. 5 exemplares
SANTOS, Rafael. Introdução à Programação Orientada a Objetos Usando JAVA. Rio de Janeiro : Campus, 2003. 9 exemplares
SIERRA, K.; BATES, B. Java – Use a Cabeça. Editora Alta Books, 2.edição, 2007. 8 exemplares
SIERRA, Kathy. Certificação Sun Para Programador Java 6 Guia de Estudo. AltaBooks, 2008. 5 exemplares (versão 2005)
Exercícios:
Observação: Os exercícios serão todos postados no Github. Um link para o github de cada aluno e para o da professora pode ser visualizado aqui.
Exercício 0: Criar uma conta no GitHub, nela criar um repositório "poo" e enviar e-mail para a professora com o link para o repositório. Mais detalhes, acesse a página:
Exercício 1: Criar as classes utilizadas no exercício passado em sala e fazer as questões ao menos até a terceira. O exercício pode ser baixado aqui.
Exercício 2: Criar um script (.bat ou .sh) capaz de compilar suas classes do exercício 1 e executar o programa principal. Colocar esse script em uma pasta chamada exercicio2 do seu github.
Exercício 3: Criar um programa principal que receba através da entrada de texto vários itens de um certo pedido de 3 em 3 linhas. Na primeira linha é passado o código do produto pedido (ex: coca cola), na segunda é passada a quantidade desse item que é pedida (ex: 3) e na terceira linha o valor unitário do ítem (ex: 6.00). O programa vai lendo os itens até que no código seja passado "0" (zero). Após ler o "0" o programa deve imprimir o valor total do pedido, através da mensagem: Valor total:R$ [valor]. (Ex: Valor total:R$ 18.00). Colocar esse programa principal e as demais classes que utiliza em uma pasta do seu github chamada exercicio3. O programa principal deve chamar as classes do código correspondente ao sistema que está no github da professora (exercício 1).
Exercício 4: Organizar as classes do exercício 3 em um pacote chamado br.ufpb.sistemapedidos e documentar a interface e a classe ControleDePedidos com Javadoc. Colocar as classes feitas na pasta "exercicio4" do seu github.
Entrega (Exercício 1 ao 4): Até: 12/11 (mas não deixem de entregar, mesmo com atraso)
Exercício 5: Implementar uma Agenda simples, composta pelas seguintes classes: AgendaIF (interface), Agenda, Contato e ContatoInexistenteException. A interface apresenta 3 métodos, cuja assinatura é descrita abaixo. Essa interface é implementada pela classe Agenda. Construa também um programa principal numa classe "ProgramaExercicio5" e nele crie um objeto Agenda, adicione nele 1 contato, pesquise esse contato adicionado e pesquise um outro contato inexistente, tratando a exceção com a mensagem "Contato não cadastrado". As classes desse exercício devem ser colocadas no diretório "exercicio5" do seu github até o dia 19/11.
public void adicionarContato(String nome, String tel);
public void removerContato(String nomeContato) throws ContatoInexistenteException;
public Contato pesquisarContato(String nomeContato) throws ContatoInexistenteException;
Exercício 6 (Para casa: Aula de 19/11): Com base no código do Exercício 4, do sistema de Controle de Pedidos, implementar a classe GravadorDePedidos, do Exercício 1, que tem os métodos List <Pedido> lePedidos () e gravaPedidos(List<Pedido> pedidos), que lançam a exceção IOException. Fazer a classe ControleDePedidos usar essa classe para recuperar e gravar seus pedidos.
Exercício 7 (Aulas de 19/11 e 20/11): Fazer com que a agenda do Exercício 5 consiga persistir seus contatos em arquivo. Para isso, crie uma classe GravadorDeContatos e que permita gravar e recuperar uma coleção de objetos do tipo Contato (Collection <Contato>). Crie um programa principal que permita adicionar, remover e consultar contatos através de JOptionPane. Esse programa pode usar a implementação da AgendaIF Agenda, que usa List, ou uma nova implementação da interface AgendaIF chamada AgendaMap e que utilize internamente Map para guardar seus contatos.
Exercício 8 (Aula de 26/11): Alterar a Agenda entregue no exercício 7 adicionando na interface um método "getContatos()" que retorna um objeto do tipo Collection com todos os contatos e um método "getContatosOrdenados()" que retorna um "Iterator" com todos os contatos, só que ordenados pelo nome. Para ordenar os contatos, utilize a classe utilitária Collections e seu método de ordenação de coleções. Para que a coleção de contatos possa ser ordenada assim, é preciso que a classe Contato implemente a interface "Comparable <Contato>".
Exercício 9 (Aula de 3/12): Fazer duas classes de teste para a Agenda do Exercício 8, uma que teste a Agenda com Lista e outra que teste a Agenda com Map e todos os seus métodos. Nos métodos que testam o "getContatos" e o "getContatosOrdenados" adicionar ao menos 3 contatos e fora da ordem.
Exercício 10 (Aula de 21/01): Criar um repositório Git para o projeto do seu grupo, compartilhá-lo entre os membros da equipe e com a professora. Implementar algumas classes do seu projeto e colocá-las no repositório (não se preocupe se essas classes mudarem depois, o objetivo é esse). Escrever alguns testes para partes do seu sistema/jogo.
Exercício 11 (Aula de 28/01): Cada membro do grupo do projeto deve baixar para sua máquina o código do projeto, implementar um teste para uma das classes e colocar no repositório esse teste. É importante que no Git haja uma classe de teste diferente postada no Git por um membro diferente do grupo. Além disso, cada equipe deve incluir no Git do seu projeto a classe correspondente à Fachada do seu projeto e implementar alguma de suas funcionalidades, incluindo um teste que demonstre que o funcionamento do sistema/jogo está correto.
Exercício 12 (Aula de 4 de Fev): Concluir implementação da fachada e demais classes do projeto. Implementar testes automáticos para todas as funcionalidades, que devem estar representadas na fachada. Prazo final: 18/02. Não acumulem e nem se preocupem em implementar a parte de interface gráfica. O foco deve ser na lógica e nos testes. Tentem fazer um design que não misture código de apresentação (interface) com lógica.
Exercício 13 (Aula de 11 de Março): Fazer um robozinho usando o robocode e entregar por e-mail o código do robô e um texto explicando a estratégia utilizada pelo seu robô. Dêem uma olhada na API do robocode (http://robocode.sourceforge.net/docs/robocode/) pra explorarem estratégias legais.
Exercício 14 (Aula de 12 de Março): Criar uma classe ProdutoraDeMensagens, que é uma Thread que adiciona x vezes uma mensagem em uma lista de mensagens e vai dormir após cada adição (mensagens.wait(tempo)). Criar uma classe ConsumidoraDeMensagens, que também é uma Thread, e compartilha com a outra a mesma lista de mensagens. Essa thread vê se a lista tem alguma mensagem e se tiver, a imprime, retirando-a da lista e terminando sua execução. Caso contrário, ela espera até que alguma mensagem seja colocada na lista. Criar também um programa principal que cria uma thread produtora e 3 consumidoras e as inicia. Colocar as classes produzidas no formulário online: https://docs.google.com/spreadsheet/viewform?formkey=dF9uZkNzVEh4SWYzckVrdXhHLWU5bkE6MQ. Lembrar de usar blocos synchronized que utilizem como lock a lista de mensagens e de usar wait e notify/notifyAll para esquemas de espera e notificação.
Aulas:
29/10: Exercício de sondagem. Apresentação da disciplina.
30/10: Aula em laboratório para resolvermos juntos o exercício até a questão 3 quase toda. Cada um ficou de implementar em casa as classes do exercício. Cada um criou sua conta no github.
05/11: Revisão do exercício da aula passada. Utilização do github e gitshell. Demonstração da forma de publicar seus exercícios no github com a divulgação da solução do exercício.
06/11: Revisão de conceitos básicos da orientação a objetos (criação de classes, instâncias, objetos, métodos, atributos, interfaces, classes abstratas, sobrecarga, documentação com javadoc)
12/11: Acompanhamento dos exercícios até o 4 e das dúvidas relacionadas. Exceções em Java.
13/11: Exercício sobre exceções (Exercício 5). Revisão de POO (Herança, Polimorfismo, sobrescrita de métodos). Introdução à API de Java para lidar com arquivos (java.io).
19/11: Dúvidas sobre exercícios anteriores. Manipulação de arquivos em Java. Exercício 6 (feito com a turma, que ficou de fazê-lo novamente em casa). Exercício 7 (início)
20/11: Miniteste sobre exceções. Continuação da revisão de POO, introduzindo também o framework de coleções de Java (incluindo Map/HashMap).
26/11: Acompanhamento de exercícios anteriores. Exercício 8.
27/11: Resolução do Exercício 8 no quadro com os alunos. Revisão de Iterator, uso das interfaces Comparable e Collection, implementação de métodos toString, equals e compareTo.
03/12:Testes com JUnit
04/12: Testes com JUnit
10/12: Exercícios sobre o conteúdo visto até então.
11/12: Primeira Avaliação
17/12: Reposição da primeira avaliação
18/12: Entrega da modelagem do projeto e de seus requisitos
22/01: Introdução às regras básicas de Refatoramento e ao processo de desenvolvimento de software (fases de requisitos, análise, desenvolvimento, testes, entrega).
28/01: Desenvolvimento do projeto (classes principais e testes).
29/01: Regras básicas de design e refatoramento. Padrão Facade (Fachada).
04/02: Exercício sobre Façade com foco no projeto.
05/02: Regras básicas de design e refatoramento.
11 e 12/02: Não teremos aula. Carnaval
18/02: Enum, Annotations, Generics e Herança x Composição.
19/02: Entrega dos projetos. Padrões GRASP
25/02: Continuação dos Padrões GRASP (padrão controller). Introdução a Swing.
26/02:Segunda avaliação
04/03: Não houve aula.
05/03: Programação concorrente em Java: classe Thread e interface Runnable. Métodos Thread.sleep(intervalo) e join().
11/03: Programação concorrente em Java. Blocos e métodos sincronizados. Liveness: deadlocks, livelocks, starvation. Exercício com Robocode.
12/03: Parando e notificando threads com wait e notify/notifyAll.
18/03: Apresentação dos Projetos
19/03: Apresentação dos Projetos
25/03: Terceiro Estágio.
26/03: Reposição
02/04: Prova Final