Programação Orientada a Objetos (2012.1)

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