|
|
| (10 revisões intermediárias por 2 usuários não estão sendo mostradas) |
| Linha 1: |
Linha 1: |
| =Plano de ensino=
| | '''Semestre''': 2º |
| == - IDENTIFICAÇÃO==
| | =Objetivo= |
| '''Curso''': Tecnologia em Análise e Desenvolvimento de Sistemas
| |
| | |
| '''Componente Curricular''': Orientação a Objetos I
| |
| | |
| '''Professor''': Humberto Martins Beneduzzi
| |
| | |
| '''Turma''': 01/2015
| |
| | |
| '''Período Letivo''': Segundo
| |
| | |
| '''Ano:''' 2015
| |
| | |
| '''Carga horária''': 60 | |
| | |
| '''Horário Semanal de Atendimento ao Estudante:''' Terça-feira, 18:00 – 19:00
| |
| | |
| == - EMENTA==
| |
| * O paradigma Orientado a Objetos.
| |
| * Conceitos fundamentais da Orientação a Objetos: Classe, Objeto, Atributo, Método, Encapsulamento, Associação (Agregação e Composição), Herança, Polimorfismo.
| |
| * Aplicação dos conceitos da Orientação a Objetos em uma linguagem de programação.
| |
| | |
| == - CONTEÚDO PROGRAMÁTICO==
| |
| | |
| * Introdução à Orientação a Objetos: Abstração, Classe, Objeto, Atributo, Método.
| |
| * Paralelos entre os paradigmas estruturado e orientado a objetos.
| |
| * Linguagens compiladas X linguagens interpretadas.
| |
| * Introdução à plataforma Java: Conceito de máquina virtual, principais versões do java (JSE, JEE, JME)
| |
| * Introdução à linguagem Java: conceitos, sintaxe e principais palavras-chave.
| |
| * Tipos de dados primitivos X classes.
| |
| * Construtores.
| |
| * Herança (Generalização e Especialização).
| |
| * Encapsulamento.
| |
| * Associação.
| |
| * Polimorfismo.
| |
| * Acesso a banco de dados através do java, utilizando o design pattern DAO.
| |
| | |
| == - OBJETIVOS DO COMPONENTE CURRICULAR==
| |
| Propiciar ao aluno a compreensão dos principais aspectos do paradigma de desenvolvimento de software orientado a objetos. Realizar a implementação destes conceitos em uma linguagem de programação. | | Propiciar ao aluno a compreensão dos principais aspectos do paradigma de desenvolvimento de software orientado a objetos. Realizar a implementação destes conceitos em uma linguagem de programação. |
| | =Ementa= |
| | O paradigma Orientado a Objetos. Conceitos fundamentais da Orientação a Objetos: Classe, Objeto, Atributo, Método, Encapsulamento, Associação (Agregação e Composição), Herança, Polimorfismo. Aplicação dos conceitos da Orientação a Objetos em uma linguagem de programação. |
|
| |
|
| == - PROCEDIMENTOS METODOLÓGICOS== | | =Planos de ensino= |
| ===Metodologia de ensino===
| | * [[Media:plano-ensino-oo1-2016.2.pdf|2016/2]] (Prof. Jésus Henrique Segantini) |
| * Aulas expositivas empregando quadro branco e projetor multimídia; | | * [[TADS:Orientação a Objetos I (2015-2)|2015/2]] (Prof. Humberto Martins Beneduzzi) |
| * Seminários para apresentação de trabalhos;
| | * [[TADS:Orientação a Objetos I (2014-2)|2014/2]] (Prof. Humberto Martins Beneduzzi) |
| * Trabalhos em grupo;
| |
| * Problematização.
| |
| | |
| ===Recursos e materiais===
| |
| * Demonstração (pratica realizada pelo professor);
| |
| * Laboratório (pratica realizada pelo aluno).
| |
| | |
| == - AVALIAÇÃO==
| |
| | |
| A avaliação será realizada seguindo as orientações da Portaria nº 120 de 6 de agosto de 2009, que estabelece os critérios de avaliação do processo de ensino e aprendizagem no IFPR.
| |
| | |
| O conceito do aluno será composto através de sua participação e aproveitamento nos seguintes quesitos:
| |
| * Trabalhos individuais e/ou grupais;
| |
| * Desenvolvimento de atividades e participação em sala de aula;
| |
| * Prova prática e/ou teórica.
| |
| | |
| == - REFERÊNCIAS BIBLIOGRÁFICAS==
| |
| ===REFERÊNCIAS BÁSICAS===
| |
| | |
| # Schildt, Herbert. Java para Iniciantes. 5ª ed., Bookman, 2013.
| |
| # Coelho, Alex. Java Com Orientação a Objetos. 1ª ed., Ciencia Moderna, 2012.
| |
| # Santos, Rafael. Introdução À Programação Orientada a Objetos Usando Java. 1ª ed., Campus, 2003.
| |
| # DEITEL, Paul J.; DEITEL, Harvey M. Java: como programar. 8ª ed., Prentice Hall, 2010.
| |
| # Cornell, Gary; Horstmann, Cay S. Core Java - Vol. 1 - Fundamentos - 8ª ed., Pearson Education, 2010.
| |
| | |
| ===REFERÊNCIAS COMPLEMENTARES===
| |
| | |
| # Araújo, Everton Coimbra. Orientação a Objetos com Java. 1ª ed., Visual Books, 2008.
| |
| # SINTES, Anthony. Aprenda Programação Orientada a Objetos em 21 Dias. 1ª ed., Makron Books, 2002.
| |
| # MCLAUGHLIN, B.; POLLISE, G.; WESTHEAD, D. Use a Cabeça! Análise e Projeto Orientado a Objeto. 1ª ed., Alta Books, 2007.
| |
| # Hunt, Andrew; Thomas, David. O Programador Pragmático. 1ª ed., Bookman, 2010.
| |
| # Sierra, Kathy, Bates, Bert. Use a Cabeça! Java. 2ª ed., Alta Books, 2007.
| |
| | |
| | |
| | |
| == - Materiais de Apoio==
| |
| * Documentação Oficial do java: http://docs.oracle.com/javase/7/docs/api/ | |
| * Apostila de Orientação a Objetos com Java: https://www.caelum.com.br/apostila-java-orientacao-objetos/
| |
| | |
| | |
| | |
| == Tópicos específicos ==
| |
| | |
| | |
| === Tratamento de Exceções ===
| |
| | |
| * Visão geral sobre pilha de execução no java
| |
| | |
| | |
| * Erros:
| |
| **de programação (sintaxe) -> aparece na compilação
| |
| **de lógica -> aparece nos testes
| |
| **de ambiente, de inconsistência de dados (ex: divisão por zero; objeto null, etc) -> tratamento de exceções
| |
| | |
| | |
| * Exceções
| |
| | |
| Eventos que podem fazer o programa falhar, geralmente relacionados ao ambiente ou a inconsistência de dados.
| |
| | |
| Ex:
| |
| | |
| - arquivo corrompido
| |
| | |
| - conexão de rede interrompida
| |
| | |
| - dados de um tipo diferente do esperado
| |
| | |
| - erro de divisão por zero
| |
| | |
| - objeto inexistente (null)
| |
| | |
| | |
| ** Tratamento de Exceções
| |
| - tentativa de contornar o problema (se possível, corrigir, senão informar o usuário "decentemente")
| |
| | |
| ** O java força o tratamento das situações mais propensas a erros.
| |
|
| |
| ** Uma exceção se propaga por toda a pilha de métodos até encontrar um bloco de tratamento ou chegar ao método main. Se não há tratamento, a mensagem do erro é exibida ao usuário e o programa encerra.
| |
| | |
| ** O trecho de código que pode gerar exceção deve estar em um bloco que possa tratar ou apenas lançar a exceção ao método chamador.
| |
| | |
| ** Para lançar uma exceção "para cima" (para o método chamador do método atual) usa-se a palavra-chave throws seguida do tipo da Exceção.
| |
| | |
| - Exception: Exceção mais genérica, todas descendem direta ou indiretamente dela.
| |
| | |
| - Existem diversas exceções mais específicas. Ex: IOException, FileNotFoundException, NullPointerException, ArrayIndexOutOfBoundException
| |
| | |
| | |
| *Para tratar exceções | |
| | |
| ** O trecho de código que pode gerar exceção vai dentro de um bloco try/catch, onde:
| |
| - try é onde se tenta executar o código
| |
| - catch serve para capturar e tratar um determinado tipo de exceção
| |
| | |
| ** Um bloco try pode ter vários blocos catch
| |
| | |
| ** Opcionalmente podemos usar o bloco finally: sempre é executado, independente de ocorrer ou não uma exceção. (ex: para encerrar uma conexão com o banco de dados ou fechar um arquivo aberto)
| |
| | |
| | |
| *Para criar um novo tipo de exceção
| |
| | |
| ** Criar herdando de um tipo existente
| |
| | |
| ** No construtor do novo tipo de exceção, chamar o método super passando a mensagem de erro a ser gerada pela exceção (será retornada pelo metodo getMessage())
| |
| | |
| ** O método onde ela poderá ser lançada deve ter um throws daquele tipo de exceção
| |
| | |
| ** Para lançar a exceção usar o throw new TipoExceção
| |
| | |
| === Atributos e Métodos Estáticos ===
| |
| | |
| *Os atributos e métodos de instância:
| |
| **Objetos (Instâncias de classe) são independentes entre si.
| |
| **Ex: Se tivermos 2 objetos da classe Cliente, o valor armazenado no atributo nome do primeiro objeto não tem relação nenhuma com o valor do atributo do segundo objeto.
| |
| **Por isso, para chamar um método ou acessar um atributo, é preciso criar um objeto daquela classe. Apenas quando criamos o objeto é que será reservada uma área de memória para armazenar aquelas informações.
| |
| | |
| | |
| *Atributos estáticos:
| |
| **Os atributos estáticos são atributos da classe, e não do objeto. Por isso eles são compartilhados entre todos os objetos dessa classe.
| |
| **Ex: Se a classe cliente possuir um atributo qtdeCliente, o valor atribuído neste atributpo será o mesmo em todos os objetos existentes na classe. Se no construtor da classe Cliente cololcarmos um qtdeCliente++, em qualquer objeto da classe cliente poderemos saber a quantidade de objetos criados a partir daquela classe.
| |
| | |
| | |
| *Métodos estáticos
| |
| **Como pertencem à classe, podem ser chamados sem a necessidade de criação de um objeto.
| |
| **No java, para declarar um atributo ou método como estático utiliza-se a palavra-chave static.
| |
| | |
| | |
| *Posso invocar um método estático em um contexto não estático. (Ex: String.valueof())
| |
| *Não posso invocar um método não estático em um contexto estático. (Ex: dentro do main, chamar calcular() sem criar um objeto da classe)
| |
| | |
| | |
| *Exemplos de métodos estáticos utilizados frequentemente:
| |
| **main()
| |
| **Integer.parseInt()
| |
| **String.valueof()
| |
| **System.out.println() // o out é um atributo público estático do tipo PrintStream, que por sua vez possui um método público estático println()
| |
| | |
| === Polimorfismo ===
| |
| | |
| *
| |
| | |
| === A palavra-chave final ===
| |
| | |
| *A palavra-chave final pode ser utilizada na definição de atributos ou de classes.
| |
| *Atributos final
| |
| **Atributos final são abritutos cujo valor não pode ser modificado, ou seja, é como se declara uma constante em java.
| |
| **Como o valor não pode ser modificado, o atributo final já deve ser declarado com seu valor.
| |
| **Ex: final float pi = 3.14f;
| |
| | |
| *Classes final
| |
| **Outro uso da palavra-chave final é na declaração de classes que não podem ser herdadas.
| |
| **Ex: final class ClasseFinal{
| |
| **Essa classe somente poderia ser instanciada diretamente para uso, jamais conseguiria ser herdada por outra classe.
| |
| | |
| === Interfaces ===
| |
| | |
| *Uma interface é uma definição de classe que possui apenas assinaturas de métodos, sem implementação.
| |
| *É usada para modelar um conjunto de comportamentos esperados. Ou seja, indica o que deve ser feito, sem dizer como deve ser feito. Assim, toda classe que se propuser a resolver um determinado problema terá que apresentar as mesmas formas de interação.
| |
| *É como um contrato entre as classes, pois sempre que uma classe implementa uma interface ela está comprometida a fornecer o comportamento publicado pela interface.
| |
| *A linguagem Java possui apenas herança simples, mas permite que uma classe implemente várias interfaces, o que pode ser uma alternativa ao uso da múltipla.
| |
| *Quando um comportamento é comum a várias subclasses, podemos implementar o método na classe pai e a classe filha que precisar de um comportamento diferente sobrescreve o método (polimorfismo). Quando existe um comportamento obrigatório mas variado, podemos criar uma interface e obrigamos cada classe a implementar o comportamento.
| |
| | |
| *Principais características das interfaces:
| |
| **Resolve (em parte) o problema da herança múltipla: Pode herdar uma classe e implementar a outra
| |
| **Interface: obriga a classe que a implementa a implementar todos os método declarados na interface
| |
| **Os métodos das interfaces possuem apenas assinatura
| |
| **Interface não pode ser instanciada
| |
| **Os atributos declarados em uma interface são automaticamente static e final, por isso devem ter valor definido no momento da declaração
| |
| **Os métodos de uma interface são automaticamente abstract e public
| |
| **Interfaces não podem ter construtores
| |
| | |
| | |
| | |
| [[Categoria:TADS]]
| |
