Download - introdução a linguagem java-2003
1
INTRODUÇÃO À LINGUAGEM INTRODUÇÃO À LINGUAGEM JAVAJAVA
Verão/2003Verão/2003
Aula 03
Estruturação de classes em Java08.01.2003
Prof. Luciano Silva
e-mail: [email protected]
2
Tópicos da Aula 03
Estrutura geral de uma classe Construtores Garbage collection Operador de autoreferência this Atributos e métodos estáticos Implementação de herança Operador super Polimorfismo Modificador final
3
Estrutura geral de uma classe
class < nome da classe > extends < nome da super classe > implements interface1,...,interfaceN{ < tipo1 > atributo1; < tipo2 > atributo 2, atributo 3; ... construtores ... void método1(){...} void método2(<parâmetros>){...} < tipo > método3(){...} < tipo > método4(<parâmetros>){...}}
4
Instanciação de classes
Instanciação uma operação que permite evidenciar elementos (objetos) de uma classe.
Instanciação é uma operação na classe, não uma operação da instância da classe (objeto). Por convenção em Java, a operação new cria instâncias de uma classe, responsável pela alocação dos objetos, mas não pela inicialização dos atributos.
5
Construtores
Como um método de classe não pode acessar diretamente os atributos na nova instância, um método de instância(construtor) precisa ser escrito para inicializar os atributos.
Em Java, o nome do construtor é o mesmo nome da classe. Numa mesma classe, podem existir construtores sobrecarregados. O nome do construtor(e possíveis parâmetros) aparece junto com a operação new.
6
Exemplo de construtor
class Funcionario{ String nome,RG; float salario;
Funcionario(String nomef,String ident,float sal){ nome=nomef; RG=ident; salario=sal; } ...}class admissao{ public static void main(String args[]){ Funcionario ze=new Funcionario(“Zé”,”15.000”,150); ... }}
7
Construtores implícitos
class Funcionario{ String nome,RG; float salario;
void admite(String nomef,String ident,float sal){ nome=nomef; RG=ident; salario=sal; }...}class admissao{ public static void main(String args[]){ Funcionario ze=new Funcionario(); ze.admite(“Zé”,”15.000”,150). ... }}
8
Construtores sobrecarregados(I)
class Funcionario{ String nome,RG; float salario; Funcionario(){ nome=“ “; RG=“ “; salario=0.0; }
Funcionario(String nomef,String ident,float sal){ nome=nomef; RG=ident; salario=sal; } void admite(String nomef,String ident,float sal){...}...}
9
Construtores sobrecarregados(II)
Usando a classe anterior, poderíamos inicializar as instâncias de dois modos:
class admissão{ public static void main(String args[]){ Funcionario ze=new Funcionario(); Funcionario maria=new Funcionario(“Maria”,”0”,300); ze.admite(“Zé”,”15.000”,150); .... }}
10
Destrutores
Java não tem destrutores explícitos. Por exemplo, considere-se a seguinte mudança de referência:
class admissão{ public static void main(String args[]){ Funcionario ze=new Funcionario(); ze.admite(“Zé”,”15.000”,150); .... ze=new Funcionario(“Zé maria”,”15.001”,200); }}
O que acontece com a primeira instância, alocada, porém não mais referenciada pela variável ze?
11
Garbage collection
De tempos em tempos, o interpretador java dispara um processo de recuperação de áreas de memória alocadas, porém não mais referenciadas ( processo de garbage collection (“coleta de lixo”)).
Isto, eventualmente, pode afetar o desempenho da aplicação.
12
Operador de autoreferência this
this é um “apontador” para o objeto em questão. Usando este apontador, um método pode acessar todas os atributos das classe a que pertence.
Ele é criado automaticamente quando um objeto chama um método e “aponta”para o próprio objeto que chamou o método.
13
Exemplo de uso do this
class Funcionario{ String nome,RG; float salario; Funcionario(String nome,String RG,float salario){ this.nome=nome; // Acesso aos atributos this.RG=RG; this.salario=salario; } Funcionario(){ this(“ “,” “,0.0); // Construtor que chama construtor } ...}
14
Atributos estáticos
Um atributo com o modificador static tem o seu valor compartilhado por todos os objetos da classe, ou seja, só haverá uma cópia dele para todos os objetos da classe.
Por exemplo:
static float valor_dolar;
15
Métodos estáticos
Um método estático é um método que pode ser invocado, mesmo que não haja nenhuma instância da classe, isto é, pode ser referenciado independentemente de qualquer objeto.
Por exemplo: static void cambio(float valor){...}Como independe da instância, não tem
autoreferência ( operador this ). Métodos estáticos podem referenciar somente atributos estáticos.
16
Exemplo de atributos e métodos estáticosclass produtoexportacao{
String nome;float preco_venda,preco_compra;static float valor_dolar;
produtoexportacao(String nome,float precov,float precoc){this.nome=nome;this.preco_venda=precov;this.preco_compra=precoc;
}...static void cambio(float valor){
valor_dolar=valor;}
}
17
Exemplo de atributos e métodos estáticos(continuação)class comercio_exterior{
public static void main(String args[]){
float cotacao;
cotacao=1.50;
produtoexportacao.cambio(cotacao);// Chamada de método estático
// sem instanciação
}
}
18
Herança
Herança é um relacionamento do tipo generalização/ especialização, onde uma classe pode ser derivada( subclasse) de outra mais geral (superclasse), absorvendo todas as características fundamentais e adicionando outras novas características, de tal modo a torná-la mais especializada.
19
Exemplo para implementação de herança
Funcionario
nomeRGsalario
aumenta(valor)pagamento
Chefecontasgastos_extraadicional_chefia
pagamento
20
Implementação da superclasse Funcionarioclass Funcionario{ String nome,RG; float salario;
Funcionario(String nomef,String ident,float sal){ nome=nomef; RG=ident; salario=sal; } void aumenta(float pouco){ salario=salario+pouco; } float pagamento(){ return (salario); }}
21
Implementação da subclasse Chefe
class Chefe extends Funcionario{ float contas, gastos_extra,adicional_chefia;
Chefe(String nomef,String RG, float sal, float contas, float gastos_extra, float adicional){ super(nomef,RG,sal); // Construtor da superclasse (Funcionario) this.contas=contas; this.gastos_extra=gastos_extra; this.adicional_chefia=adicional; } float pagamento(){ float recebe; recebe=this.salario; recebe=recebe+contas+gastos_extra+adicional_chefia; return(recebe); }}
22
Instanciação da subclasse
class ganhando{
public static void main(String args[]){Chefe joao=new Chefe(“João”,”320”,11150,1250,680, 5000);
joao.aumenta(300);
System.out.println(“João ganha”+joao.pagamento());
}
}
23
Operador de referência super
super é um operador para acessar atributos e métodos das superclasses, a partir das subclasses.
Este operador deve ser usado com bastante cuidado, principalmente na presença de modificadores de acesso.
24
Implementação da subclasse Chefe com superclass Chefe extends Funcionario{ float contas, gastos_extra,adicional_chefia;
Chefe(String nomef,String RG, float sal, float contas, float gastos_extra, float adicional){ super(nomef,RG,sal); // Construtor da superclasse (Funcionario) this.contas=contas; this.gastos_extra=gastos_extra; this.adicional_chefia=adicional; } float pagamento(){ float recebe; recebe=super.pagamento(); // Chamada de pagamento() da superclasse recebe=recebe+contas+gastos_extra+adicional_chefia; return(recebe); }}
25
POLIMORFISMO
Habilidade de uma ou mais classes responder a uma mesma mensagem de forma diferente.
Polimorfismo
Universal Ad-Hoc
Paramétrico Inclusão Sobrecarga Coerção ( Taxonomia de Cardelli e Wegner )
26
POLIMORFISMO UNIVERSAL
Mecanismo de trabalho com um número infinito de tipos.
Pode ser de dois tipos: paramétrico ( Ex.: templates do C++) de inclusão
27
Polimorfismo universal paramétrico
No polimorfismo paramétrico, um único método é codificado, e ele trabalhará uniformemente num intervalo de tipos.
Java não implementa polimorfismo universal paramétrico.
28
Exemplo de polimorfismo universal paramétrico ( em C++)template <class T> // Tipo T class Vetor{ T *dados; // Elementos do vetor int tamanho; // Tamanho do vetor
public: Vector(int); // Construtor ~Vector() {delete [] dados;} // Destrutor T& operator[](int i) { return dados[i];} // Retorna o elemento da posição i };
template <class T> Vetor<T>::Vetor(int n){ dados=new T[n]; tamanho=n;}main(){ Vetor<int> x(5); // Gera um vetor para armazenar 5 números inteiros ...}
29
Polimorfismo universal de inclusão
O polimorfismo de inclusão está relacionado com a noção de supertipo e subtipo. Um subtipo pode ser usado no contexto do supertipo.
Em orientação a objetos, isto está relacionado com a noção de subclasse e superclasse. Isto significa que o tratamento da mensagem dependerá do contexto da classe.
30
Exemplo para polimorfismo universal de inclusão
Funcionario
nomeRGsalario
aumenta(valor)pagamento
Chefecontasgastos_extraadicional_chefia
pagamento
31
Implementação da superclasse Funcionarioclass Funcionario{ String nome,RG; float salario;
Funcionario(String nomef,String ident,float sal){ nome=nomef; RG=ident; salario=sal; } void aumenta(float pouco){ salario=salario+pouco; } float pagamento(){ return (salario); }}
32
Implementação da subclasse Chefe
class Chefe extends Funcionario{ float contas, gastos_extra,adicional_chefia;
Chefe(String nomef,String RG, float sal, float contas, float gastos_extra, float adicional){ super(nomef,RG,sal); // Construtor da superclasse (Funcionario) this.contas=contas; this.gastos_extra=gastos_extra; this.adicional_chefia=adicional; } float pagamento(){ float recebe; recebe=super.pagamento(); // Chamada no contexto da superclasse recebe=recebe+contas+gastos_extra+adicional_chefia; return(recebe); }}
33
Chamadas na superclasse e subclasseclass ganhando{
public static void main(String args[]){Chefe joao=new Chefe(“João”,”320”,11150,1250,680, 5000);Funcionario maria=new Funcionario(“Maria”,”16.000”,2000);System.out.println(“João ganha”+joao.pagamento() );
Chamada no contexto da subclasse
System.out.println(“Maria ganha”+maria.pagamento() );
Chamada no contexto da superclasse
}}
34
POLIMORFISMO ad-hoc
Mecanismo de trabalho com um número finito de tipos.
O polimorfismo ad-hoc pode ser de dois tipos: por coerção por sobrecarga
35
POLIMORFISMO ad-hoc POR COERÇÃO
Meio de contornar a rigidez de tipos monomórficos.
A linguagem dá suporte à coerção através de um mapeamento interno entre tipos. O tipo que está sendo mapeado é chamado coargido.
36
Exemplo de polimorfismo ad-hoc por coersãoclass numero{ float num;
numero(float num){ // Construtor this.num=num; } void soma(float num){ this.num+=num; }}class teste{ public static void main(String args[]){ numero n=new numero(1.3); int valor=5; n.soma(valor); // valor é coargido de int para float }}
37
POLIMORFISMO ad-hoc POR SOBRECARGA
Permite que um nome de método seja usado mais do que uma vez com diferentes quantidades ou tipos de parâmetros.
A seleção do método adequado é feita com base em comparação dos tipos ou quantidade dos parâmetros.
38
Exemplo de polimorfismo ad-hoc por sobrecargaclass complexo{ // Números da forma a+bi float real,imagin;
complexo(float r,float i){ real=r; imagin=i; }
complexo soma(float r){ // Soma r na parte real e devolve o complexo resultante complexo s=new complexo(real+r,imagin); return(s); } complexo soma(float r,float i){ // Soma r na parte real e i na parte imaginária e devolve o resultado complexo s=new complexo(real+r,imagin+i); return(s); }}
39
Exemplo de polimorfismo ad-hoc por sobrecarga(continuação)
class teste{
public static void main(String args[]){
complexo num=new complexo(1,1); // Cria 1+i
complexo num2=num.soma(1); // Cria 2+i
complexo num3=num.soma(1,1); // Cria 2+2i
}
}
40
Modificador final
O modificador final tem comportamentos diferentes, dependendo do local onde é aplicado:
atributo: uma vez que é inicializado, não pode mais sofrer alteração (~constante).
método: nas classes descendentes não pode mais haver polimorfismo com o método.
classes: não podem mais ser estendidas.
41
Exemplo de uso de finalclass classe1{ final double pi=3.1415926535; // Inicialização de pi ( funciona como constante )
final void calcula(){ pi=2.718; // ERRO DE COMPILAÇÃO! pi já foi inicializado! ... }}
final class classe2 extends classe1{ ... void calcula(){...}; //ERRO! calcula() é final na superclasse.}class classe3 extends classe2{ // ERRO! classe2 é final. ...}