programação Utilizando Classes no Java

[Felipe Moraes 151]

Bom dia XTibia.

 

Neste tutorial, explicarei como criar classes e instancia-las, utilizando Java.

Recomendo a leitura dos seguintes tutoriais, para ter que tenha uma noção do que estamos fazendo

• http://www.xtibia.com/forum/topic/236597-criando-sua-primeira-aplicacao-em-java/
• http://www.xtibia.com/forum/topic/236685-principios-da-orientacao-a-objetos/

 

 

Esse aula, diferentemente da última, terá um teor mais prático.

Vamos lá.

 

 

 

Vamos Usar como exemplo, um sistema de um banco.

Uma forte canditada, seria uma entidade conta.

Para o nosso exemplo, usaremos uma conta poupança como referência, que não pode ter saldo negativo.

 

Primeiramente, o que toda conta tem que será importante em nosso exemplo ?

 

• Títular da conta (nome)
• Saldo
• Número da conta

O que uma conta deve fazer ? Ou seja, qual será seu comportamento:

 

• Sacar
• Depositar
• Saldo Atual
• Transferir de uma conta para outra
• Exibir titular da conta

 

Veremos alguns exemplos abaixo:

 

 

Temos o modelo de como deverá ficar nosso objeto conta. Mas pra isso, precisamos definir uma classe, para que em tempo de execução, nosso objeto possua valores.

 

 

• No Eclipse, crie uma nova classe.
• Vamos chama-la de Conta.

Precisamos definir os atributos dessa conta. São eles:

• Número, do tipo inteiro
• Cliente, do tipo String
• Saldo, do tipo double

 

Nossa classe ficou assim:

public class Conta{
 int numero;
 String cliente;
 double saldo;
}

Mas para rodar nosso programa, precisamos do nosso método main. Vamos então:

• Criar uma outra classe, chamada Testadora
• Adicionar nosso método main
• Instanciar uma Conta, através do operador new.

public class Testadora {
	public static void main(String[] args) {
		new Conta();
	}
}

Sendo que, no exemplo acima, não temos nenhuma referência ao nosso objeto.

Precisamos de uma variável!

 

 

Do mesmo jeito que criamos uma variável do tipo inteira, por exemplo, criamos nossa variável do objeto.

Conta conta1;

Perceba que nosso tipo, ao invés de ser int, double ou String, é do tipo Conta.

 

Agora podemos instanciar:

Conta conta1;
conta1 = new Conta();

Podemos encurtar essa leitura, ficando:

Conta conta1 = new Conta();

Além disso, podemos acessar e modificar os atributos de conta:

Conta conta1 = new Conta();
conta1.numero = 123; // Número é um atributo de conta, do tipo inteiro.
conta1.cliente = "João"; // Cliente é do tipo String.
conta1.saldo = 1000.0; // Saldo é do tipo double, devemos usar o ponto para representar casa decimal.

Além de tudo, vamos exibir agora o número, o titular e o saldo de nossa conta:

public class Testadora {
	public static void main(String[] args) {
		Conta conta1 = new Conta();
                conta1.numero = 123; 
                conta1.cliente = "João";
                conta1.saldo = 1000.0;
                System.out.println("Número da conta: " +conta1.numero+ "  o nome do titular: " +conta1.cliente+ " e o saldo atual da conta é: "+conta1.saldo);
	}
}

Podemos retirar o valor da conta, utilizando apenas:

double valorSaque = 500.0;
conta1.saldo = conta1.saldo - valorSaque;

Com isso, modificamos os atributos de um objeto do tipo conta, apenas utilizando o "."(ponto).

Entretanto, isso não é considerado uma boa prática. Vejamos o porquê.

 

 

Vamos supor que eu tente, em tempo de execução, alterar o saldo da conta(realizando saques). Sabendo que meu saldo atual é de 500. Se eu solicitasse retirar a quantia de 700 reais (conta1.saldo = conta1.saldo - 700).

OPA! Teríamos um problema aí. O saldo da conta passaria a ser negativo, o que viola a premissa de conta poupança.

 

Uma solução sería implementarmos uma validação em cada ponto que alterassemos o saldo da conta, por exemplo:

if(conta1.saldo >= valorSaque){

conta1.saldo = conta1.saldo - valorSaque;

}

 

Com isso, apenas haveria o saque caso o saldo atual da conta for maior do que o valor de retirada.

 

Mas e se tivermos 50 chamadas para saque em nosso programa. Teríamos que implementar essa condicional 50 vezes.

Isso além de muito trabalhoso, viola o princípio de Orientação a Objetos.

 

Aí entra o conceito de encapsulamento, através do setter, que nada mais é do que um método implementado na classe Conta, que é responsável por modificar um atributo específico daquela classe. Quem melhor do que a classe conta para saber quais as regras para se efetuar um saque ?

 

 

Vamos lá!

 

• Na classe Conta, criaremos um método, denominado sacar.
• O que precisamos informar à classe Conta ao efetuarmos um saque ? O valor, é claro.

Nosso método ficará assim:

public void sacar(int valorDoSaque){
}

Public porque ele é um método público, isto é, qualquer outra classe de nosso sistema pode chamar esse método.

Void porque ele não vai retornar nada. Ele apenas vai executar a ação de sacar.

 

• Precisamos também adicionar nossa condicional, certo ?

 

Nossa classe Conta ficará assim:

public class Conta{
 private int numero;
 private String cliente;
 private double saldo;

public void sacar(int valorDoSaque){
  if(this.saldo >= valorDoSaque){ // Aqui, fazemos nossa verificação. O saldo atual tem que ser maior.
     this.saldo = this.saldo - valorDoSaque; //Se passar na condicional, vai realizar a subtração.
     System.out.println("Você acabou de sacar "+ valorDoSaque); //Vai exibir uma mensagem de confirmação
         }else{   // Caso NÃO passe na verificação, ou seja, se o saldo for menor que o saque
             System.out.println("Desculpe, mas você não possui saldo suficiente"); //Exibe uma mensagem
             } 
}

}

Vamos criar um método para depositar também:

public void depositar(int valorDeposito){
 this.saldo = this.saldo + valorDeposito;
 System.out.println("Você depositou a quantia de " +valorDeposito);
}

Perceba também que, foi inserido antes dos nossos atributos o modificador private. Isso porquê agora, eles só serão acessíveis pela própia classe conta.

 

Como nossos atributos estão encapsulados, precisamos também de um método para consultar o saldo atual, certo ?

São o que chamamos de getters, pois eles vão recuperar (get = pegar) algum valor.

 

Vejamos sua implementação.

public int obterSaldo(){
 return this.saldo;
}

Vejamos que ele retorna um valor do tipo inteiro, que nada mais é do que o nosso saldo.

Ele também não recebe nenhum parâmetros, afinal, ele não vai modificar nada.

Perceba o uso do this. Ele apenas quer dizer que estamos nos referenciando ao atributo saldo da própia classe. Isso ficará mais claro quando falarmos de herança.

 

Nossa classe Testadora ficará assim então:

public class Testadora {
	public static void main(String[] args) {
		Conta conta1 = new Conta();
               // conta1.saldo = 1000.0;  OPA! NÃO podemos mais nos referenciar aos atributos assim.
               conta1.depositar(1000.0);
               System.out.println("Saldo atual da conta é: " +conta1.obterSaldo());

               conta1.sacar(700.0) 
               System.out.println("Saldo atual da conta é: " +conta1.obterSaldo());
	}
}

E aí, já se sente preparado ? Que tal você criar os getters e setters dos outros atributos para testar seu conhecimento ?

Qualquer dúvida, podem postar.

 

 

Para não me extender muito, vamos criar o método transfere, que vai transferir o saldo de uma conta para outra.

public void transferir(Conta contaDestino, double valorTransferencia){
    this.saldo = this.saldo - valorTransferencia;
    contaDestino.depositar(valorTransferencia);
}

Perceba que, nosso método é um set, isto é, ele vai modificar valores, sem retornar nada.

Como parâmetro, devemos receber um outro objeto Conta, além do valor a ser transferido.

Primeiro vamos subtrair o valor da transferência da conta de origem, e depois realizar um depósito na conta de destino.

 

 

 

Vamos precisar instanciar 2 objetos conta em nossa classe Testadora.

// Veja que usamos variáveis diferentes. Cada uma aponta para um objeto diferente na memória
Conta c1 = new Conta();
Conta c2 = new Conta(); 

// Depositamos os valores iniciais em cada conta.
c1.depositar(1000.0);
c2.depositar(100.0);

// Vamos exibir o saldo das nossas contas
System.out.println("Saldo da conta 1: " +c1.obterSaldo());
System.out.println("Saldo da conta 2: " +c2.obterSaldo());

// Aqui vamos transferir valor da conta 1(c1) para a conta 2(c2) a quanta de 200.
// A conta que chamou o método é a conta de origem. A conta referenciada no parâmetro é a de destino.
c1.transferir(c2, 200.0);

// Exibir novamente os valores para notar as alterações
System.out.println("Saldo da conta 1: " +c1.obterSaldo());
System.out.println("Saldo da conta 2: " +c2.obterSaldo());

 

Muito bem pessoal, espero que tenham gostado desse tutorial, e que alguém possa ser beneficiado com ele.

Abraçoss e até a próxima !