Prazer a todos. Eu tenho dúvida quanto a implementar vetores com os getters e setters, entendi perfeitamente os conceitos e funcionamentos dos getters e setters, porém como devo aplicar quando tenho um vetor? Pois posso tem 100 itens de um produto, 100 nomes. Devo fazer como abaixo?
private String[] nome;
private int[] data;
int i;
public void setData(int[] data) {
this.data[i] = data;
}
public void setNome(String[] Nome){
this.nome[i] = nome;
como exemplo:
Depende do resultado que você deseja obter, e de quais funcionalidades você quer suportar.
Por exemplo, você pode querer substituir o vetor inteiro, e retorná-lo inteiro também:
private TipoQualquer[] tipo;
public void setTipoQualquer(TipoQualquer[] t){
this.tipo = t;
}
public TipoQualquer[] getTipo(){
return this.tipo;
}
Nesse caso, você está permitindo acessá-lo externamente sem filtros, e possivelmente é mais simples deixá-lo como public.
Outra opção é tratar o vetor como uma lista, usando um índice para controlar a posição alterada:
private TipoQualquer[] tipo;
public void setTipoNaPosicao(int indice, TipoQualquer t){
this.tipo[indice] = t;
}
public TipoQualquer getTipoNaPosicao(int indice){
return this.tipo[indice];
}
Esse segundo caso pode ser expandido para ter métodos que pegam se uma posição está preenchida (algo como existe() ou contains()), se há elementos na lista (isEmtpy()), métodos para remoção e adição de elementos verificando o estado atual, etc, e usando um atributo auxiliar oara facilitar esse controle (como o i no seu código).
private TipoQualquer[] tipo;
private int indiceInterno = 0;
public void adicionar(TipoQualquer ti){
this.tipo[indiceInterno] = t;
this.indiceInterno++;
}
public void existe(int indice){
return this.tipo[indice] != null;
}
Abraço.
Muito obrigado pela pronta resposta, vou olhar com cuidado para implementar corretamente e entender os conceitos. Depois posto o código completo quando pronto.
Resolvi e apliquei, porém há somente um erro no qual eu não consigo resolver. Um tipo não é aplicável para o tipo de argumentos. Vou colocar o código aqui.`package pck;
import java.util.Scanner;
public class main {
//public static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
Disciplina disciplina = new Disciplina();
int qtdeNotas = 0;
String nome, nomeDisciplina;
int idade = 0, turma = 0;
double nota = 0;
int qtdeAlunos, i = 0;
//Aluno aluno = new Aluno();// o construtor está na classe Aluno, como pode estar indefinido? Pedindo construtor vazio porque?
//disciplina.adicionarAluno(nome,idade,turma, nomeDisciplina);
/*
* Aluno aluno = new Aluno();
//Aluno a1 = new Aluno("Ricardo", 31, 1);
//Aluno a1 = null;
//Aluno a2 = new Aluno("Ana Elisa", 17, 1);
//Aluno a3 = new Aluno("Geovana", 18, 2);
//Aluno a4 = new Aluno("Livia", 20, 2);
Cliente cliente1 = new Cliente();
cliente1.setNome = "Fulano";
int[] vetor = new int[5];
*/
Scanner sc = new Scanner(System.in);
System.out.println("\nEntre com a quantidade de alunos: ");
qtdeAlunos = sc.nextInt();
Aluno aluno = new Aluno();
Aluno[] alunos = new Aluno[qtdeAlunos];
sc.nextLine();
//for (int a = 0;a < qtdeAlunos;a++) {
for(int a = 0; a < alunos.length; a++) {
System.out.println("Entre com o nome: ");
//alunos[i] = scanner.nextLine();
//alunos[i] = sc.nextLine();//este valor é passado para o construtor.
aluno.setNome(sc.nextLine());
System.out.println("Entre com o nome da Discipĺina: ");
aluno.setnomeDisciplina(sc.nextLine());
System.out.println("Entre com a idade: ");
aluno.setIdade(sc.nextInt());
System.out.println("Entre com o número da turma: ");
aluno.setTurma(sc.nextInt());
System.out.println("Entre com a quantidade de notas: ");
qtdeNotas = sc.nextInt();
sc.nextLine();
for (a = 0;a < qtdeNotas;a++)
{
System.out.println("\nEntre com a nota: " + (a + 1));
alunos[i].setNota(sc.nextLine());
disciplina.adicionarAluno(aluno);
// recebe os dados enviados pelo usuário e enviar para o construtor.
//e passa para as variáveis dentro da classe.
//sc.next();
}
}
sc.close();
//disciplina.adicionarAluno(a2);
//disciplina.adicionarAluno(a3);
//disciplina.adicionarAluno(a4);
System.out.println("Quantidade de alunos: " + disciplina.getNumAlunos());
disciplina.exibirInformacoes();
System.out.println("Antes de remover alunos. ");
//removendo aluno
//disciplina.removerAluno(a2);
disciplina.exibirInformacoes();
System.out.println("Despois de remover alunos. ");
disciplina.exibirInformacoes();
System.out.println("Quantidade de alunos: " + disciplina.getNumAlunos() + "\n");
System.exit(0);
}
}
E a classe aluno onde estão os getters e setters com o construtor.
`package pck;
import pck.Disciplina;
public class Aluno {
private String[] Nome;
String nomeDisciplina;
int idade, turma, i, qtdeNotas;
private double[] nota;
private double[] nota_total;
public Aluno() {//para evitar erro, pois ainda não foi passad nenhum valor.
this.nota = new double[3];
this.nota_total = new double[3];
}
public Aluno(String[] nomeAluno, String nomeDisciplina, int idade, int turma, double[] nota) {
//setNome(nomeAluno);
this.Nome = nomeAluno;
this.nomeDisciplina = nomeDisciplina;
this.idade = idade;
this.turma = turma;
this.nota = nota;
}
public void setNome(String[] aluno) {// atribui um valor para o atributo nome.
this.Nome = aluno;
}
//this.nome = nome;
//setNome(nome);// vem do construtor, para onde é passado o valor digitado pelo usuário.
public String[] getNome() {
return Nome;
}
public String getnomeDisciplina() {//Disciplina
return nomeDisciplina;
}
public void setnomeDisciplina(String nomeDisciplina) {//set de disciplina
this.nomeDisciplina = nomeDisciplina;
}
public void setIdade(int idade) {
this.idade = idade;
}
public int getIdade() {
return idade;
}
public void setTurma(int turma) {
this.turma = turma;
}
public int getTurma() {
return turma;
}
public void setNota(double[] nota) {//está correto
this.nota = nota;
}
public double[] getNota() {//está correto
return nota;
}
public void setqtdeNotas(int qtdeNotas) {
this.qtdeNotas = qtdeNotas;
}
public int getqtdeNotas() {
return qtdeNotas;
}
public double calcularNota() {
return nota_total[i] += this.nota[i] / qtdeNotas;
}
public String mostrarInformacoes() {
if (nota_total[i] >= 7) {
System.out.println("Aluno aprovado." + nota_total[i]);
}
else {
System.out.println("Aluno reprovado." + nota_total[i]);
}
return "Nome: " + getNome() + "\nIdade: " + getIdade() + "\nTurma: " + getTurma() +
"\nDisciplina: " + getnomeDisciplina() +
"\nNota: " + getNota() +
"\nNota_total " + calcularNota() +
"\n##############";
}
}
Estas duas linha apresentam o mesmo erro.
aluno.setNome(sc.nextLine());```e alunos[i].setNota(sc.nextLine());
Não sei porque está tentando converter, Aluno é um objeto. Aprendi assim: cria o objeto e acessa o atributo dele podendo preencher pelo scanner ou somente o scanner sem ou `alunos[i] = sc.nextLine();``Este último também dá erro, não pode converter de String para objeto Aluno. Verifiquei e estudei mais sobre getters e setters e estão corretos. Obrigado.
Esqueci, não é nextLine e sim nextDouble, mesmo assim não funciona.
Um aluno tem vários nomes?
Bem consertei, Aluno é uma classe e tem vários alunos, então pensei, no banco e a coluna onde nome onde aparecerá a coluna com estes nomes, por isso pensei no vetor. Depois eu tirei até resolver os erros. Quase consertei, o cálculo está errado e não sei porque a nota está pegando o endereço e não devolvendo o valor.`package pck;
import java.util.Scanner;
public class main {
//public static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
Disciplina disciplina = new Disciplina();
int qtdeNotas = 0;
String nome = “”;
String nomeDisciplina;
int idade = 0, turma = 0;
int qtdeAlunos, i = 0;
//Aluno aluno = new Aluno();// o construtor está na classe Aluno, como pode estar indefinido? Pedindo construtor vazio porque?
//disciplina.adicionarAluno(nome,idade,turma, nomeDisciplina);
/*
* Aluno aluno = new Aluno();
//Aluno a1 = new Aluno(“Ricardo”, 31, 1);
//Aluno a1 = null;
//Aluno a2 = new Aluno(“Ana Elisa”, 17, 1);
//Aluno a3 = new Aluno(“Geovana”, 18, 2);
//Aluno a4 = new Aluno(“Livia”, 20, 2);
Cliente cliente1 = new Cliente();
cliente1.setNome = "Fulano";
int[] vetor = new int[5];
*/
Scanner sc = new Scanner(System.in);
System.out.println("\nEntre com a quantidade de alunos: ");
qtdeAlunos = sc.nextInt();
Aluno aluno = new Aluno();
Aluno[] alunos = new Aluno[qtdeAlunos];
sc.nextLine();
//for (int a = 0;a < qtdeAlunos;a++) {
for(int a = 0; a < alunos.length; a++) {
//emp.nome = sc.nextLine();
System.out.println("Entre com o nome: ");
nome = sc.nextLine();
//alunos[i] = sc.nextLine();
aluno.setNome(nome);
System.out.println("Entre com o nome da Discipĺina: ");
aluno.setnomeDisciplina(sc.nextLine());
System.out.println("Entre com a idade: ");
aluno.setIdade(sc.nextInt());
System.out.println("Entre com o número da turma: ");
aluno.setTurma(sc.nextInt());
System.out.println("Entre com a quantidade de notas: ");
qtdeNotas = sc.nextInt();
sc.nextLine();
double[] nota = new double[qtdeNotas];
for (a = 0;a < qtdeNotas;a++)
{
System.out.println("\nEntre com a nota: " + (a + 1));
nota[i] = sc.nextDouble();
aluno.setNota(nota);
//alunos[i].setNota(sc.nextDouble());
disciplina.adicionarAluno(aluno);
// recebe os dados enviados pelo usuário e enviar para o construtor.
//e passa para as variáveis dentro da classe.
//sc.next();
}
}
sc.close();
//disciplina.adicionarAluno(a2);
//disciplina.adicionarAluno(a3);
//disciplina.adicionarAluno(a4);
System.out.println("Quantidade de alunos: " + disciplina.getNumAlunos());
disciplina.exibirInformacoes();
System.out.println("Antes de remover alunos. ");
//removendo aluno
//disciplina.removerAluno(a2);
disciplina.exibirInformacoes();
System.out.println("Despois de remover alunos. ");
disciplina.exibirInformacoes();
System.out.println("Quantidade de alunos: " + disciplina.getNumAlunos() + "\n");
System.exit(0);
}
}
Ainda tem erros, agora vou pesquisar porque o valor não é retornado. Entrei com a variável de qtdeNotas e fiz o encapsulamento, não descobri o erro.
Saída do algoritmo:
Quantidade de alunos: 2
Aluno reprovado.0.0
Nome: paulo
Idade: 38
Turma: 2
Disciplina: mat
Nota: [D@1540e19d
Nota_total Infinity
##############
Aluno aprovado.Infinity
Nome: paulo
Idade: 38
Turma: 2
Disciplina: mat
Nota: [D@1540e19d
Nota_total Infinity
##############
Antes de remover alunos.
Aluno aprovado.Infinity
Nome: paulo
Idade: 38
Turma: 2
Disciplina: mat
Nota: [D@1540e19d
Nota_total Infinity
##############
Aluno aprovado.Infinity
Nome: paulo
Idade: 38
Turma: 2
Disciplina: mat
Nota: [D@1540e19d
Nota_total Infinity
##############
Despois de remover alunos.
Aluno aprovado.Infinity
Nome: paulo
Idade: 38
Turma: 2
Disciplina: mat
Nota: [D@1540e19d
Nota_total Infinity
##############
Aluno aprovado.Infinity
Nome: paulo
Idade: 38
Turma: 2
Disciplina: mat
Nota: [D@1540e19d
Nota_total Infinity
##############
Quantidade de alunos: 2`
Quando entender bem o funcionamento ai sim vou para array list. Assim terei pego bem os fundamentos. Tenho de praticar bastante para pegar prática.
Então você vai ter uma lista ou um array de objetos do tipo Aluno.
O que você fez foi um array de nomes como sendo atributo do aluno.
Sim, isso mesmo, vou corrigir. E a nota, não sei porque dá infinity, vi setter e getter e o main e estão certos. Não entendi o erro. Obrigado pela ajuda.
Você está dividindo um número real por zero, aí o resultado é infinito.
Refiz tudo, porém há erro na inserção do vetor. Verifiquei e vi outros exemplos, parece tudo certo, não compreendeo o erro.
Qual o erro?
Posta o código refeito, não tem como adivinhar a forma que você implementou.
Sim, não tinha colocado, pressa nas coisas.
package pck;
import java.util.Scanner;
public class main {
//public static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
Disciplina disciplina = new Disciplina();
double soma = 0, nota = 0;
int qtdeNotas = 0;
String nome = "";
String nomeDisciplina = " ";
int idade = 0, turma = 0;
int qtdeAlunos = 0;
//Aluno aluno = new Aluno();// o construtor está na classe Aluno, como pode estar indefinido? Pedindo construtor vazio porque?
//disciplina.adicionarAluno(nome,idade,turma, nomeDisciplina);
/*
* Aluno aluno = new Aluno();
//Aluno a1 = new Aluno("Ricardo", 31, 1);
//Aluno a1 = null;
//Aluno a2 = new Aluno("Ana Elisa", 17, 1);
//Aluno a3 = new Aluno("Geovana", 18, 2);
//Aluno a4 = new Aluno("Livia", 20, 2);
Cliente cliente1 = new Cliente();
cliente1.setNome = "Fulano";
int[] vetor = new int[5];
*/
Scanner sc = new Scanner(System.in);
System.out.println("\nEntre com a quantidade de alunos: ");
qtdeAlunos = sc.nextInt();
Aluno[] alunos = new Aluno[qtdeAlunos];
sc.nextLine();
//for (int a = 0;a < qtdeAlunos;a++) {
for(int a = 0; a < qtdeAlunos; a++) {
//emp.nome = sc.nextLine();
System.out.println("Entre com o nome: ");
nome = sc.nextLine();
System.out.println("Entre com o nome da Discipĺina: ");
nomeDisciplina = sc.nextLine();
System.out.println("Entre com a idade: ");
idade = sc.nextInt();
System.out.println("Entre com o número da turma: ");
turma = sc.nextInt();
//alunos=alunos[a];
System.out.println("Entre com a quantidade de notas: ");
qtdeNotas = sc.nextInt();
//double nota = new double[qtdeNotas];
for (a = 0;a < qtdeNotas;a++)
{
System.out.println("\nEntre com a nota: " + (a + 1));
nota = sc.nextDouble();
//System.out.println(nota[a]);
//soma += nota[a];
// recebe os dados enviados pelo usuário e enviar para o construtor.
//e passa para as variáveis dentro da classe.
//sc.next();
}
alunos[a] = new Aluno(nome, nomeDisciplina, idade, turma , nota);
disciplina.adicionarAluno(alunos[a], a);
}
sc.close();
//disciplina.adicionarAluno(a2);
//disciplina.adicionarAluno(a3);
//disciplina.adicionarAluno(a4);
System.out.println("Quantidade de alunos: " + disciplina.getNumAlunos());
disciplina.exibirInformacoes();
System.out.println("Antes de remover alunos. ");
//removendo aluno
//disciplina.removerAluno(a2);
disciplina.exibirInformacoes();
System.out.println("Despois de remover alunos. ");
disciplina.exibirInformacoes();
System.out.println("Quantidade de alunos: " + disciplina.getNumAlunos() + "\n");
System.exit(0);
}
/*Exemplo de um vetor.
* Teste[] teste1;
* int testes;
*
*public Vetor(int numero){
*this.teste1 = new Teste[numero];
*}
**/
}código principal.
Classe Disciplina com inserção dos valores:
package pck;
public class Disciplina {
private Aluno[] alunos; //declaração do vetor
private Disciplina[] disciplina;
private int posicao;
String nome;
int i;
public Disciplina() {
this.alunos = new Aluno[40];//construtor, quando cria a disciplina, cria automaticamente um vetor Aluno de 40 posições.
this.disciplina = new Disciplina[10];
//criação do vetor
}
public int getNumAlunos() {
int cont = 0;
for (int i = 0; i < alunos.length; i++) {
if(alunos[i] != null) {//se a posição é diferente de null não conta.
cont++;
}
}
return cont;//retorna o número de alunos.
}
/* public void adicionarAluno(Aluno aluno) {
if(alunos != null){
this.alunos[posicao] = aluno;
posicao = posicao + 1;
//return true;
} else {
System.out.println(“Valor deve ser preenchido”);
//return false;//aluno não foi adicionado.
}
} */
public boolean adicionarAluno(Aluno aluno, int posicao) {
if(alunos != null){
this.alunos[posicao] = aluno;
posicao = posicao + 1;
return true;
} else {
System.out.println("Valor deve ser preenchido");
return false;//aluno não foi adicionado.
}
}
public boolean removerAluno(Aluno aluno) {//verifica sem existe nome, idade, e turma, as três tem de ser verificadas, pois podem haver repetições.
for(int i = 0; i < alunos.length; i++) {//para remover o aluno do vetor. Excluindo pelo nome, idade e turma.
if((alunos[i].getNome() == aluno.getNome()) &&
(alunos[i].getIdade() == aluno.getIdade()) &&
(alunos[i].getTurma() == aluno.getTurma()) &&
(alunos[i].getnomeDisciplina() == aluno.getnomeDisciplina())) {
alunos[i] = null;//remove um aluno
return true;
} //aqui não podemos, após esta chave, por causa da posição do vetor, por exemplo, aluno na posição 3.
//por causa da iteração, o for não estará na posição 0. Pode estar em outra posição. Ele pode não estar na posição 0 e retorna false,
//queremos que percorra todo o vetor e não encontrar a condição do if acima.
}
return false;//caso não encontre na primeira posição, pode estar em outra posição de 0 a 4. Tem de percorrer todo o vetor e não cair dentro do if.
//por isso não tem o else e o return está fora da condição. False é porque não está no vetor.
}
//exibir as informações de todos os alunos.
public void exibirInformacoes() {
//for (int i = 0; i < alunos.length;i++)
for(i = 0; i < this.alunos.length; i ++){
if (alunos[i] != null)//if para evitar exceção se a posição for null pela informação removida, pois a posição não tem mais dados, está vazia.
System.out.println(alunos[i].mostrarInformacoes());//chama o método já pronto mostrarInformações que está na classe Aluno. Mostra somente posições com valores.
}
}
}
Classe Aluno com os getters e setters e construtor.
package pck;
import pck.Disciplina;
public class Aluno {
private String Nome;
private String nomeDisciplina;
private int idade, turma, i, qtdeNotas;
private double nota;
private double nota_total;
double soma = 0;
public void setNome(String nome) {// atribui um valor para o atributo nome.
this.Nome = nome;
}
//this.nome = nome;
//setNome(nome);// vem do construtor, para onde é passado o valor digitado pelo usuário.
public String getNome() {
return this.Nome;
}
public String getnomeDisciplina() {//Disciplina
return nomeDisciplina;
}
public void setnomeDisciplina(String nomeDisciplina) {//set de disciplina
this.nomeDisciplina = nomeDisciplina;
}
public void setIdade(int idade) {
this.idade = idade;
}
public int getIdade() {
return idade;
}
public void setTurma(int turma) {
this.turma = turma;
}
public int getTurma() {
return turma;
}
public void setNota(double nota) {//está correto
this.nota = nota;
}
public double getNota() {//está correto
return nota;
}
public void setqtdeNotas(int qtdeNotas) {
this.qtdeNotas = qtdeNotas;
}
public int getqtdeNotas() {
return qtdeNotas;
}
public double calcularNota() {
nota_total = nota_total + nota;
return nota_total;
}
public String mostrarInformacoes() {
return "Nome: " + getNome() + "\nIdade: " + getIdade() + "\nTurma: " + getTurma() +
"\nDisciplina: " + getnomeDisciplina() +
"\nNota: " + getNota() +
"\n##############";
}
public Aluno() {//para evitar erro, pois ainda não foi passado nenhum valor.
this.idade = 0;
}
public Aluno(String nomeAluno, String nomeDisciplina, int idade, int turma, double nota) {
this.Nome = nomeAluno;
this.nomeDisciplina = nomeDisciplina;
this.idade = idade;
this.turma = turma;
this.nota = nota;
}
}
No final, quando vou inserir a nota, erro na linha 70. Minha dúvida é onde e como colocar os vetores, eu os declarei, revi setter e getters. Nem sei se os getters e setters precisam do vetor, entende, pois no método adicionarAluno já está declarado um vetor.
Por que a classe Aluno só tem uma nota?
Deveria ser um array de notas e nem precisa dos atributos quantidadeNotas, soma e total.
Eu estou tentanto ainda fazendo somente com uma nota, para depois tornar mais complexo e ver se está funcionando. Ainda tenho dificuldades e não quero usar arraylists que ainda não estudei. Ali na classe Aluno eu devo declarar um vetor de notas e aplicar public void setNota(double[] nota), seria isso? e no getter também.public TipoQualquer getTipoNaPosicao(int indice){ return this.tipo[indice]; }
Obrigado, está sendo de grande ajuda.
Sim, declare um atributo de instância, do tipo array, para armazenar suas notas.
Mas os métodos faça assim:
void setNota(int posicao, double nota) {
notas[posicao] = nota;
}
double getNota(int posicao,) {
return notas[posicao];
}
double getMedia() {
double media = 0;
// Aqui faz o loop pra calcular a média
return media;
}package pck;
import java.util.Scanner;
import pck.Disciplina;
import pck.Aluno;
public class main {
public static void main(String[] args) {
Aluno[] aluno = new Aluno[2];
//double[] nota = new double[3];
int acm = 0, j, i = 0;
//Aluno a1 = new Aluno("Ricardo", 31, 1);
Scanner sc = new Scanner(System.in);
Scanner nomeDisciplina = new Scanner(System.in);
Scanner numeroDeDisciplinas = new Scanner(System.in);
Disciplina disciplina = new Disciplina();
//disciplina.adicionarAluno(a1);
//for(int i = 0; i < aluno.length;i++)
while(i < aluno.length){
Aluno alunos = new Aluno();
System.out.println("Entre com o nome do aluno: "+(i+1));
alunos.setNome(sc.nextLine());
System.out.println("Entre com a idade do aluno: "+(i+1));
alunos.setIdade(sc.nextInt());
System.out.println("Entre com as três notas do aluno: " + (i+1));
while (acm < 3) {
System.out.println("Entre com a nota " + (acm+1) + " do aluno ");
alunos.setNota(sc.nextDouble());
acm = acm + 1;
}
System.out.println("Entre com o número da turma do aluno: "+(i+1));
alunos.setTurma(sc.nextInt());
sc.nextLine();
System.out.println("Entre com o nome da disciplina cursada: "+(i+1));
alunos.setnomeDisciplina(nomeDisciplina.nextLine());
System.out.println("Entre com o numero de disciplinas cursadas pelo aluno: "+(i+1));
alunos.setnumeroDeDisciplinas(numeroDeDisciplinas.nextInt());
disciplina.adicionarAluno(alunos);
i++;
}
System.out.println("Quantidade de alunos: " + disciplina.getNumAlunos());
System.out.println("Antes de remover alunos. ");
disciplina.exibirInformacoes();
//removendo aluno
System.out.println("Despois de remover alunos. ");
disciplina.exibirInformacoes();
System.out.println("Quantidade de alunos: " + disciplina.getNumAlunos() + "\n");
}
}
package pck;
import pck.Disciplina;
public class Aluno {
private String nomeDisciplina;
private int numeroDeDisciplinas;
private String nome;
private int idade, turma, cont = 0;
private Double nota = 0.0, soma = 0.0, media = 0.0;
Aluno[] notas = new Aluno[3];
//Aluno notas = new Aluno();
//private Disciplina disciplina;
int i = 0;
public Aluno() {
this.nome="FuncPadrao";
this.idade=0;
this.nota=0.0;
}
public Aluno(String nomeDisciplina, int numeroDeDisciplinas, String nome, int idade, int turma, double nota) {
this.nomeDisciplina = nomeDisciplina;
this.numeroDeDisciplinas = numeroDeDisciplinas;
this.nome = nome;
this.idade = idade;
this.turma = turma;
this.nota = nota;
}
public void setNota(Double nota) {
this.nota = nota;
}
public void setnumeroDeDisciplinas(int numeroDeDisciplinas) {//
this.numeroDeDisciplinas = numeroDeDisciplinas;
}
public int getnumerodeDisciplinas() {
return this.numeroDeDisciplinas;
}
//java já coloca valores por padrão.
public void setnomeDisciplina(String nomeDisciplina) {
this.nomeDisciplina = nomeDisciplina;
}
public String getnomeDisciplina(){
return this.nomeDisciplina;
}
public void setNome(String nome) {// atribui um valor para o atributo nome.
this.nome = nome;
}
public String getNome() {
return this.nome;
}
public void setIdade(int idade) {
this.idade = idade;
}
public int getIdade() {
return this.idade;
}
public void setTurma(int turma) {
this.turma = turma;
}
public int getTurma() {
return this.turma;
}
public Double getNota() {
return this.nota;
}
public String mostrarInformacoes() {
return "Nome: " + getNome() + "\nIdade: " + getIdade() + "\nTurma: " + getTurma() + "\nMédia: " + calculaNota() + "\n##############\n";
}
public double calculaNota() {
soma += this.nota;
media=soma/contNota();
return media;
}
public int contNota() {
int contNota = 0;
for (int j = 0; j < notas.length; j++) {
//if(nota[i] != null) {//se a posição é diferente de null não conta.
contNota++;
}
return contNota;//retorna o número de alunos.
}
/* public Aluno(String nome, int idade, int turma) {
setNome(nome);
setIdade(idade);
setTurma(turma);
}*/
}
Perceba, tive de criar um vetor para a alunos para poder preencher o vetor, e dois objetos, um objeto, Disciplina para inserir os dados no vetor e outro alunos para fazer o encapsulamento.
Ainda não funciona bem, pois o loop não está lendo as notas na segunda iteração, está certo a lógicoa e preciso acumular quantas vezes foi contado para tirar a média, até fiz o código, mas não sei se está certo, criei o método para contar o número de notas lidas. Só falta mesmo entender melhor os vetores com os getters e setters. Evoluindo aos poucos. Estou estudando sozinho.
Uma outra coisa. É obrigado a colocar as variáveis de leitura dentro dos getters e setters para a proteção das variáveis. Não dá somente para colocar as variáveis naturalmente, por isso a leitura dentro dos parentes dos sets, estou correto?
Você não precisa desse método contNota() você já tem o número de notas com o tamanho do array, que é o notas.length.
Quais são as classes que você tem e qual é a relação entre elas?
Um Aluno pode estar matriculado em quantas disciplinas?
As notas são do aluno ou dá disciplina?
Sua classe está confusa, seu aluno tem um atributo quantidade de disciplinas mas só tem o nome de uma disciplina, o aluno também só tem uma nota.
Porque não explica direitinho o que você quer fazer que daí a galera pode te ajudar a primeiro modelar as classes da forma correta.