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.

 
Free Web Hosting