Your SlideShare is downloading. ×
introdução a linguagem java-2003
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

introdução a linguagem java-2003

2,313
views

Published on

Published in: Technology, Travel

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
2,313
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
112
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide
  • Transcript

    • 1. 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
    • 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á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;
      • }
      • }
    • 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 nome RG salario aumenta(valor) pagamento Chefe contas gastos_extra adicional_chefia pagamento
    • 20. 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);
      • }
      • }
    • 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 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);
      • }
      • }
    • 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 nome RG salario aumenta(valor) pagamento Chefe contas gastos_extra adicional_chefia pagamento
    • 31. 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);
      • }
      • }
    • 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 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
      • }
      • }
    • 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ã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
      • }
      • }
    • 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 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);
      • }
      • }
    • 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 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.
      • ...
      • }