Notas - Conceitos de POO

Página 1

HERANÇA: é o mecanismo que permite basear uma nova classe (filha ou subclasse) na definição de uma previamente existente (mãe ou superclasse). Essa nova classe, herdará os métodos e atributos da anterior. É declarado da seguinte forma: public class <NomeClasse> extends <ClasseMae>{}.

POLIMORFISMO: Em termos de programação, muitas formas significa que um único nome pode representar um código diferente, selecionado por algum mecanismo automático. Isso permite que um único nome expresse muitos comportamentos diferentes.

OBJETO: é uma classe instanciada.

ENCAPSULAMENTO: Trata-se de esconder o funcionamento das classes da implementação.

É um: Quando usar? Faça o teste "é um": você diz a si mesmo, "um objeto A 'é um' B?"? Caso verdadeiro, a herança é válida.

TEM um: Descreve o relacionamento em que uma classe contém uma instância de outra classe. É utilizada através da COMPOSIÇÃO.

Especialização: É o processo de uma classe filha ser projetada em termos de como ela é diferente da classe mãe. Quando terminada, a definição da filha incluirá apenas os elementos que a tornam diferente da mãe.

Generalização: Quando a hierarquia de herança é percorrida para cima, você generaliza. quando é percorrida para baixo, você especializa.

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Classes Abstratas: Define uma classe com métodos sem implementação. Ela serve apenas para ser estendida, obrigando a filha a implementar os métodos.

Composição: Significa que uma classe é implementada usando variáveis internas que contém instâncias de outras classes.

Sobreposição ou sobrescrita: É o processo de uma filha pegar o método herdado e reescrevê-lo para alterar seu comportamento.

Sobrecarga: Permite que você use o mesmo nome de método para muitos métodos diferentes. Cada método difere apenas no número e no tipo de seus parâmetros.

Classes: define os atributos e comportamentos de um tipo de objeto. Molda o objeto e é utilizada para instanciar o

objeto.

Atributos: São as características de uma classe visíveis externamente. Pode conter variáveis ou retornar algum valor através de um método.

Métodos: Alteram o comportamento do objeto, através de uma mudança de estado ou mensagem.

Getters / Setters: Métodos específicos de acesso para obter e configurar uma variável de instancia. Utilizam a notação: public void set<VariableName>(<type> value) para configurar e public <type> get<Variablename>().

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Construtores: Método diferenciado, usado quando se quer obrigar ou possibilitar a passagem de argumentos na criação do objeto. A classe pode ter n construtores. o nome do construtor deve ser igual ao nome da classe.

Modificadores de Acesso:

Modificadores Gerais:

Protected: Visível apenas as classes do mesmo pacote.

Private: Visível apenas a própria classe.

Public: Visível a qualquer classe em qualquer pacote.

Abstract: Indica uma classe ou método abstrato. Classes Abstratas fornecem apenas modelos de comportamento (protótipos), mas não uma implementação concreta. Ela é fornecida pelas subclasses.

Final: Finaliza a implementação da classe, método ou atributo. Método ou atributo declarado como final não pode ser sobrescrito em classes derivadas e uma classe final não pode ser derivada. Essa é a maneira que definimos constantes em java.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Static: Cria um atributo da Classe e não das instancias. Métodos do tipo static não precisam de objetos para serem chamados.