Difference between revisions of "Herança e Composição/Definição Simples de Superclasse e Subclasse"

From Wiki**3

< Herança e Composição
 
Line 1: Line 1:
 +
{{TOCright}}
 
== Classe <code>SuperClasse</code> ==
 
== Classe <code>SuperClasse</code> ==
  
Line 58: Line 59:
  
 
== Classe <code>SubClasse</code> ==
 
== Classe <code>SubClasse</code> ==
 +
 +
A classe <tt></tt> corresponde a uma especialização da superclasse e redefine o método <tt>getX</tt>.
 +
 +
Note-se a sintaxe de invocação do construtor da superclasse, utilizando a palavra chave <tt>super</tt>: esta chamada é necessária, pois a não existência de um construtor sem argumentos na superclasse faz com que o comportamento por omissão do construtor da subclasse (na iniciação da porção do objecto correspondente à superclasse) não possa ser executado.
 +
 +
  public class SubClasse extends SuperClasse {
 +
 
 +
    SubClasse() {
 +
      super(4);
 +
      System.out.println("-- calling SubClasse.SubClasse()");
 +
    }
 +
 
 +
    protected int getX() {
 +
      int result = 1 + super.getX();
 +
      System.out.println("-- calling SubClasse.getX() returns " + result);
 +
      return result;
 +
    }
 +
 
 +
  }

Revision as of 18:20, 30 September 2006

Classe SuperClasse

A classe SuperClasse representa o conceito mais geral, que irá ser posteriormente especializado.

São apresentados dois cenários para ilustrar o comportamento na iniciação de um atributo declarado final.

Cenário A

No cenário A, o atributo é declarado, mas não tem um iniciador por omissão explícito. Por isso, é possível definir no construtor o seu valor.

 public class SuperClasse {
   private         int _a = 78;
   protected final int _x;         // cenário A
 
   SuperClasse(int x) {
     System.out.println("-- calling SuperClasse.SuperClasse(" + x + ")");
     _a = (int)(100*Math.random());
     _x = x;  // ok:   cenário A
   }
 
   final int getA() {
     System.out.println("-- calling SuperClasse.getA() returns " + _a);
     return _a;
   }
 
   protected int getX() {
     System.out.println("-- calling SuperClasse.getX() returns " + _x);
     return _x;
   }
 
 }

Cenário B

No cenário A, o atributo é declarado, mas já tem um iniciador por omissão explícito. Por isso, já não é possível definir no construtor o seu valor.

 public class SuperClasse {
   private         int _a = 78;
   protected final int _x = 93;    // iniciação
 
   SuperClasse(int x) {
     System.out.println("-- calling SuperClasse.SuperClasse(" + x + ")");
     _a = (int)(100*Math.random());
     //_x = x;  // erro: já está iniciada
   }
 
   final int getA() {
     System.out.println("-- calling SuperClasse.getA() returns " + _a);
     return _a;
   }
 
   protected int getX() {
     System.out.println("-- calling SuperClasse.getX() returns " + _x);
     return _x;
   }
 
 }

Classe SubClasse

A classe corresponde a uma especialização da superclasse e redefine o método getX.

Note-se a sintaxe de invocação do construtor da superclasse, utilizando a palavra chave super: esta chamada é necessária, pois a não existência de um construtor sem argumentos na superclasse faz com que o comportamento por omissão do construtor da subclasse (na iniciação da porção do objecto correspondente à superclasse) não possa ser executado.

 public class SubClasse extends SuperClasse {
 
   SubClasse() {
     super(4);
     System.out.println("-- calling SubClasse.SubClasse()");
   }
 
   protected int getX() {
     int result = 1 + super.getX();
     System.out.println("-- calling SubClasse.getX() returns " + result);
     return result;
   }
 
 }