introdução a linguagem java-2003

INTRODUÇÃO À LINGUAGEM JAVA Verão/2003 Aula 03 Estruturação de classes em Java 08.01.2003 Prof. Luciano Silva e-mail: lucianos@ime.usp.br

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

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

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.

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.

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

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

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

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

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?

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.

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.

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

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;

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.

Exemplo de atributos e métodos estáticos class 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; } }

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

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.

Exemplo para implementação de herança Funcionario nome RG salario aumenta(valor) pagamento Chefe contas gastos_extra adicional_chefia pagamento

Implementação da superclasse Funcionario class 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); } }

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); } }

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()); } }

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.

Implementação da subclasse Chefe com super 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 de pagamento() da superclasse recebe=recebe+contas+gastos_extra+adicional_chefia; return(recebe); } }

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 )

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

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.

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

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.

Exemplo para polimorfismo universal de inclusão Funcionario nome RG salario aumenta(valor) pagamento Chefe contas gastos_extra adicional_chefia pagamento

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); } }

Chamadas na superclasse e subclasse class 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 } }

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

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.

Exemplo de polimorfismo ad-hoc por coersão class 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 } }

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.

Exemplo de polimorfismo ad-hoc por sobrecarga class 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); } }

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

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.

Exemplo de uso de final class 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. ... }

introdução a linguagem java-2003

Mais conteúdo relacionado

Destaque (19)

Semelhante a introdução a linguagem java-2003 (20)

Mais de elliando dias (20)

Último (7)

introdução a linguagem java-2003