Ajuda para resolver três questões da faculdade sobre encapsulamento em POO.
04/05/2023
0
Pessoal, boa noite!
Gostaria de pedir a ajuda de vocês para me ajudar a entender como resolvo três questões de encapsulamento. Tenho prova e estou estudando vários conteúdos, porém estou com dificuldade em entender a prática.
A teoria sobre encapsulamento e os métodos Get e set eu estou pegando. Se puderem me explicar onde está a pegadinha da lógica para resolver.
Então vou digitar aqui. Desde já agradeço a atenção:
1 - Analise o trecho de código, a representação UML da classe “Conta” e as observações a seguir:
=======================
Conta
======================
- saldo : float
+ name : String
-------------------------------------------
+ Conta(String.float)
+ getNome() : String
+ setNome(String) : void
+ sacar(float) : void
+ getSaldo(): float
Conta c = new Conta ("Maria" , 0);
String nome = " Camila ";
c.depositar (100);
c.saldo=100;
c.sacar(50);
System.out.println( c.getNome+ "," +c.getSaldo);
O que será exibido no console?
==============================================================================================
2 - Analise, passo a passo, o trecho de código e interprete seu comportamento. Para isso, considere que exista a classe “Pessoa” e que o trecho do código funcione corretamente.
Aluno aluno1 = new Aluno("Joana");
Aluno aluno2 = aluno;
Aluno aluno3 = new Aluno(aluno.getNome());
aluno.setNome("Maria");
System.out.println(aluno1.getNome());
System.out.println(aluno2.getNome());
System.out.println(aluno3.getNome());
Qual será a sequência correta dos nomes.
====================================================================================================
3- Considere a existência de um método setNome com a seguinte implementação:
Na sequência, analise o trecho de código, passo a passo, e interprete seu comportamento:
public void setNome(String nome) {
nome = nome;
}
Aluno aluno1 = new Aluno("Joana");
Aluno aluno2 = aluno1;
aluno2.nome = " Mariana ";
Aluno aluno3 = new Aluno(aluno2.getNome());
aluno.setNome("Maria");
System.out.println(aluno1.getNome());
System.out.println(aluno2.getNome());
System.out.println(aluno3.getNome());
Qual será a sequência dos nomes?
Gostaria de pedir a ajuda de vocês para me ajudar a entender como resolvo três questões de encapsulamento. Tenho prova e estou estudando vários conteúdos, porém estou com dificuldade em entender a prática.
A teoria sobre encapsulamento e os métodos Get e set eu estou pegando. Se puderem me explicar onde está a pegadinha da lógica para resolver.
Então vou digitar aqui. Desde já agradeço a atenção:
1 - Analise o trecho de código, a representação UML da classe “Conta” e as observações a seguir:
=======================
Conta
======================
- saldo : float
+ name : String
-------------------------------------------
+ Conta(String.float)
+ getNome() : String
+ setNome(String) : void
+ sacar(float) : void
+ getSaldo(): float
Conta c = new Conta ("Maria" , 0);
String nome = " Camila ";
c.depositar (100);
c.saldo=100;
c.sacar(50);
System.out.println( c.getNome+ "," +c.getSaldo);
O que será exibido no console?
==============================================================================================
2 - Analise, passo a passo, o trecho de código e interprete seu comportamento. Para isso, considere que exista a classe “Pessoa” e que o trecho do código funcione corretamente.
Aluno aluno1 = new Aluno("Joana");
Aluno aluno2 = aluno;
Aluno aluno3 = new Aluno(aluno.getNome());
aluno.setNome("Maria");
System.out.println(aluno1.getNome());
System.out.println(aluno2.getNome());
System.out.println(aluno3.getNome());
Qual será a sequência correta dos nomes.
====================================================================================================
3- Considere a existência de um método setNome com a seguinte implementação:
Na sequência, analise o trecho de código, passo a passo, e interprete seu comportamento:
public void setNome(String nome) {
nome = nome;
}
Aluno aluno1 = new Aluno("Joana");
Aluno aluno2 = aluno1;
aluno2.nome = " Mariana ";
Aluno aluno3 = new Aluno(aluno2.getNome());
aluno.setNome("Maria");
System.out.println(aluno1.getNome());
System.out.println(aluno2.getNome());
System.out.println(aluno3.getNome());
Qual será a sequência dos nomes?
Lucas Awad
Curtir tópico
+ 0
Responder
Post mais votado
04/05/2023
A questão 1 tem alguns problemas.
1.1 - A definição da classe Conta não indica o método depositar()
1.2 - Uma vez que existem os métodos sacar() e depositar(), não é uma boa prática permitir que a propriedade saldo seja acessada diretamente, para alteração.
1.3 - Nem todas as linguagens conseguem concatenar texto e número, de forma implícita. Então, poderia dar algum erro.
Supondo que nada disso ocorra, entendo que a conta Maria foi criada com saldo inicial zero. Foi feito um depósito de 100 e saque de 50. Portanto, o resultado deveria ser 'Maria, 50'.
A questão 2 faz referência a uma instância "aluno" que, aparece de forma indefinida. Caso ela esteja instanciada corretamente, entendo que os nomes a serem exibidos deveriam ser:
Joana
Maria
<indefinido>
A questão 3 tem uma pegadinha no método. Em princípio, eu entendo que o escopo do parâmetro de um método sobrepõe o escopo de uma propriedade da classe. Logo, chamar o método não altera o nome da classe. Portanto, acho que os nomes exibidos seriam:
Mariana
Mariana
Mariana
1.1 - A definição da classe Conta não indica o método depositar()
1.2 - Uma vez que existem os métodos sacar() e depositar(), não é uma boa prática permitir que a propriedade saldo seja acessada diretamente, para alteração.
1.3 - Nem todas as linguagens conseguem concatenar texto e número, de forma implícita. Então, poderia dar algum erro.
Supondo que nada disso ocorra, entendo que a conta Maria foi criada com saldo inicial zero. Foi feito um depósito de 100 e saque de 50. Portanto, o resultado deveria ser 'Maria, 50'.
A questão 2 faz referência a uma instância "aluno" que, aparece de forma indefinida. Caso ela esteja instanciada corretamente, entendo que os nomes a serem exibidos deveriam ser:
Joana
Maria
<indefinido>
A questão 3 tem uma pegadinha no método. Em princípio, eu entendo que o escopo do parâmetro de um método sobrepõe o escopo de uma propriedade da classe. Logo, chamar o método não altera o nome da classe. Portanto, acho que os nomes exibidos seriam:
Mariana
Mariana
Mariana
Arthur Heinrich
Responder
Mais Posts
04/05/2023
Lucas Awad
A questão 1 tem alguns problemas.
1.1 - A definição da classe Conta não indica o método depositar()
1.2 - Uma vez que existem os métodos sacar() e depositar(), não é uma boa prática permitir que a propriedade saldo seja acessada diretamente, para alteração.
1.3 - Nem todas as linguagens conseguem concatenar texto e número, de forma implícita. Então, poderia dar algum erro.
Supondo que nada disso ocorra, entendo que a conta Maria foi criada com saldo inicial zero. Foi feito um depósito de 100 e saque de 50. Portanto, o resultado deveria ser ''Maria, 50''.
A questão 2 faz referência a uma instância "aluno" que, aparece de forma indefinida. Caso ela esteja instanciada corretamente, entendo que os nomes a serem exibidos deveriam ser:
Joana
Maria
<indefinido>
A questão 3 tem uma pegadinha no método. Em princípio, eu entendo que o escopo do parâmetro de um método sobrepõe o escopo de uma propriedade da classe. Logo, chamar o método não altera o nome da classe. Portanto, acho que os nomes exibidos seriam:
Mariana
Mariana
Mariana
1.1 - A definição da classe Conta não indica o método depositar()
1.2 - Uma vez que existem os métodos sacar() e depositar(), não é uma boa prática permitir que a propriedade saldo seja acessada diretamente, para alteração.
1.3 - Nem todas as linguagens conseguem concatenar texto e número, de forma implícita. Então, poderia dar algum erro.
Supondo que nada disso ocorra, entendo que a conta Maria foi criada com saldo inicial zero. Foi feito um depósito de 100 e saque de 50. Portanto, o resultado deveria ser ''Maria, 50''.
A questão 2 faz referência a uma instância "aluno" que, aparece de forma indefinida. Caso ela esteja instanciada corretamente, entendo que os nomes a serem exibidos deveriam ser:
Joana
Maria
<indefinido>
A questão 3 tem uma pegadinha no método. Em princípio, eu entendo que o escopo do parâmetro de um método sobrepõe o escopo de uma propriedade da classe. Logo, chamar o método não altera o nome da classe. Portanto, acho que os nomes exibidos seriam:
Mariana
Mariana
Mariana
Amigo. Obrigado pela atenção.
Eles colocam o código não perfeito para execução, mas para tentar pegar alguma lógica e avaliar se o aluno entende. Acho que é isso.
Vou passar as respostas e pedir mais ajuda.
Questão 1 é isso mesmo Maria,50. Essa eu entendi em parte, mas a minha confusão é o por quê do string nome = " Camila "; o getNome não busca a Camila?
Questão 2 é Maria, Maria e Joana.
Questão 3 é isso também. Mariana, Mariana, Mariana. A 2 e 3 estou mais confuso, mas vou tentar entender. Poderia indicar o trecho que tem a pegadinha?
Responder
05/05/2023
Arthur Heinrich
Na questão 1, a linha:
String nome = " Camila ";
Atribui o texto " Camila " a uma variável do tipo String chamada "nome".
Embora a propriedade da classe tenha o mesmo nome, não estão relacionadas.
Se fosse:
c.nome = " Camila ";
A estória seria outra, já que acessaria a propriedade da classe "c".
String nome = " Camila ";
Atribui o texto " Camila " a uma variável do tipo String chamada "nome".
Embora a propriedade da classe tenha o mesmo nome, não estão relacionadas.
Se fosse:
c.nome = " Camila ";
A estória seria outra, já que acessaria a propriedade da classe "c".
Responder
05/05/2023
Arthur Heinrich
Vamos analisar o item 2 linha a linha:
Aluno aluno1 = new Aluno("Joana");
- Classe aluno1 instanciada com nome Joana
Aluno aluno2 = aluno;
- Variável aluno2 aponta para a classe aluno, de nome desconhecido. Temos agora duas variáveis apontando para a instância desconhecida.
Aluno aluno3 = new Aluno(aluno.getNome());
- Classe aluno3 instanciada com o nome indefinido da classe aluno.
aluno.setNome("Maria");
- O nome da instância aluno foi alterada para Maria. Como aluno2 aponta para a mesma instância, aluno2 vira Maria junto.
System.out.println(aluno1.getNome());
- A classe aluno1 foi instanciada com nome Joana e não foi alterada. Por isso, o primeiro nome deve ser Joana.
System.out.println(aluno2.getNome());
- O segundo nome será Maria
System.out.println(aluno3.getNome());
- A classe aluno3 é instanciada com o nome da instância aluno, antes de ter o nome alterado para Maria. No código, não há indicação de qual seria o nome original da instância aluno.
Aluno aluno1 = new Aluno("Joana");
- Classe aluno1 instanciada com nome Joana
Aluno aluno2 = aluno;
- Variável aluno2 aponta para a classe aluno, de nome desconhecido. Temos agora duas variáveis apontando para a instância desconhecida.
Aluno aluno3 = new Aluno(aluno.getNome());
- Classe aluno3 instanciada com o nome indefinido da classe aluno.
aluno.setNome("Maria");
- O nome da instância aluno foi alterada para Maria. Como aluno2 aponta para a mesma instância, aluno2 vira Maria junto.
System.out.println(aluno1.getNome());
- A classe aluno1 foi instanciada com nome Joana e não foi alterada. Por isso, o primeiro nome deve ser Joana.
System.out.println(aluno2.getNome());
- O segundo nome será Maria
System.out.println(aluno3.getNome());
- A classe aluno3 é instanciada com o nome da instância aluno, antes de ter o nome alterado para Maria. No código, não há indicação de qual seria o nome original da instância aluno.
Responder
05/05/2023
Frank Hosaka
Eu achei bem difícil o enunciado, o máximo que eu consegui foi isso:
<script>
class conta {
saldo
nome
constructor(nome,saldo){
this.nome=nome
this.saldo=saldo}
depositar(dinheiro){this.saldo=this.saldo+dinheiro}
sacar(dinheiro){this.saldo=this.saldo-dinheiro}}
c=new conta("Maria",0)
c.nome="Camila"
c.depositar(100)
c.saldo=100
alert(c.nome+","+c.saldo)
// resultado: Camila, 100
class aluno {
aluno1
aluno2
aluno3
constructor($aluno1){this.aluno1=$aluno1}
getNome(){return this.aluno3}
setNome(nome){void(this.aluno2=nome)}
}
aluno1=new aluno("Joana");aluno.aluno1=aluno1.aluno1
aluno.aluno2=aluno
aluno.aluno3=aluno.getNome
aluno.aluno2=aluno.setNome="Maria"
alert(aluno.aluno1+", "+aluno.aluno2+", "+aluno.aluno3)
// resultado: Joana, Maria, undefined
aluno1=new aluno('Joana');aluno.aluno1=aluno1.aluno1
aluno.aluno2=aluno1.aluno1
aluno.aluno2="Mariana"
aluno2=aluno.aluno2;aluno3=new aluno(aluno2);aluno.aluno3=aluno3.aluno3
aluno.setNome="Maria"
alert(aluno.aluno1+", "+aluno.aluno2+", "+aluno.aluno3)
// resultado: Joana, Mariana, undefined
</script>
Responder
Clique aqui para fazer login e interagir na Comunidade :)