RESUMO UN4 - ORIENTAÇÃO A OBJETOS

Prévia do material em texto

UN 4.1 
O polimorfismo é geralmente aplicado quando múltiplas classes implementam a mesma interface. 
Cada classe implementa os métodos de maneira diferente. É a herança que herda os membros de 
outra classe. A classe que tem métodos abstratos deve, obrigatoriamente, ser uma classe abstrata. 
Quando uma subclasse apenas usa um método da superclasse, ele está simplesmente herdando 
esse membro. O fato de uma classe ter mais de um método sem retorno não caracteriza 
polimorfismo, o que, aliás, é algo extremamente normal em programação orientada a objetos. 
 
 
Diferentemente de uma classe, um tipo de interface não fornece nenhuma implementação. A 
principal diferença entre eles está, respectivamente, na possibilidade de serem ou não 
instanciados. O polimorfismo pode ser implementado em conjunto a ambos. Uma classe que tem 
apenas atributos pode ser uma classe que apenas modela a criação de um objeto. Classes que não 
podem ser instanciadas geralmente são escritas como classes abstratas. Um tipo de interface não 
tem variáveis de instância, e os métodos de uma interface devem ser implementados pelas classes 
que os implementam. 
 
 
Ao realizarmos o processo polimórfico, precisamos programar no específico. Polimorfismo 
significa "muitas formas"; com isso, os métodos podem assumir ações diferentes de acordo com a 
especificação da classe que os está utilizando. Portanto, devemos alterar a implementação desses 
métodos. O polimorfismo permite escrevermos programas que processam objetos que 
compartilham a mesma superclasse. Os métodos com mesma assinatura podem ser herdados de 
uma superclasse ou de uma interface implementada pela classe em questão. Por trabalhar com 
muitas formas, o polimorfismo permite, inclusive, a implementação de um método. Somente o 
código cliente que instancia novos objetos precisa ser modificado para acomodar os novos tipos. 
 
 
Quando uma classe implementa uma interface, é como se ela assinasse um contrato que a obriga 
a utilizar os métodos existentes na interface. Esses métodos devem ser implementados pela 
classe, isto é, devem ser escritos de forma a atender à especificidade da classe. Uma classe 
implementa uma interface; o comportamento de herança acontece quando uma subclasse herda 
de uma superclasse. O polimorfismo altera a ação do método de acordo com a especificidade de 
cada classe. Para que haja um comportamento polimórfico, é necessário que a classe implemente 
os métodos da interface; entretanto, há a necessidade de utilizar todos os métodos da interface 
que foi implementada. 
 
 
Para implementarmos uma interface, devemos colocar a palavra-chave "interfaces" antes do nome 
da interface. E, para utilizarmos uma interface, devemos colocar a palavra-chave "implements", 
não "extends". Assim, o código 4 deveria trazer a palavra-chave "extends". Para criarmos uma 
classe abstrata, é necessário utilizar as palavras-chave "abstract" e "class". Quando a classe 
implementa a interface de acordo com a especificação necessária para ela, não é polimorfismo. A 
falta de um chave representa um erro de compilação. 
================================================================= 
UN 4.2 
Ocorre a sobrecarga de métodos quando um ou mais métodos da mesma classe têm o mesmo 
nome, mas um conjunto de parâmetros diferente. A sobrecarga permite que métodos diferentes 
sejam renomeados igualmente, mas utilizem assinaturas diferenciadas pelos parâmetros de 
entrada, saída ou ambos. 
Quando um método é declarado com void, significa que não terá retorno. Quando se declara um 
tipo de dado no método, é informando que ele terá um retorno daquele tipo. Quando um método 
é declarado com a palavra abstract, está-se referindo a um método abstrato. A sobrescrita ocorre 
quando um ou mais métodos têm a mesma assinatura, mas implementações específicas de acordo 
com a classe a que pertencem. 
 
 
O nome e o conjunto de parâmetros do método são sua assinatura. Quando se coloca a palavra-
chave public na declaração do método, está sendo informado que ele é público, isto é, será visível 
para qualquer classe da aplicação. 
Ao declarar variáveis e tipos nos argumentos do método, está sendo especificado que ele 
receberá argumentos. A declaração do método tem o nome de cabeçalho do método, consistindo 
em modificador, tipo, nome e parâmetros (menos o corpo do método). O conjunto de parâmetros 
do método faz parte da assinatura, mas é necessário acrescentar o nome do método. 
 
 
 
"Polimorfismo" deriva do grego e significa "muitas formas". Em orientação a objeto, refere-se à 
utilização do mesmo método de formas diferentes, de acordo com a especificidade de cada classe. 
Herança é a técnica na qual subclasses herdam membros da superclasse. Quando uma classe 
implementa uma interface, ela deverá, obrigatoriamente, utilizar os métodos dessa interface, isto 
é, como um contrato de comprometimento. Sobrecarga é quando se utiliza o método com o 
mesmo nome, mas alterando seu conjunto de parâmetros. Os métodos set e get são métodos de 
acesso. 
 
 
Polimorfismo é o uso do mesmo método de forma diferente, dependendo da especificação de 
cada classe. Quando os métodos da mesma classe têm nomes iguais e conjuntos de parâmetros 
diferentes, ocorre a sobrecarga. Na sobrecarga, os métodos têm um conjunto de argumentos 
diferentes; logo, sua implementação também será diferente. Quando os métodos têm a mesma 
assinatura, ocorre a sobrescrita (e não sobrecarga) de métodos. 
======================================================================== 
 
4.3 
Para criarmos encapsulamento, uma das condições é termos os atributos da classe declarados 
com o modificador de acesso private. Para deixarmos os membros da classe com visibilidade 
pública, utilizamos o modificador de acesso public em sua declaração. O modificador de acesso 
protected é utilizado para deixar os membros visíveis às subclasses em uma estrutura de herança. 
O uso do "final" serve para darmos imutabilidade. Podemos utilizar a palavra-chave "final" em 
classes e em mais de um de seus membros. 
 
 
A palavra-chave "final" pode ser usada em diferentes tipos de dados, como Integer, Double e 
Math, não somente no Integer. Uma constante é um atributo imutável, isto é, recebe um valor que 
não será modificado na aplicação. Com isso, faz-se necessário o uso da palavra "final" na 
declaração desse atributo. Para declararmos atributos estáticos, devemos utilizar a palavra-chave 
"static", que pode também ser combinada com a palavra-chave "final". Valores de ponto flutuante 
são números com casas decimais e, com isso, um tipo de dado. O atributo que receberá um dado 
decimal receberá o nome do tipo de acordo com a linguagem utilizada. Em Java, esses tipos 
podem ser Float e Double. O próprio compilador informará um erro quando fizer a leitura e 
verificar que há dois ou mais atributos com o mesmo nome. Caso esteja usando uma IDE, a 
ferramenta acusa na hora de escrever o código. 
 
 
Com o uso da palavra-chave "final", é fácil impedir que um método seja sobreposto, e não o 
contrário. Para o método não ser visível a outras classes, é necessário utilizarmos o modificador 
de acesso Private. Todo método sem retorno é declarado com a palavra-chave "Void". A palavra-
chave "final" pode ser usada em qualquer método seguido de um corpo, inclusive para impedir 
que seja herdado por outras classes.