Pesquisa

Pesquisa personalizada
Apostila Java, parte 1 PDF Imprimir E-mail
Escrito por Alexander Kohler   
Seg, 04 de Maio de 2009 12:43

1.     Introdução_______________________________________________ 03

1.1. O que é JAVA? __________________________________________  03

1.2. O que é uma Applet _______________________________________  03

1.3. O que é uma Aplicação_____________________________________ 03

1.4. O que é o Appletviewer ____________________________________  03

1.5. O que é Applet no WWW__________________________________ 03

1.6. Criando uma Aplicação ____________________________________  04

1.7. Criando uma Applet ______________________________________  04

2. O Básico _________________________________________________  06

2.1 Variáveis e tipos de dados __________________________________  06

2.2. Comentários _____________________________________________  06

2.3. Caracteres Especiais ______________________________________  07

2.4. Expressões e Operadores ___________________________________  07

2.5. Comparações ____________________________________________  08

3. Arrays, Loops e Condicionais ________________________________  10

3.1. Arrays _________________________________________________  10

3.2. Condicionais ____________________________________________  11

3.3. Operador Condicional _____________________________________  12

3.4. Switch__________________________________________________ 12

3.5. Loop For _______________________________________________  13

3.6. Loop While _____________________________________________  13

3.7. Loop Do _______________________________________________  13

4. Criando Classes e Aplicações em Java__________________________ 14

4.1. Definindo Classes ________________________________________  14

4.2. Definindo Variáveis de Instância ____________________________  14

4.3. Constantes ______________________________________________  14

4.4. Variáveis de Classe _______________________________________  14

4.5. Definição de Métodos _____________________________________  15

4.6. A palavra chave this ______________________________________  15

4.7. Passando argumentos para Métodos __________________________  16

5. Mais sobre Métodos ________________________________________  17

5.1. Polimorfismo ou Sobrecarga_________________________________ 17

5.2. Métodos Construtores _____________________________________  19

5.3. Métodos Destrutores ______________________________________  21

6. Window Toolkit ___________________________________________  22

6.1. Eventos ________________________________________________  22

6.2. Componentes AWT _______________________________________  26

6.3. Gráficos ________________________________________________  33

7. Threads __________________________________________________  36

7.1. O que são threads? _______________________________________  36

7.2. Os estados de uma thread __________________________________  37

7.3. Threads em Applets _______________________________________  38

7.4. Herdando de Thread x Implementando Runnable _______________  39

8. Procure Saber Mais Sobre ____________________________________  41

Referências Bibliográficas _____________________________________  42


1. INTRODUÇÃO

1.1. O que é JAVA?

Java é uma linguagem de programação orientada a objetos desenvolvida pela Sun Microsystems. Modelada depois de C++, a linguagem Java foi projetada para ser pequena, simples e portável a todas as plataformas e sistemas operacionais, tanto o código fonte como os binários. Esta portabilidade é obtida pelo fato da linguagem ser interpretada, ou seja, o compilador gera um código independente de máquina chamado byte-code. No momento da execução este byte-code é interpretado por uma máquina virtual instalado na máquina. Para portar Java para uma arquitetura hadware/s específica, basta instalar a máquina virtual (interpretador). Além de ser integrada à Internet, Java também é uma excelente linguagem para desenvolvimento de aplicações em geral. Dá suporte ao desenvolvimento de software em larga escala.

1.2. O que é uma APPLET?

Applet é um programa especial escrito em Java adaptado para instalação e execução dentro de páginas HTML. Estas páginas podem então ser visualizadas num browser.

1.3. O que é uma APLICAÇÃO?

Aplicação é um programa mais geral escrito na linguagem Java. Não requer um browser para  sua execução. De fato, Java pode ser usada para criar todo tipo de aplicações que usualmente você implementa com outras linguagens mais convencionais.

1.4. O que é o APPLETVIEWER?

Quem criou o Java espera que todos os browsers algum dia suportem as applets, o que não acontece ainda. Para facilitar o desenvolvimento de aplicações, foi criado o Appletviewer que mostra apenas a área onde é executada applet. Depois de testar bem seu código com o Appletviewer, você deve então testá-lo com alguns browsers que suportem Java para ver o efeito final.

1.5. O que é APPLET no WWW

As applets são disparadas quando se carrega uma página HTML. A seguir há um exemplo de código HTML que dispara uma applet.

 

<HTML>

<HEAD>

<TITLE> Java </TITLE>

</HEAD>

<BODY>

<APPLET CODE=”nome.class” WIDTH=300 HEIGHT=100>

</APPLET>

</BODY>

</HTML>

 


1.6. Criando uma APLICAÇÃO

Para começar, criaremos uma simples aplicação em Java: a clássica “Hello World!”, o exemplo que todos os livros de linguagens usam.

1.6.1. O código fonte

Como todas as linguagens de programação, o código fonte será criado em um editor de texto ASCII puro. No Unix alguns exemplos são emacs, pico, vi e outros. No Windows, notepad ou dosedit também servem.

A seguir, o código da aplicação “Hello World!” (arquivo: HelloWorld.java):

 

class HelloWorld {

      public static void main (String args[]) {

            System.out.println(“Hello World!”);

      }

}

 

1.6.2. Compilando a aplicação

Para compilar a aplicação, basta digitar o comando:

                        javac HelloWorld.java

Este comando vai gerar o arquivo HelloWorld.class, que é o byte-code da aplicação. Para executar o byte-code basta digitar o comando:

                        java HelloWorld

1.7. Criando uma APPLET

Criar uma applet é diferente de criar uma simples aplicação porque uma applet é executada e visualizada dentro de uma página HTML. Como exemplo, novamente será implementada a clássica “Hello World!”.

1.7.1. O código fonte

A seguir, o código da aplicação “Hello World!” (arquivo: HelloWorldApplet.java):

import java.awt.Graphics;

 

public class HelloWorldApplet extends java.applet.Applet {

      public void paint (Graphics g) {

            g.drawString (“Hello World!”,5,25);

      }

}

 


1.7.2. Compilando a applet

Para compilar a applet, basta digitar o comando:

                        javac HelloWorldApplet.java

Este comando vai gerar o arquivo HelloWorldApplet.class, que é o byte-code da applet. Para executar o byte-code é necessário haver uma página HTML, a qual tem o código a seguir (arquivo: exemplo1.html):

<HTML>

<HEAD>

<TITLE> Java Hello World </TITLE>

</HEAD>

<BODY>

<APPLET CODE=”HelloWorldApplet.class” WIDTH=300 HEIGHT=100>

</APPLET>

</BODY>

</HTML>

 

1.7.3. Visualização

A página com código descrito anteriormente pode ser visualizada através de um browser que suporte java ou do appletviewer utilizando-se do comando a seguir:

            appletviewer exemplo1.html

 


2. O BÁSICO

2.1. Variáveis e tipos de dados

Variáveis são alocações de memória nas quais podemos guardar dados. Elas têm um nome, tipo e valor. Toda vez que necessite usar de uma variável você precisa declará-la e só então poderá atribuir valores a mesma.

2.1.1. Declarando variáveis

As declarações de variáveis consistem de um tipo e um nome de variável: como segue o exemplo:

            int idade;

            String nome;

            boolean existe;

Os nomes de variáveis podem começar com uma letra, um sublinhado ( _ ), ou um cifrão ($). Elas não podem começar com um número. Depois do primeiro caracter pode-se colocar qualquer letra ou número.

2.1.2. Tipos de variáveis

Toda variável deve possuir um tipo. Os tipos que uma variável pode assumir uma das três “coisas” a seguir:

·         Uma das oito primitivas básicas de tipos de dados

·         O nome de uma classe ou interface

·         Um Array

Veremos mais sobre o uso de arrays e classes mais a frente.

Os oito tipos de dados básicos são: inteiros, números de ponto-flutuante, caracteres e booleanos (verdadeiro ou falso).

Tipos Inteiros:

Tipo    Tamanho         Alcance

            byte     8 bits               -128 até 127

            short    16 bits             -32.768 até 32.767

            int        32 bits             -2.147.483.648 até 2.147.483.647

            long     64 bits             -9223372036854775808 até 9223372036854775807

Existem dois tipos de números de ponto-flutuante: float ( 32 bits, precisão simples) e double (64 bits, precisão dupla).

2.1.3. Atribuições a variáveis

Após declarada uma variável a atribuição é feita simplesmente usando o operador ‘=’:

                        idade = 18;

                        existe = true;

2.2. Comentários

Java possui três tipos de comentário, o /* e */ como no C e C++. Tudo que estiver entre os dois delimitadores são ignorados:

/* Este comentário ficará visível somente no código o compilador ignorará completamente este trecho entre os delimitadores

*/

 

Duas barras (//) também podem ser usadas para se comentar uma linha:

      int idade; // este comando declara a variável idade

 

E finalmente os comentários podem começar também com /** e terminar com */. Este comentário é especial e é usado pelo javadoc e para gerar uma documentação API do código. Para aprender mais sobre o javadoc acesse a home page (http://www.javasoft.com).

2.3. Caracteres especiais

Caracter

Significado

\n

Nova Linha

\t

Tab

\b

Backspace

\r

Retorno do Carro

\f

“Formfeed” (avança página na impressora)

\\

Barra invertida

\’

Apóstrofe

\”

Aspas

\ddd

Octal

\xdd

Hexadecimal

 

2.4. Expressões e operadores

2.4.1. Operadores Aritméticos

Operador

Significado

Exemplo

+

soma

3 + 4

-

subtração

5 - 7

*

multiplicação

5 * 5

/

divisão

14 / 7

%

módulo

20 % 7

 

Exemplo Aritmético:

      class ArithmeticTest {

      public static void main ( Strings args[] ) {

            short x = 6;

            int y = 4;

            float a = 12.5f;

            float b = 7f;

 

            System.out.println ( “x é “ + x + “, y é “ + y );

            System.out.println ( “x + y = “ + (x + y) );

            System.out.println ( “x - y = “ + (x - y) );

            System.out.println ( “x / y = “ + (x / y) );

            System.out.println ( “x % y = “ + ( x % y ) );

 

            System.out.println ( “a é “ + a + “, b é “ + b );

            System.out.println ( “ a / b = “ + ( a / b ) );

      }

}

 


A saída do programa acima é :

 

      x é 6, y é 4

      x + y = 10

      x - y = 2

      x / y = 1

      x % y = 2

      a é 12.5, b é 7

      a / b = 1.78571

 

2.4.2. Mais sobre atribuições

Variáveis podem atribuidas em forma de expressões como:

                        int x, y, z;

                        x = y = z = 0;

No exemplo as três variáveis recebem o valor 0;

Operadores de Atribuição:

Expressão

Significado

x += y

x = x + y

x -= y

x = x - y

x *= y

x = x * y

x /= y

x = x / y

2.4.3. Incrementos e decrementos

Como no C e no C++ o Java também possui incrementadores e decrementadores :

                        y = x++;

                        y = --x;

As duas expressões dão resultados diferentes, pois existe uma diferença entre prefixo e sufixo. Quando se usa os operadores ( x++ ou x-- ), y recebe o valor de x antes de x ser incrementado, e usando o prefixo ( ++x ou –x ) acontece o contrario, y recebe o valor incrementado de x.

2.5. Comparações

Java possui várias expressões para testar igualdade e magnitude. Todas as expressões retornam um valor booleano (true ou false).

2.5.1. Operadores de comparação

Operador

Significado

Exemplo

==

Igual

x == 3

!=

Diferente ( Não igual)

x != 3

Menor que

x < 3

Maior que

x > 3

<=

Menor ou igual

x <= 3

>=

Maior ou igual

x >= 3


2.5.2. Operadores lógicos

Operador

Significado

&&

Operação lógica  E (AND)

||

Operação lógica OU (OR)

!

Negação lógica

&

Comparação bit-a-bit E (AND)

|

Comparação bit-a-bit OU (OR)

^

Comparação bit-a-bit OU-Exclusivo (XOR)

<< 

Deslocamento a esquerda

>> 

Deslocamento a direita

>>> 

Deslocamento a direita com preenchimento de zeros

-

Complemento bit-a-bit

x <<= y

Atribuição com deslocamento a esquerda ( x = x << y )

x >>= y

Atribuição com deslocamento a direita     ( x = x >> y )

x >>>= y

Atribuição com deslocamento a direita e com preenchimento de zeros ( x = x >>> y )

x &= y

atribuição AND ( x = x & y )

x |= y

atribuição OR ( x = x | y )

x ^= y

atribuição XOR ( x = x ^ y )


3. ARRAYS, LOOPS E CONDICIONAIS

3.1. Arrays

            Arrays em Java são diferentes do que em outras linguagens. Arrays em Java são objetos que podem ser passados e acoplados a outros objetos.

            Arrays podem conter qualquer tipo de elemento valorado(tipos primitivos ou objetos), mas você não pode armazenar diferente tipos em um simples array.

Ou seja, você pode ter um array de inteiros, ou um array de strings, ou um array de array, mas você não pode ter um array que contenha ambos os objetos strings e inteiros.

            A restrição acima descrita significa que os arrays implementados em Java são genéricos homogêneos, ou seja, um único array pode armazenar qualquer tipo de objeto com a restrição que todos sejam do mesma classe.

3.1.1. Declarando um Array:

           

            String difficult[];

            Point hits[];

            int temp[];

 

 

Outra alternativa de declaração:

           

      String[] difficult;

            Point[]  hits;

      int[]  temp;

 

3.1.2. Criando Objetos Arrays:

            Um dos  caminhos é usar o operador new para criar uma nova instância de um array, por exemplo:

                   

            int[] temps = new int[99];

 

Quando voce cria um objeto array usando o operador new, todos os índices são inicializados para você ( 0 para arrays numéricos, falso para boolean, ‘\0’ para caracteres, e NULL para objetos). Você também pode criar e inicializar um array ao mesmo tempo.

 

String[] chiles = { “jalapeno”,  “anaheim”,  “serrano” ,  “jumbou”,  “thai”};

 

Cada um dos elementos internos deve ser do mesmo tipo e deve ser também do mesmo tipo que a variável que armazena o array. O exemplo acima cria um array de Strings chamado chiles  que contém 5 elementos.

 

3.1.3. Acessando os Elementos do Array

Uma vez que você têm um array com valores iniciais, você pode testar e mudar os valores em cada índice de cada array.

 

            Os arrays em Java sempre iniciam-se na posição 0 como no C++. Por exemplo:

            String[]  arr= new String[10];

            arr[10]=”out”;

 

            Isto provoca um erro de compilação pois o índice 10 não existe, pois isto está fora das bordas do array.

 

            arr[9] = “inside”;

 

            Esta operação de atribuição é válida e insere na posição 9 do array, a string “inside”.

           

3.1.4. Arrays Multidimensionais

            Java não suporta arrays multidimensionais. No entanto, você pode declarar e criar um array de arrays   e acessá-los como você faria no estilo-C.

 

      int coords[][]= new int[12][12];

      coords[0][0] = 1;

      coords[0][1] = 2;

 

3.2. Condicionais

            O condicional contém a palavra chave if, seguido por um teste booleano. Um opcional else  como palavra chave pode ser executado na caso do teste ser falso, Exemplo:

 

            if ( x < y)

                  System.out.println(“ x e menor do que y”);

            else

                  System.out.println(“ y e maior);

 

Nota técnica: A diferença entre o if em Java e C ou C++ é que o teste deve retornar um valor booleano(true ou false).

 

3.2.1. Bloco

            Um bloco é definido por ({}) e contém um grupo de outros blocos. Quando um novo bloco é criado um novo escopo local é aberto e permite a definição de variáveis locais. As variáveis definidas dentro de um bloco só podem ser vistas internamente a este, e são terminadas ou extintas no final da execução deste(}).


 

      void testblock(){

            int x = 10, w=1;

           

            if (x> w)

            {  // inicio do bloco

                  int y=50;

                  System.out.println(“dentro do bloco”);

                  System.out.println(“x:” + x);

                  System.out.println(“y:” + y);

            } // final do bloco

 

            System.out.println(“w:” + w);

            System.out.println(“y:” + y);  // erro variável não conhecida

}          

 

3.3. O operador Condicional

         Uma alternativa para o uso do if e else é um operador ternário condicional. Este operador ternário (?: ) , é chamado assim porque tem três termos como parâmetro.

            Exemplo:

test ? trueresult : falseresult

int menor = x < y ? x : y ;  // A variável menor recebe o valor do menor entre x e  y.

 

3.4. O switch

         Um comum mecanismo para substituição de ifs que pode ser usado para um grupo de testes e ações junto a um simples agrupamento, chama-se switch.

      switch (teste){

            case  valorum;

                  resultum;

            break;

 

            case valordois;

                  resultdois;

            break;

 

            case valortres:

                  resulttres;

            break;

 

            default: defaultresult;

}

 

            O valor é comparado com cada um dos casos relacionados. Se a combinação não for encontrada, o bloco default executado. O default  é opcional, então caso este não esteja

associado ao comando, o bloco do swicth sem executar nada.

 


3.5. Looping  For

            O loop em Java tem esta sintaxe:

 

for(inicialização; teste; incremento) {

      bloco de comandos;

}

 

Você também pode incluir um comando simples, sendo assim não há necessidade da utilização de chaves. Exemplo:

 

String strArray[] = new String[10];

for ( i=0; i< strArray.length; i++)

      strArray[i]=””;

 

Inicializa um array de10 elementos com “”;

 

3.6. Loop While

         O while é usado para repetir um comando, ou um conjunto de comando enquanto a condição é verdadeira.

        

While (condição){

      bloco de comandos;

}

 

A condição é uma expressão booleana. Exemplo:

 

int count=0;

while( count < array1.length  && array1[count]!=0){

      array2[count]=(float) array1[count++];

}

 

3.7. Loop Do

            A principal diferença entre o while e o do é que o teste condicional no caso do while é feita antes de se executar o código interno ao loop.   Desta forma, o que pode acontecer no while  é que o loop pode não ser executado se a condição for false. Já no loop do o corpo do loop é executado pelo menos uma vez, pois o teste de permanência é executado no fim do loop.

 

do{

            bodyOfLoop;

} while(condition);

 

 


4. Criando Classes e Aplicações em Java

 

4.1. Definindo Classes

Para definir uma classe use a palavra chave class e o nome da classe. Exemplo:

 

class Minhaclasse{

...

}

 

Se esta classe é uma subclasse de outra classe, use extends para indicar a superclasse. Exemplo:

 

class Minhaclasse extends SuperClasse{

...

}

 

4.2. Definindo Variáveis de Instância

As variáveis de instância, aparentemente, são declaradas e definidas quase exatamente da mesma forma que as variáveis locais, a  principal diferença é que a alocação delas é na definição da classe. Exemplo:

 

class Bike extends Veículo {

      String tipo;

      int correia;

      int pedal;

}

 

4.3. Constantes          

Para declarar uma constante, use  a palavra chave final  antes da declaração da variável e inclua um valor inicial para esta variável. Exemplo:

 

final float pi=4.141592;

final boolean debug=false;

final int maxsize = 40000;

 

4.4. Variáveis de Classe

As variáveis de classe são boas para a comunicação entre os diferentes objetos da mesma classe, ou para manter travamento de estados globais sobre um conjunto de objetos. Exemplo:

 

static int soma;

static final int maxObjects= 10;

 

4.5. Definição de Métodos

A definição dos métodos têm quatro partes básicas:

*                     O nome do método;

*                     O tipo objeto ou tipo primitivo de retorno;

*                     Uma lista de parâmetros;

*                     O corpo do método;

 

            A definição básica de um método tem esta aparência:

 

      tipoderetorno nomedometodo(tipo1 arg1, tipo2 arg2, ...){

            ....

}

 

            Exemplo:

 

      int[] makeRange(int lower, int upper)  { ... }

 

 

            A RangeClass classe:

 

      class RangeClass{

            int[] makeRange(int lower, int upper){

                  int arr[] = new int[ (upper - lower) + 1];

 

            for (int i=0; i<arr.length;i++)

                  arr[i]=lower++;

            return arr;

      }

     

      public static void main(String arg[]){

            int theArray[];

            RangeClass theRange=new RangeClass();

 

            theArray= theRange.makeRange(1,10);

            System.out.print(“The array: [ “ );

            for ( int i=0; i < theArray.length; i++)

                  System.out.print(theArray[i] + “ “);

 

            System.out.println(“]”);

            }

}

 

    A saída do programa é :

 

            The array: [ 1 2 3 4 5 6 7 8 9 10 ]

 

 

4.6. A palavra chave this

            No corpo de uma definição de método, você pode querer referir-se ao objeto corrente-o objeto que o método foi chamado - para referir-se às variáveis de instância ou para passar o objeto corrente como um argumento para um outro método. Para este tipo de referência, você pode usar a palavra chave this.

 

class Pessoa {

      String nome;

      int idade;

            Pessoa ( String nome, int idade ) {

            this.nome = nome;

            this.idade = idade;

      }

 

      public void imprimeDados () {

        System.out.print ( “Nome: “ + this.nome + “ Idade: “ + this.idade);

      }

}

 

4.7.Passando argumentos para Métodos

    class PassByReference{

            int onetoZero(int arg[]){

                  int count=0;

 

            for(int i=0; i< arg.length; i++){

                  if(arg[i]==1){

                        count++;

                        arg[i]=0;

                  }

            }

            return count;

            }

      }

 

      public static void main (String arg[])

            int arr[]= { 1,3,4,5,1,1,7};

            PassByReference test = new PassByReference();

            int numOnes;

 

            System.out.print(“Values of the array: [“);

            for( int i=0; i < arr.length; i++){

                  System.out.print(arr[i] + “ “);

            }

            System.out.println(“]”);

           

            numOnes= test.onetoZero(arr);

            System.out.println(“Number of Ones = “ + numOnes);

            System.out.print(“New values of the array: [ “);

            for( int i=0; i < arr.length; i++){

                  System.out.print(arr[i] + “ “);

            }

            System.out.println(“]”);

}

 

As saídas deste programa:

            Values of the array: [ 1 3 4 5 1 1 7 ]

            Number of Ones = 3

            New values of the Array: [ 0 3 4 5 0 0 7]


5. MAIS SOBRE MÉTODOS

5.1. Polimorfismo ou Sobrecarga

            Os métodos em Java podem ser sobrecarregados, ou seja, podem-se criar métodos com o mesmo nome, mas com diferentes assinaturas (parâmetros) e diferentes definições. Quando se chama um método em um objeto, o Java casa o nome do método, o número de argumentos e o tipo dos argumentos e escolhe qual a definição do método a executar.

Para criar um método sobrecarregado, é necessário criar diferentes definições de métodos na sua classe, todos com o mesmo nome, mas com diferentes parâmetros (número de argumentos ou tipos).

No exemplo a seguir veremos a definição da classe Retangulo, a qual define um retângulo plano. A classe Retangulo têm quatro variáveis para instanciar, as quais definem o canto superior esquerdo e o canto inferior direito do retângulo: x1, y1, x2 e y2.

 

class Retangulo {

      int x1 = 0;

      int y1 = 0;

      int x2 = 0;

      int y2 = 0;

}

 

            Quando uma nova instância da classe Retangulo for criada, todos as suas variáveis são inicializadas com 0. Definindo um método construaRetang (): este método recebe quatro inteiros e faz um “resize” do retângulo de acordo com as novas coordenadas e retorna o objeto retângulo resultante ( note que os argumentos possuem o mesmo nome das variáveis instanciáveis, portanto deve-se usar o this para referenciá-las ):

 

Retangulo construaRetang ( int x1, int y1, int x2, int y2 ) {

      this.x1 = x1;

      this.y1 = y1;

      this.x2 = x2;

      this.y2 = y2;

      return this;

}

 

Querendo-se definir as dimensões do retângulo de outra forma, por exemplo pode-se usar o objeto Point ao invés de coordenadas individuais. Faremos a sobrecarga do método construaRetang (), passando agora como parâmetro dois objetos Point:

 

Retangulo construaRetang (Point superiorEsquerdo, Point inferiorDireito) {

      x1 = superiorEsquerdo.x;

      y1 = superiorEsquerdo.y;

      x2 = inferiorDireito.x;

      y2 = inferiorDireito.y;

      return this;

}

 

Porém querendo-se definir um retângulo usando somente o canto superior esquerdo e uma largura e altura do retângulo pode-se ainda definir mais um método construaRetang ():


 

Retangulo construaRetang (Point superiorEsquerdo, int largura, int altura) {

      x1 = superiorEsquerdo.x;

      y1 = superiorEsquerdo.y;

      x2 = (x1 + largura);

      y2 = (y1 + altura);

      return this;

}

 

Para finalizar o exemplo mostra-se a seguir um método para imprimir as coordenadas do retângulo e um main para fazer o teste:

 

import java.awt.Point;

 

class Retangulo {

      int x1 = 0;

      int y1 = 0;

      int x2 = 0;

      int y2 = 0;

 

Retangulo construaRetang ( int x1, int y1, int x2, int y2 ) {

      this.x1 = x1;

      this.y1 = y1;

      this.x2 = x2;

      this.y2 = y2;

      return this;

}

     

Retangulo construaRetang (Point superiorEsquerdo, Point inferiorDireito) {

      x1 = superiorEsquerdo.x;

      y1 = superiorEsquerdo.y;

      x2 = inferiorDireito.x;

      y2 = inferiorDireito.y;

      return this;

}

 

Retangulo construaRetang (Point superiorEsquerdo, int largura, int altura) {

      x1 = superiorEsquerdo.x;

      y1 = superiorEsquerdo.y;

      x2 = (x1 + largura);

      y2 = (y1 + altura);

      return this;

}

 

void imprimaRetangulo () {

      System.out.print ( “Retângulo: < “ + x1 + “, “ + y1 );

      System.out.println ( “, “ + x2 + “, “ + y2 + “>”);

}

 

public static void main ( String args[] ) {

      Retangulo retang =      new Retangulo();

     

      System.out.println ( “Chamando construaRetang com coordenadas 25, 25, 50, 50 :” );

      retang.construaRetang ( 25, 25, 50, 50 );

      retang.imprimaRetangulo ();

      System.out.println ( “--------------------------------------------“);

     

      System.out.println ( “Chamando construaRetang com os pontos (10, 10) , (20, 20) :” );

      retang.construaRetang ( new Point (10,10) , new Point (20, 20) );

      retang.imprimaRetangulo ();

      System.out.println ( “--------------------------------------------“);

     

      System.out.println ( “Chamando construaRetang com os pontos (10, 10) ,  largura (50) e altura (50) :” );

      retang.construaRetang ( new Point (10,10) , 50, 50);

      retang.imprimaRetangulo ();

      System.out.println ( “--------------------------------------------“);

}

}

 

5.2. Métodos Construtores

Um método construtor é um tipo especial de método que determina como um objeto é inicializado quando ele é criado.

Diferente dos métodos normais um método construtor não pode ser chamado diretamente; ao invés disto os métodos construtores são chamados automaticamente pelo Java. No momento em que o objeto é instanciado, ou seja quando se usa new o Java faz três coisas:

 

*                     Aloca memória para o objeto

*                     Inicializa as variáveis daquela instância do objeto

*                     Chama o método construtor da classe

 

5.2.1. Construtores Básicos

Os construtores parecem muito com os métodos normais, com duas diferenças básicas:

*                     Construtores sempre têm o mesmo nome da classe

*                     Construtores não podem ter tipo de retorno

            Exemplo:

 

class Pessoa {

      String nome;

      int idade;

     

      Pessoa (String n, int i) {

            nome = n;

            idade = i;

      }

     

      void printPessoa () {

            System.out.print (“Oi meu nome é : ”+ nome);

            System.out.println (“. Eu tenho : “+idade+ “ anos”);

      }

 

      public static void main ( String args[] ) {

            Pessoa p;

            p = new Pessoa ( “Maria”, 20 );

 

            p.printPessoa();

      }

}

 

5.2.2. Polimorfismo de Construtores

Igual aos métodos normais os construtores também podem ter números variáveis de tipos e parâmetros. Por exemplo os métodos construaRetang () definidos na classe Retangulo seriam excelentes construtores para a mesma classe, pois eles estão justamente instanciando as variáveis. Segue o exemplo abaixo com as devidas alterações :

 

import java.awt.Point;

class Retangulo {

      int x1 = 0;

      int y1 = 0;

      int x2 = 0;

      int y2 = 0;

Retangulo ( int x1, int y1, int x2, int y2 ) {

      this.x1 = x1;

      this.y1 = y1;

      this.x2 = x2;

      this.y2 = y2;

}

Retangulo (Point superiorEsquerdo, Point inferiorDireito) {

      x1 = superiorEsquerdo.x;

      y1 = superiorEsquerdo.y;

      x2 = inferiorDireito.x;

      y2 = inferiorDireito.y;

}

 

Retangulo (Point superiorEsquerdo, int largura, int altura) {

      x1 = superiorEsquerdo.x;

      y1 = superiorEsquerdo.y;

      x2 = (x1 + largura);

      y2 = (y1 + altura);

}

 

void imprimaRetangulo () {

      System.out.print ( “Retângulo: < “ + x1 + “, “ + y1 );

      System.out.println ( “, “ + x2 + “, “ + y2 + “>”);

}

 

public static void main ( String args[] ) {

      Retangulo retang;

     

      System.out.println ( “Retangulo com coordenadas 25, 25, 50, 50 :” );

      retang = new Retangulo (25, 25, 50, 50 );

      retang.imprimaRetangulo ();

      System.out.println ( “--------------------------------------------“);

     

      System.out.println ( “Retangulo com os pontos (10, 10) , (20, 20) :” );

      retang = new Retangulo ( new Point (10,10) , new Point (20, 20) );

      retang.imprimaRetangulo ();

      System.out.println ( “--------------------------------------------“);

      System.out.println ( “Retangulo com os pontos (10, 10) ,  largura (50) e altura (50) :” );

      retang = new Retangulo ( new Point (10,10) , 50, 50);

      retang.imprimaRetangulo ();

      System.out.println ( “--------------------------------------------“);

}

}


5.3. Métodos Destrutores

Os métodos destrutores são chamados logo antes do “coletor de lixo” passar e sua memória se liberada. O métodos destrutor é chamado de finalize() a classe Object define um método destrutor padrão, que não faz nada. Para criar um método destrutor para suas próprias classes basta sobrepor o método finalize () com o seguinte cabeçalho:

 

protected void finalize () {

      ...

}

 

Dentro do método finalize você pode colocar tudo que você precisa fazer para a limpeza do seu objeto.