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: lucianos@ime.usp.br

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. ...}