introdução a linguagem java-2003

  • 2,302 views
Uploaded on

 

More in: Technology , Travel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
2,302
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

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