Arrays

Programação 3: Orientação a Objetos e Java

Definição e Criação de Arrays

Em Java, arrays são objetos especiais. Como vimos anteriormente, objetos são agrupados em classes. Uma classe de arrays pode ser especificada usando a notação

    Tipo[]

Precisamente, esta notação denota a classe cujos objetos são arrays, de qualquer tamanho, contendo elementos do tipo Tipo. As operações de uma classe array são pré-definidas, não sendo possível a inclusão de novas operações.

Como exemplo, considere a definição da classe Banco contendo o atributo contas, o qual é associado a uma classe de arrays de contas bancárias:

    class Banco {
        private int indice = 0;
        private Conta[] contas;
    }

Como nesta classe nenhum inicializador foi especificado, um inicializador default é automaticamente introduzido por Java. Para uma classe Classe, este inicializador é implicitamente declarado como

    Classe ();

e quando invocado inicializa os atributos de um objeto da classe com valores default pré-definidos, ou com valores especificados na definição do atributo (como na definição do atributo indice da classe Banco), se existirem. Em particular, atributos do tipo int são inicializados por default com 0, enquanto atributos de tipo classe são inicializados por default com a constante null. Esta constante corresponde a referência nula; isto é, uma referência que não aponta para nenhum objeto.

Note que os elementos de um tipo Tipo[] podem ter qualquer tamanho, mas na hora de criação de um elemento específico temos que especificar o tamanho do mesmo. De uma forma geral, a criação de um array com capacidade para armazenar n elementos de um tipo Tipo é especificada pela seguinte expressão:

    new Tipo[n]

Por exemplo, um array de contas pode ser criado como descrito no inicializador a seguir:

    Banco (byte tamanho) {
        contas = new Conta[tamanho];
        indice = 0;
    }

onde o número de elementos que podem ser armazenados no array é dado como argumento para o construtor de bancos.

Operações sobre Arrays

Por serem objetos especiais, as operações associadas a arrays são representadas em Java com a notação usual de arrays em linguagens imperativas. Por exemplo, considere o método que cadastra uma conta em um banco:

    void cadastro(Conta c) {
        contas[indice] = c;
        indice = indice + 1;
    }

Este método ilustra como o indice-ésimo componente do array pode ser alterado, enquanto o método a seguir ilustra como obter o i-ésimo componente do array:

    Conta procura(long num) {
//      Comentários de uma linha são introduzidos assim...
//      Variáveis locais ao método.
        int i = 0;
        boolean achou = false;
        Conta result;

        while ((! achou) & (i < indice)) {
            if (contas[i].numConta() == num)
                achou = true;
            else
                i = i + 1;
        }
        if (achou)
            result = contas[i];
        else
            result = null;

        return result;
    }

Este método retorna a conta de número num cadastrada no banco responsável pela execução do método. Note que a expressão

    contas[i].numConta()

denota o envio de uma mensagem para o i-ésimo componente de contas requisitando a execução do método num_conta(), ou seja, pedindo o número da conta correspondente.

Note também que assim como atributos e variáveis locais de tipo classe, componentes de array, argumentos e resultados de tipo classe também denotam referências para objetos, ao invés de objetos propriamente. No entanto, isto é normalmente implícito em Java; só nota-se que trabalhamos com referências quando a constante null é usada explicitamente.

Paulo Borba (phmb@di.ufpe.br)