Modelos

• Considere o seguinte exemplo, fora do contexto de programação:

"O coordenador, Taciano, resolveu padronizar as provas do curso de Sistemas do CERES. Para isso, escreveu um modelo de prova. O modelo de prova descrito por Taciano estabelece que as provas do nosso curso deveriam ter um mínimo de 5 questões e um máximo de 10, além de um cabeçalho indicando nome da disciplina, nome do professor, nome do aluno e data da prova"

• De posse do modelo de provas de Taciano, considere as seguintes interrogações:

Qual é o número mínimo de questões da prova?

Qual é o número máximo de questões da prova?

Qual é o nome do aluno?

Qual é a primeira questão?

• Como podemos perceber, apenas as duas primeiras perguntas podem ser respondidas a partir do modelo. O que Taciano escreveu foi um modelo de prova, e não uma prova
• Uma prova de Java com 7 questões e um cabeçalho adequado "segue" o modelo de Taciano. Podemos dizer que esta prova é uma instância do modelo de Taciano. Para responder às últimas indagações propostas anteriormente, precisamos de uma instância do modelo e não apenas do modelo propriamente dito
• Logo, podemos observar que algumas informações podem ser obtidas a partir dos modelos, ao passo que outras só podem ser obtidas a partir das instâncias do modelo. Chamamos de informações estáticas aquelas que podem ser obtidas a partir de um modelo

Classes e Objetos

• Classes são modelos. Mais especificamente, classes são modelos de software
• Objetos são instâncias de uma classe (modelo)
• Assim como o modelo de Taciano determina uma estrutura comum a todas as suas instâncias (provas), uma classe também determina uma estrutura (e um comportamento) comum a todas as suas instâncias (objetos)
• Em termos técnicos, uma classe será uma espécie de registro
• Em Pascal, C e PE, usávamos registros para agrupar informações inter-relacionadas numa só estrutura
• Em Java, usaremos classes para este mesmo propósito. Desta forma, uma classe pode ser considerada um tipo de dado (assim como os registros, nestas outras linguagens)
• Entretanto, definiremos nas classes não só a estrutura das instâncias, mas também o comportamento delas. Assim, classes são registros que descrevem não só informações, mas também rotinas. Tais rotinas são chamadas genericamente de métodos (ou, menos comummente, funções)
• Como pudemos perceber pela Aula 4 e pela Aula 5 , é através dos métodos que nos comunicamos com os objetos. Normalmente não podemos acessar diretamente as informações internas aos objetos, assim como acessávamos os campos de um registro
• Classes e objetos são conceitos fundamentais no paradigma de programação conhecido como Orientação a Objetos.

Exemplos

• Antes de vermos como os modelos/classes são criados/das, vamos rever a utilização de instâncias (objetos)
• Criamos instâncias através de um método especial, chamado construtor. Um método construtor tem seu nome rigorosamente igual ao nome da classe (respeitando-se a caixa das letras!). Sua chamada deve ser precedida da palavra-chave new.

ContaBancaria conta1 = new ContaBancaria("Roberto Jefferson");

[editado: esse texto foi escrito por volta de 2005. Por incrível que pareça, Jefferson ainda é figura bem atuante no país]

• Podemos chamar os métodos do objeto conta1 e usar seus resultados

conta1.depositar(500);

System.out.println("Saldo: "+conta1.saldo());

boolean result = conta1.sacar(200);

if (result)

   System.out.println("Saque efetuado com sucesso. Novo saldo: "+conta1.saldo());

else System.out.println("Você não tem crédito para efetuar esse saque. Saldo atual: "+conta1.saldo());

result = conta1.sacar(1000);

if (result)

   System.out.println("Saque efetuado com sucesso. Novo saldo: "+conta1.saldo());

else System.out.println("Você não tem crédito para efetuar esse saque. Saldo atual: "+conta1.saldo());

• Analisemos uma possível implementação para a classe ContaBancaria:

class ContaBancaria 

{

    String titular;

    double total;

    ContaBancaria(String t){

        this.titular = t;

        this.total = 0.0;        

    }

    double saldo(){

        return this.total;

    }    

    boolean sacar(double quantidade){

        if (this.total >= quantidade ){

            this.total-=quantidade;

            return true;

        }

        return false;        

    }

    void depositar(double quantidade){

        this.total+=quantidade;

    }

}

• Inicialmente, a definição de uma classe se assemelha um pouco à definição de registros (em Pascal), onde listamos os campos do registro e seus respectivos tipos. Ex:

type ContaBancaria = record

titular : string;

total : real;

end;

• No mundo da orientação a objetos, os campos também são chamados de propriedades (ou atributos) ao passo que rotinas são chamadas de métodos
• Após a definição dos atributos, segue-se a definição do construtor
• Construtores têm o mesmo nome da classe e são utilizados para criar objetos
• Os objetos da classe em questão terão dois atributos (titular e total), logo é natural que o construtor inicialize esses atributos para que o objeto seja criado adequadamente
• Uma classe pode ter vários construtores e os construtores podem receber quaisquer parâmetros que o ajudem a inicializar um objeto
• Ex: Poderíamos adicionar o seguinte construtor à classe ContaBancaria:

ContaBancaria(String t, double saldoInicial){

        this.titular = t;

        this.total = saldoInicial;        

}

• Depois do construtor, temos a implementação de vários métodos: depositar, sacar e saldo
• Além de receberem parâmetros, os métodos também têm acesso aos atributos - podem modificá-los ou utilizá-los para fazer algum tipo de processamento
• Em resumo, a classe ContaBancaria contém um construtor, dois atributos, três métodos
• Observação: de posse do código da classe ContaBancaria, considere as sequintes questões:

Quem é o titular da conta?

Qual é o saldo da conta?

- Não podemos responder a essas questões pois se tratam de questões pertinentes a instâncias (objetos) da classe ContaBancaria, e não à classe em si

Problemas com a classe ContaBancaria

• Considere um programa principal com o seguinte código:

ContaBancaria conta = new ContaBancaria("Bispo Rodrigues");

conta.depositar(1000);

• Em vez de chamarmos conta.depositar(1000) poderíamos fazer conta.total=1000 ou conta.total+=1000
• Isto - acesso direto a atributos de um objeto - é extremamente indesejável num programa orientado a objetos, pois quebra o princípio de encapsulamento dos dados
• Para inviabilizar construções do tipo conta.total=1000, as linguagens orientadas a objetos definem modificadores de acesso, que indicam o que está acessível a quem instancia/usa objetos de uma determinada classe
• Vejamos a classe ContaBancaria escrita corretamente, com os modificadores de acesso adequados:

class ContaBancaria 

{

    private String titular;

    private double total;

    public ContaBancaria(String t){

        this.titular = t;

        total = 0.0;        

    }

    public double saldo(){

        return total;

    }    

    public boolean sacar(double quantidade){

        if (total >= quantidade ){

            total-=quantidade;

            return true;

        }

        return false;        

    }

    public void depositar(double quantidade){

        total+=quantidade;

    }

}

• Os modificadores de acesso private e public indicam, respectivamente, o que pode e o que não pode ser acessado por quem instanciar objetos da classe ContaBancaria
• Normalmente, os dados descritos nas classes são privados, ao passo que os métodos são públicos. Com isso, dizemos que os dados estão "escondidos" (há quem diga "encapsulados"), pois a única maneira de manipulá-los é utilizando os métodos descritos na própria classe
• Com isso, ninguém poderá efetuar sobre os dados de um objeto alguma operação que o desenvolvedor da classe não tenha previsto

Considerações Gerais

• E aquela história de "classes são modelos"!?

A classe ContaBancaria constitui um modelo no seguinte sentido: ela descreve a estrutura e o comportamento de todos os seus objetos. Rigorosamente todos os objetos da classe ContaBancaria armazenarão internamente informações sobre o titular (String) e o total (double). Além disso, todos os objetos efetuarão depósitos, saques e verificação de saldo exatamente da mesma maneira (seguindo o mesmo código/algoritmo)

Exercícios

Baixe aqui o projeto a partir do qual os exercícios devem ser feitos.

0. Escreva um método na classe ContaBancaria que retorne o nome do titular da conta.

1. Adicione um atributo à classe ContaBancaria. O atributo deve expressar a data de criação da conta. Dentro do construtor da classe, esse atributo deve ser inicializado com com a data atual do sistema

2. Adicione dois atributos à classe ContaBancaria. Um para representar a data do último depósito, outra para representar a data do último saque

3. Implemente um método que imprima todos os dados da conta quando chamado

Ex:

Titular: ACM Neto

Saldo atual: 1000

Último saque: 15/Set/2005

Último depósito: 10/Set/2005

Data de criação da canta: 01/Set/2005

4. Altere a classe ContaBancaria para que só seja efetuado, no máximo, um saque por dia. Precisaremos de uma nova classe? De um novo método? Ou apenas de alterar um método existente? Neste último caso, de que estrutura de programação precisaríamos?

5. Acrescente a funcionalidade de extrato ao seu projeto. Procure responder às seguintes questões:

Preciso acrescentar novas propriedades à classe ContaBancaria? Preciso acrescentar novo(s) métodos(s) à classe ContaBancaria? Qual/quais? Precisam de parâmetros/tipo de retorno? Será preciso modificar alguma das funcionalidades existentes para que essa funcionalidade de extrato seja implementada?

6. Implemente um esquema de crédito na classe ContaBancaria, de modo os saques possam ser efetuados mesmo se o total da conta ficar menor que zero, repeitando-se um determinado limite. Reflita sobre as mesmas questões escritas anteriormente.

7. Dê uma olhada no código do arquivo Main.java. Ele tem um método estático. Copie este código no BlueJ e tente executar o método estático