DOWNLOAD SEMINÁRIO

Para baixar o seminário no formato ppt clique no link abaixo:

http://www.miltoncps.110mb.com/Java.ppt

Polimorfismo

Existem várias classificações e tipos de polimorfismo. C++ apresenta vários tipos de
polimorfismo . Java apresenta um conjunto mais reduzido evitando principalmente polimorfismos ad-hoc.


REDEFINIÇÃO DE MÉTODOS PARA UMA CLASSE HERDEIRA

Trata-se de um polimorfismo, pode serclassificado como polimorfismo de inclusão. Um método é uma redefinição de um método herdado, quando está definido em uma classe construída através de herança e possui o mesmo nome, valor de retorno e argumentos de um método herdado da classe pai. A assinatura do método tem que ser idêntica, ou seja, teremos redefinição quando uma classe filha fornece apenas uma nova implementação para o método herdado e não um novo método.
Se a classe filha fornecer um método de cabeçalho ou assinatura parecida com a do método
herdado (difere ou no número ou no tipo dos argumentos, ou então no tipo do valor de retorno)
então não se trata mais de redefinição, trata-se de uma sobrecarga, pois criou-se um novo método.
Uma chamada ao método herdado não mais é interceptada por esse novo método de mesmo nome.
O método tem o mesmo nome, mas é ligeiramente diferente na sua assinatura (o corpo ou bloco de código {} não importa), o que já implica que não proporciona o mesmo comportamento
(behaviour) do método da superclasse.

SOBRECARGA ( MÉTODOS E OPERADORES)

• SOBRECARGA DE MÉTODOS

Este tipo de polimorfismo permite a existência de vários métodos de mesmo nome, porém
com assinaturas levemente diferentes ou seja variando no número e tipo de argumentos e no valor de retorno. Ficaria a cargo do compilador escolher de acordo com as listas de argumentos os procedimentos ou métodos a serem executados.

• SOBRECARGA DE OPERADOR

Java não fornece recursos para sobrecarga de operador, o que é perfeitamente condizente
com a filosofia da linguagem. Seus criadores que acreditavam que a linguagem deveria ser
pequena, simples, segura de se programar e de se usar (simple, small, safe and secure).
A ausência de sobrecarga de operadores pode ser contornada definindo apropriadamente
classes e métodos.


CLASSES ABSTRATAS


Classes abstratas são poderosas, elas permitem: criação de listas heterogêneas, ocorrência de
“dynamic binding” e maior clareza no projeto de sistemas. Os packages que vem com a linguagem estão repletos de exemplos de classes abstratas.
Métodos abstratos, obrigatoriamente pertencem a classes abstratas, e são métodos desprovidos
de implementação, são apenas definições que serão aproveitadas por outras classes da hierarquia.

Exemplo de classe abstrata:


abstract class Forma {

protected float x,y; //visivel hierarquia abaixo

public void move(float dx,float dy)
{
this.x+=dx; this.y+=dy;
}

abstract public void mostra( ); //metodo abstrato
}



//Classe ponto

class Ponto extends Forma {

public Ponto(float ax,float ay) //omita o valor de retorno!

//garante o estado do objeto
{
this.x=ax; this.y=ay;
}
//move nao precisa ser redefinido
public void mostra()
{
System.out.println("("+this.x+","+this.y+")");
}
}



Classes abstratas X Interfaces:

Você deve estar achando que classes abstratas e interfaces são conceitos parecidos e que
podem ser usados com objetivos semelhantes. Cuidado! Uma classe pode estender uma única classe (que pode ser abstrata ou não), mas pode implementar várias interfaces. Além disso, interfaces não permitem declaração de atributos, enquanto que classes abstratas permitem. Interfaces estão mais ligadas a comportamento, enquanto que classes abstratas estão mais ligadas a implementação.

Herança

Existe uma visão um pouco tacanha de orientação a objetos como uma simples maneira de
organizar melhor o seu código. Essa visão é facilmente desmentida pelos conceitos de
encapsulamento, interfaces, packages e outros já apresentados. Neste tópico apresentaremos o
conceito de herança, fundamental para programação orientada a objetos e um dos fatores de sucesso desta como muito mais que uma simples maneira de organizar melhor seu código.
Um dos aspectos que distinguem objetos de procedimentos e funções é que o tempo de
existência de um objeto pode ser maior do que o do objeto que o criou. Isto permite que em
sistemas distribuídos objetos criados em um local, sejam passados através da rede para outro local e armazenados lá quem sabe na memória ou mesmo em um banco de dados.


REDEFINIÇÃO DE MÉTODOS HERDADOS

Uma classe filha pode fornecer uma outra implementação para um método herdado,caracterizando uma redefinição “overriding” de método. Importante: o método deve ter a mesma assinatura (nome, argumentos e valor de retorno), senão não se trata de uma redefinição e sim sobrecarga “overloading”. A redefinição garante que o método terá o mesmo comportamento que o anterior isto faz com que as subclasses possam ser atribuídas a variáveis da superclasse pois atendem a todas as operações desta.


INTERFACES, UMA ALTERNATIVA PARA HERANÇA MÚLTIPLA


Herança múltipla é a capacidade de uma classe herdar de duas ou mais classes, por exemplo a classe radio-relógio herdar da classe rádio e da classe relógio.

Java por motivos de simplicidade, abandona a idéia de herança múltipla, cedendo lugar ao
uso de interfaces. Interfaces são um conjunto de métodos e constantes (não contém atributos). Os métodos definidos na interface são “ocos” ou desprovidos de implementação. Classes podem dizer que implementam uma interface, estabelecendo um compromisso, uma espécie de contrato, com seus clientes no que se refere a prover uma implementação para cada método da referida interface.Ao cliente, pode ser dada a definição da interface, ele acaba não sabendo o que a classe é, mas sabe o que faz. Quem programa em Objective C, deve ver as interfaces como algo semelhante ao conceito de protocolos.

Encapsulamento

Encapsulamento, “data hiding” é um conceito bastante importante em orientação a objetos.
Neste tópico vamos falar das maneiras de restringir o acesso as declarações de uma classe e a
própria classe, isto é feito através do uso das palavras reservadas public, private e protected
que são qualificadores.
Alguém pode estar se perguntando o porquê de se restringir o acesso a certas partes de uma
classe. A idéia é simples, devemos fornecer ao usuário, cliente de uma classe, o necessário e
somente o necessário para que ele tire proveito da funcionalidade desta classe. Os detalhes devem ser omitidos, somente a lista de operações a qual uma classe deve atender fica visíve
Os benefícios são muitos: clareza do código, minimização de erros, facilidade de extensão.
Talvez a facilidade de modificação seja o mais importante dos benefícios. Como a classe é
conhecida pela sua interface, é muito fácil mudar a representação interna sem que o cliente,
usuário, perceba a diferença Estaremos preocupados em separar design de implementação, Java é uma linguagem boa de se programar em termos de design e em termos de implementação.
Programar tendo em vista o design é também chamado de “programming in the large”,
enquanto que programar tendo em vista implementação, codificação é chamado e“programming in the small”. Alguns programadores experientes afirmam que Java se parece com C quando estamos preocupados com codificação, mas quando estamos preocupados com design, Java se assemelha a Smalltalk.
Com encapsulamento você será capaz de criar componentes de software reutilizáveis, seguros,
fáceis de modificar.


Mas então como controlar o acesso de atributos e métodos em uma classe? Simples, através
das palavras reservadas private, public e protected cujos significados quando qualificando
métodos e atributos (private e public podem também qualificar classes) são descritos abaixo:

public

Estes atributos e métodos são sempre acessíveis em todos os métodos de todas as classes. Este é o nível menos rígido de encapsulamento, que equivale a não encapsular.

private

Estes atributos e métodos são acessíveis somente nos métodos(todos) da própria classe. Este é o nível mais rígido de encapsulamento.

protected

Estes atributos e métodos são acessíveis nos métodos da própria classe e suas subclasses, o que será visto em Herança

Nada especificado, equivale “package”ou “friendly”

Estes atributos e métodos são acessíveis somente nos métodos das classes que pertencem ao “package” em que foram criados. Este modo de acesso é também chamado de “friendly”.

Efeito Colateral

Observe o exemplo:

//Classe ponto

class Ponto {
public float x,y;
.
.
.
}

//Classe principal

class Principal {
public static void main(String args[]) {

//preparacao das variaveis copia de objetos

Ponto pOriginal,pAlias,pCopia;
pOriginal=new Ponto((float)0.0,0.0f);
pAlias=pOriginal; //copiando atraves de atribuicao
pCopia=new Ponto(pOriginal.x,pOriginal.y); //copiando atributo por atributo
}


Preparacao das variaveis, copia de objetos:

pAlias e uma referência para o mesmo local de memória que pOriginal, por este motivo
quando pAlias é alterado, pOriginal se altera por “efeito colateral”, eles compartilham o mesmo
objeto pois a atribuição pAlias=pOriginal, copia o endereço de pOriginal.
Já pCopia, é o resultado de uma nova alocação de memória, portanto um novo endereço, um
objeto independente dos outros.

Comparacao de objetos:

pOriginal==pAlias e outras comparações equivalentes têm o significado de comparação do
endereço de memória e não do conteúdo.

pOriginal.x==pCopia.x tem o significado de comparação do valor desses atributos, assim
como uma comparação entre inteiros. Se esses atributos por sua vez fossem objetos, esta operação teria o significado de comparação entre endereços de memória dos objetos.

Ponteiros

Ponteiros não existem nessa linguagem. Existem estudos que afirmam que erros com ponteiros são um dos principais geradores de “bugs” em programas, além disso com todos os recursos que Java oferece não precisaremos deles.
Os programadores acostumados ao uso de ponteiros (e aos erros decorrentes desse uso),
acharão muito natural e segura a transição para Java onde passarão a usar principalmente vetores e classes. A estruturação de seu código deverá agora ser feita em um modelo que se baseia no uso de objetos (vetores e Strings também são objetos). Objetos superam a representatividade obtida com records, funções isoladas e ponteiros.
De certo modo você estará usando referências, mas de forma implícita. Por exemplo: objetos
são alocados dinamicamente com new, eles são referências ou ponteiros para posições na
memória, mas a linguagem mascara este fato por razões de segurança. Como objetos são ponteiros (só que transparentes para você), nos depararemos com o problema de reference aliasing quando discutirmos cópia de objetos com outros objetos como atributos.

Operadores bitwise

Os operadores bitwise são aqueles que alteram o valor das variáveis em operações lógicas diretamente no processador, tornando-as muito mais performáticas. Estas operações são geralmente chamadas de tratamento por bits pois são operações que comparam e modificam a variável bit por bit. São eles:
Op : Nome : Uso : Descrição
~ : Inversão : ~x : Inversão dos bits de x.
& : E lógico : x & y : AND bit a bit entre x e y.
| : OU lógico : x | y : OR bit a bit entre x e y.
^ : OU excl. lógico : x ^ y : XOR bit a bit entre x e y.
<< : Desloc. a esq. : x << y : Desloc. a dir os bits de x, y vezes.
>> : Desloc. a dir. : x >> y : Desloca a direita os bits de x, y vezes.
>>> : Desloc. a dir. : x >>> y : Preenche zero a esquerda de x, y vezes.