Construção, Iniciação e Destruição de Objectos/Construção de Objectos em Java: Difference between revisions

From Wiki**3

< Construção, Iniciação e Destruição de Objectos
 
Line 1: Line 1:
{{TOCright}}
#REDIRECT [[ist:Construção, Iniciação e Destruição de Objectos/Construção de Objectos em Java]]
A construção de objectos em Java segue a [[Construção, Iniciação e Destruição de Objectos|modalidade genérica da iniciação de objectos]], i.e., primeiro iniciam-se os sub-objectos correspondentes a definições da superclasse e só depois os próprios. Este processo é recursivo, o que significa que a superclasse mais antiga na hierarquia é a que inicia primeiro, sendo seguida pela classe logo abaixo, etc., até chegar à classe cuja instância está a ser criada.
 
Como já se referiu, a linguagem Java procura esconder do programador pormenores como as especificadades de reserva de memória. No entanto, o programador ainda fica com algumas responsabilidades, nomeadamente na definição e chamadas dos construtores.
Esta secção apresenta então os seguintes aspectos relacionados com a construção e iniciação de objectos em Java:
 
* Definição de construtores e ordem de invocação;
* Ordem de iniciação de atributos de classes (static) e de objectos.
 
== Definição de Construtores ==
 
== Usos Especiais de "this" e "super" ==
 
As palavras chave '''this''' e '''super''', além das utilizações como auto-referência, permitem a chamada explícita a construtores.
 
=== "this" ===
 
Num construtor, esta palavra reservada pode ser utilizada para chamar explicitamente outro construtor da mesma classe. Quando é utilizado desta forma, '''this''' pode ocorrer apenas uma vez e deve aparecer como a primeira instrução do construtor.
<java5>
class A {
  A(int i) { /* qualquer coisa */ }
  A(float f, int i) {
    this(i);              // chamada ao outro construtor
    /* resto do segundo construtor */
  }
}
</java5>
 
=== "super" ===
 
Num construtor, esta palavra reservada pode ser utilizada para chamar explicitamente outro construtor de uma superclasse. Quando é utilizado desta forma, '''super''' pode ocorrer apenas uma vez e deve aparecer como a primeira instrução do construtor.
 
Definição de uma classe '''A''':
<java5>
  class A {
    A(int i) { /* qualquer coisa */ }
    A(String etiqueta, int i) {
      this(i);              // chamada ao outro construtor
      /* resto do segundo construtor */
    }
  }
</java5>
 
Definição de uma classe '''B''' (subclasse de '''A'''):
<java5>
  class B extends A {
    B() {
      this("etiqueta arbitrária", 123);  // chama outro construtor de B
      /* uma iniciação qualquer */
    }
    B(String etiqueta, int quantidade) {
      super(etiqueta, quantidade);  // chama um construtor de A
      /* resto do construtor */
    }
  }
</java5>
 
== Ordem de Iniciação de Atributos ==
 
Quando um objecto é criado, várias acções são realizadas em sequência, algumas das quais apenas uma vez durante a vida de uma aplicação.
 
As seguintes acções são executadas apenas uma vez:
* Carregamento da classe pela máquina virtual;
* Iniciação de variáveis "static";
* Execução sequencial de blocos anónimos "static".
 
As seguintes acções são executadas cada vez que um objecto é criado:
* Iniciação por omissão de atributos (não "static");
* Execução sequencial de blocos anónimos (não "static");
* Execução do constructor utilizado com o operador "new" (em classes não anónimas).
 
Os seguintes exemplos ilustram a ordem de iniciação.
 
=== Exemplo 1 ===
 
Neste exemplo a classe Numero não é carregada (o método "main" de Order1 não a usa). Assim, não há produção de caracteres para a saída.
 
<java5>
class Numero {
  int x;
  static int a = 7;
  {
    int b = 1;
    System.out.println("non-static block: a = " + a + " b = " + b);
  }
  static {
    int b = 4;
    System.out.println("static block: a = " + a + " b = " + b);
  }
  {
    int b = 3;
    System.out.println("non-static block: a = " + a + " b = " + b + " x = " + x);
  }
}
</java5>
 
<java5>
public class Order1 {
  public static void main(String[] args) {}
}
</java5>
 
//output:
 
=== Exemplo 2 ===
 
Neste exemplo, a classe Order2 utiliza um atributo "static" da class Numero, provocando o carregamento da classe e a iniciação e execução de componentes "static".
 
<java5>
class Numero {
  int x;
  static int a = 7;
  {
    int b = 1;
    System.out.println("non-static block: a = " + a + " b = " + b);
  }
  static {
    int b = 4;
    System.out.println("static block: a = " + a + " b = " + b);
  }
  {
    int b = 3;
    System.out.println("non-static block: a = " + a + " b = " + b + " x = " + x);
  }
}
</java5>
 
<java5>
public class Order2 {
  public static void main(String[] args) {
    Numero.a = 2;
  }
}
</java5>
 
//output:
//static block: a = 7 b = 4
 
=== Exemplo 3 ===
 
Semelhante ao exemplo 2, mas utilizando o valor alterado.
 
<java5>
class Numero {
  int x;
  static int a = 7;
  {
    int b = 1;
    System.out.println("non-static block: a = " + a + " b = " + b);
  }
  static {
    int b = 4;
    System.out.println("static block: a = " + a + " b = " + b);
  }
  {
    int b = 3;
    System.out.println("non-static block: a = " + a + " b = " + b + " x = " + x);
  }
}
</java5>
 
<java5>
public class Order3 {
  public static void main(String[] args) {
    Numero.a = 2;
    System.out.println("Numero.a = " + Numero.a);
  }
}
</java5>
 
//output:
//static block: a = 7 b = 4
//Numero.a = 2
 
=== Exemplo 4 ===
 
É criada uma instância da classe Numero. Todas as fases descritas nos exemplos anteriores são executadas. Depois, são executados os blocos anónimos e o contrutor.
 
<java5>
class Numero {
  int x = 93;
  Numero() { System.out.println("Numero.Numero"); }
  static int a = 7;
  {
    int b = 1;
    System.out.println("non-static block: a = " + a + " b = " + b);
  }
  static {
    int b = 4;
    System.out.println("static block: a = " + a + " b = " + b);
  }
  {
    int b = 3;
    System.out.println("non-static block: a = " + a + " b = " + b + " x = " + x);
  }
}
</java5>
 
<java5>
public class Order4 {
  public static void main(String[] args) {
    Numero n = new Numero();
    System.out.println("Numero.a = " + Numero.a + " n.x = " + n.x);
  }
}
</java5>
 
//static block: a = 7 b = 4
//non-static block: a = 7 b = 1
//non-static block: a = 7 b = 3 x = 93
//Numero.Numero
//Numero.a = 7 n.x = 93
 
[[category:Ensino]]
[[category:PO]]
[[category:PO Exemplos]]
[[category:Java]]

Latest revision as of 16:37, 7 November 2018

Redirect to:

Retrieved from "https://www.hlt.inesc-id.pt/~david/wiki/pt/index.php?title=Construção,_Iniciação_e_Destruição_de_Objectos/Construção_de_Objectos_em_Java&oldid=10854"