Solucionado (ver solução)
Solucionado
(ver solução)
4
respostas

Dúvida Teórica sobre Encapsulamento

Boa noite pessoal, meu código rodou sem problemas, porém estou com uma dúvida teórica quanto ao encapsulamento,

No exercício em questão eu não entendi a necessidade do atributo titular, nem da necessidade dos getters e setters, já que o código rodaria sem eles e como foi possível popular os atributos da classe Cliente direto no main, sem entrar na classe Conta, fiquei em dúvida quanto a necessidade do mesmo,

Gostaria de saber se essa prática seria somente para manter o código mais organizado, facilitando a manutenção.

Caso necessitem do código:

MAIN:

package bancoEncapsulado;

public class TestaBanco {
    public static void main(String[] args) {
        Conta contaDoLuan = new Conta();
        Cliente luan = new Cliente();

        contaDoLuan.setTitular(luan);

        luan.setNome("Luan");
        luan.setCpf("111.111.111-11");
        luan.setProfissao("Assistente de Infra");

        System.out.println(contaDoLuan.getTitular().getNome());
        System.out.println(contaDoLuan.getTitular().getCpf());
        System.out.println(contaDoLuan.getTitular().getProfissao());

    }
}

CONTA:

package bancoEncapsulado;

public class Conta {
    private double saldo;
    private int numero;
    private int agencia;
    private Cliente titular;

    public double getSaldo(){
        return this.saldo;
    }

    public int getNumero(){
        return this.numero;
    }

    public void setNumero(int numero) {
        this.numero = numero;
    }

    public int getAgencia() {
        return agencia;
    }

    public void setAgencia(int agencia) {
        this.agencia = agencia;
    }

    public void deposita(double valor) {
        this.saldo += valor;        
    }

    public boolean transfere(double valor, Conta conta) {
        if (this.saldo >= valor) {
            this.saldo -= valor;
            conta.saldo += valor;
        } return false;
    }

    public Cliente getTitular() {
        return titular;
    }

    public void setTitular(Cliente titular) {
        this.titular = titular;
    }

}

CLIENTE

package bancoEncapsulado;

public class Cliente {
    private String nome;
    private String cpf;
    private String profissao;

    public String getNome() {
        return this.nome;
    }
    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getCpf() {
        return this.cpf;
    }
    public void setCpf(String cpf) {
        this.cpf = cpf;
    }

    public String getProfissao() {
        return this.profissao;
    }
    public void setProfissao(String profissao) {
        this.profissao = profissao;
    }

}

Obrigado, Luan Torres.

4 respostas

Olá Luan,

mas vc teve que utilizá-los:

        luan.setNome("Luan");
        luan.setCpf("111.111.111-11");
        luan.setProfissao("Assistente de Infra");

se não tivesse criado os métodos de acesso, vc não iria conseguir acessar os atributos da classe, pois são privados.

    private double saldo;
    private int numero;
    private int agencia;
    private Cliente titular;

Olá Luciano, muito obrigado pela resposta, mas a minha dúvida é a seguinte, se eu troco meu MAIN para o seguinte código, eu consigo executar o código sem precisar passar pela classe Conta:

        package bancoEncapsulado;

public class TestaBanco {
    public static void main(String[] args) {
        Conta contaDoLuan = new Conta();
        Cliente luan = new Cliente();

        //contaDoLuan.setTitular(luan);

        luan.setNome("Luan");
        luan.setCpf("111.111.111-11");
        luan.setProfissao("Assistente de Infra");

        System.out.println(luan.getNome());
        System.out.println(luan.getCpf());
        System.out.println(luan.getProfissao());

    }
}

O output é o mesmo, gostaria de saber se fazer da maneira abaixo seria somente uma maneira de manter o código mais organizado:

        System.out.println(contaDoLuan.getTitular().getNome());
         System.out.println(contaDoLuan.getTitular().getCpf());
         System.out.println(contaDoLuan.getTitular().getProfissao());

Att. Luan

Olá Luciano, muito obrigado pela resposta, mas a minha dúvida é a seguinte, se eu troco meu MAIN para o seguinte código, eu consigo executar o código sem precisar passar pela classe Conta:

        package bancoEncapsulado;

public class TestaBanco {
    public static void main(String[] args) {
        Conta contaDoLuan = new Conta();
        Cliente luan = new Cliente();

        //contaDoLuan.setTitular(luan);

        luan.setNome("Luan");
        luan.setCpf("111.111.111-11");
        luan.setProfissao("Assistente de Infra");

        System.out.println(luan.getNome());
        System.out.println(luan.getCpf());
        System.out.println(luan.getProfissao());

    }
}

O output é o mesmo, gostaria de saber se fazer da maneira abaixo seria somente uma maneira de manter o código mais organizado:

        System.out.println(contaDoLuan.getTitular().getNome());
         System.out.println(contaDoLuan.getTitular().getCpf());
         System.out.println(contaDoLuan.getTitular().getProfissao());

Att. Luan

solução!

Bom dia pessoal, a minha dúvida era quanto a acessar um método no Main de uma classe encapsulada como private, aparentemente o public é universal, então o Java nos permite escrever:

        System.out.println(luan.getNome());

Porém, o correto, como boa prática é escrever da seguinte maneira:

        System.out.println(contaDoLuan.getTitular().getNome());