public class ExercicioClasse {
private String _nome;
private String _snome;
private int _idade;
public ExercicioClasse(String _nome, String _snome, int _idade)
{
this._nome = _nome;
this._snome = _snome;
this._idade = _idade;
}
/**
* Contrutor vazio para atender as subclasses
*/
public ExercicioClasse()
{
}
public void setNome(String _mnome)
{
_nome = _mnome;
}
public String getNome()
{
return _nome;
}
public void setSNome(String _msnome)
{
_snome = _msnome;
}
public String getSNome()
{
return _snome;
}
public void setIdade(int _midade)
{
_idade = _midade;
}
public int getIdade()
{
return _idade;
}
public void mostraMensagem()
{
System.out.println("As informações inseridas foram:");
System.out.println("Nome: " + getNome());
System.out.println("Sobrenome: " + getSNome());
System.out.println("Idade: " + getIdade());
}
}
A classe abaixo, herdou as caracteristicas, da postada acima:
public class CadastroDeAmigos extends ExercicioClasse{
public static void main(String args[])
{
/**
* Primeiro trecho de código, executado, com sucesso.
*
ExercicioClasse exc = new ExercicioClasse();
exc.setNome("X");
exc.setSNome("Y");
exc.setIdade(1);
exc.mostraMensagem();
*/
List<ExercicioClasse>exc = new ArrayList<ExercicioClasse>();
exc
}
}
Na linha 17, começou meu problema, a idéia era chamar cada objeto do ArrayList. Usar cada set da classe pai, para atribuir valores no ArrayList, nas variaveis _nome, _snome e _idade.
Depois imprimir, os valores do ArrayList, através do metodo “mostraMensagem()”.
É possivel usar os sets, herdados, para atribuir os valores. E os gets e o metodo (“mostrarMensagem()”), para exibir as saidas?
Olá,
você não precisa herdar a classe ExercicioClasse para poder ter acesso aos métodos. Você pode retirar o “extends ExercicioClasse”.
Os objetos ExercicioClasse deverão ser armazenados no ArrayList exc. Para chamar os métodos do objeto armazenado você deverá acessar o índice do ArrayList e aí chamar o método desejado… compreende?
Meu entendimento sobre seu problema: criar objetos ExercicioClasse, utilizar os métodos set’s para definir nome snome e idade, e dpois chamar o método mostraMensagem() para exibir as informações de cada objeto.
seria isso msm cara :?:
se sim, alterei a classe CadastroDeAmigos, conforme abaixo:
[code]import java.util.ArrayList;
public class CadastroDeAmigos extends ExercicioClasse{
public static void main(String args[]) {
ArrayList<ExercicioClasse> myList = new ArrayList<ExercicioClasse>();
ExercicioClasse exc = new ExercicioClasse();
exc.setNome("X");
exc.setSNome("Y");
exc.setIdade(1);
ExercicioClasse exc2 = new ExercicioClasse();
exc2.setNome("X2");
exc2.setSNome("Y2");
exc2.setIdade(2);
ExercicioClasse exc3 = new ExercicioClasse();
exc3.setNome("X3");
exc3.setSNome("Y3");
exc3.setIdade(3);
myList.add(exc); // adiciona a array
myList.add(exc2); // adiciona a array
myList.add(exc3); // adiciona a array
for (ExercicioClasse e : myList) {
e.mostraMensagem(); // para cada elemento da array, ele chama o método mostraMensagem();
}
}
Ou seja, não use _ no início de nomes de variável. Também é bom não ser economico no nome das variáveis. Ao invés de sNome, é melhor chamar a variável de sobrenome.
Por que manter um construtor sem parâmetros?
Se os campos são obrigatórios, vc não deveria ter um construtor assim. Se realmente for necessário só para atender as subclasses, torne-o protected.
Deixar ou não aquela linha em branco é opcional. Eu geralmente não deixo. Algumas pessoas chegam a colocar as chaves na mesma linha, mas isso também não é 100% de acordo com a convenção do java.
Uma outra alteração que eu faria. As classes de negócio geralmente não devem realizar tarefas de view (como “mostrar mensagens”).
Nesse caso, transforme o método mostraMensagem() no toString(). E faça a exibição pela view:
[code]public class ExercicioClasse {
private String nome;
private String sobrenome;
private int idade;
public ExercicioClasse(String nome, String sobrenome, int idade) {
this.nome = nome;
this.sobrenome = sobrenome;
this.idade = idade;
}
public void setNome(String x) {
nome = x;
}
public String getNome() {
return nome;
}
public void setSobreNome(String x) {
sobrenome = x;
}
public String getSobreNome() {
return sobrenome;
}
public void setIdade(int x) {
idade = x;
}
public int getIdade() {
return idade;
}
@Override
public String toString() {
return String.sprinf("Nome: %s %n Sobrenome: %s%n Idade: %d",
getNome(), getSobrenome(), getIdade());
}
}[/code]
E na view:
[code]
public class CadastroDeAmigos {
public static void main(String args[]) {
Listlistaexercicioclasse = new ArrayList();
for (int i = 1; i <= 3; i++) {
ExercicioClasse itemexercicioclasse = new ExercicioClasse();
itemexercicioclasse.setNome("X" + i);
itemexercicioclasse.setSobreNome("Y" + i);
itemexercicioclasse.setIdade(i);
listaexercicioclasse.add(itemexercicioclasse);
}
System.out.println("As informações inseridas foram:");
for (ExercicioClasse e: listaexercicioclasse) {
System.out.println(e);
}
}
}[/code]
Finalmente, seria uma boa renomear sua classe de ExercicioClasse para Amigo. Além disso, não tem porque a classe CadastroDeAmigos fazer aquele extends ali.
Nesse bloco ele está executando realmente a view, exibindo, a saida “As informações inseridas foram:” que a principio estavam erronhamente na classe model.
Realmente, não faz sentido, vou ajustar.
Sim, não havia percebido, que era um erro. Até as primeiras respostas, de Adelar e userguj. Na verdade, “vi realmente”, assim que me passaram a forma de acesso e insersão das informações.
Vou fazer essas correções, e postar assim que ajustar.
Só me restou uma duvida, “@Override”, qual é a função?
Quando você usa o @Override você está avisando o compilador que você está sobrescrevendo um método da classe pai.
Ele não é necessário. Mesmo que vc não escreva, vc ainda vai sobrescrever métodos. Mas, usar a tag faz com que você evite erros de digitação. Se você marcar algo com @Override e não estiver sobrescrevendo nada, o compilador te avisa. Por exemplo, vamos supor que vc cometa o seguinte erro de digitação:
@Override
public String tostring() {
}
Como toString precisa do S maiúsculo, o compilador diz “O método tostring() não está sobrescrevendo nada”. E então vc vai até lá e corrige. Sem o @Override, o código também compilaria, e vc acabaria com 2 métodos. O toString(), que faz o que vc não quer, e o tostring() que faz o que vc quer, mas não está sobrescrevendo nada.
Note que essa função da tag é especialmente importante quando vc renomeia métodos. Se vc renomear um método da classe pai, que está sendo sobrescrito nas filhas, a tag irá exigir que vc renomeie corretamente em todos os filhos. Sem a tag, corre-se o risco de esquecer de renomear em algum lugar.
