Ajuda com POO1 (Avaliação Final)

28 de agosto de 2021 19 respostas Resolvido

Debora_Alves 28 de agosto de 2021

estaAprovado(int posAluno):boolean (Um método que permite verificar se
o aluno na posição posAluno da lista está ou não aprovado na disciplina. O método
retorna true se aprovado e false, caso contrário. Um aluno aprovado possui nota maior
OU igual a 6 e frequência maior ou igual a 75%).
exibirReprovados():void (Um método que permite exibir todos os alunos aprovados na disciplina. Se não houverem alunos reprovados, então deve-se imprimir “Não
há alunos reprovados.”. Se não houver alunos matriculados na disciplina imprimir “Disciplina não possui alunos matriculados”).
exibirAprovados():void (Um método que permite exibir todos os alunos aprovados. Se não houverem alunos aprovados, então deve-se imprimir “Não há alunos
aprovados.”. Se não houver alunos matriculados na disciplina imprimir “Disciplina
não possui alunos matriculados”).

public boolean estaAprovado( int posAluno, int frequenciaTotal) {
	if(posAluno>=6 && frequenciaTotal>=75/100) {
		return true;
	}
	else {
		return false;
	}
}

Como posso criar os public void exibirAprovado e public void exibirReprovado?

19 Respostas

Lucas_Camara 28 de ago. de 2021

Usando o método estaAprovado, vc já consegue identificar quem está aprovado ou não. Com isso, vc basta vc percorrer a lista de alunos, chamando esse método, e apresentar os dados apenas do que esse método retornar true para exibirAprovado e false para exibirReprovado.

Imaginando que vc tenha uma lista de alunos, imagino algo mais ou menos assim:

for (int i = 0; i < alunos.size(); i++) {
    if (estaAprovado(...)) {
        // aluno aprovado, imprime dados
    } else {
        // aluno reprovado, imprime dados
    }
}

Porém, tem algo que não entendi nesse método estaAprovado. O parâmetro posAluno seria a nota dele? Pois, pelo nome, parece mais um índice que indica a posição em algum array ou lista.

E esse método estaAprovado poderia ser simplificado para ficar assim:

public boolean estaAprovado(int posAluno, int frequenciaTotal) {
    return posAluno >= 6 && frequenciaTotal >= (75/100); // é bom colocar os parênteses nesse cálculo
}

Debora_Alves 28 de ago. de 2021

Obrigada!!
O Trabalho é muito extenso , como é minha primeira publicação , fiquei em dúvida se poderia postar ele completo. Aqui é quando o posAluno é mencionado:
addNota(int posAluno, double nota):boolean (Um método que permite
configurar para o aluno na posição posAluno a sua nota (nota) na disciplina. Retorne
verdadeiro ou falso se isso for possível. O valor para nota deve estar no intervalo [0,10])

Debora_Alves 28 de ago. de 2021

Tenho essas listas : ArrayList alunos , ArrayList notas e ArrayList frequencias

Lucas_Camara 28 de ago. de 2021

Por ser um exercicio de POO, então vc não precisa ter 3 ArrayList para armazenar esses dados do aluno. Em vez disso, vc poderia ter uma classe Aluno com 3 propriedades:

public class Aluno {
    private String nome;
    private double nota;
    private double frequencia;
}

Com isso, vc consegue manter todos os alunos com seus dados numa única lista:

List<Aluno> alunos = new ArrayList<>();

Acredito que vá deixar seu código mais simples. Por exemplo, no método está aprovado, em vez de receber a um posAluno e frequenciaTotal como parâmetro, poderia receber o Aluno diretamente:

public boolean estaAprovado(Aluno aluno) {
    return aluno.getNota() >= 6 && aluno.getFrequencia() >= (75/100);
}

E pensando numa utilização ainda melhor de POO, vc poderia ter esse método estaAprovado criado diretamente na classe Aluno. Já que a aprovação, no seu exercício, está ligado diretamente ao aluno.

public class Aluno {
    private String nome;
    private double nota;
    private double frequencia;

    // getters and setters

    public boolean estaAprovado() {
        return this.nota >= 6 && this.frequencia >= (75/100);
    }
}

Dessa forma, vc poderia verificar os alunos aprovados da lista assim:

for (Aluno aluno : alunos) {
    if (aluno.estaAprovado()) {
        // aluno aprovado, apresenta dados
    }
}

Debora_Alves 28 de ago. de 2021

o trabalho é esse aqui

Crie um projeto Java com quatro pacotes distintos:
• ifsuldeminas.academico
• ifsuldeminas.alunos
• ifsuldeminas.funcionarios
• ifsuldeminas.main
No pacote ifsuldeminas.alunos deve-se implementar a classe Aluno com os seguintes
atributos, construtores e métodos:
• nome:String (um atributo para armazenar o nome de um aluno).
• ra:int (Um inteiro no intervalo [1000,9999] que representa o registro acadêmico do
aluno).
• periodo:int (um inteiro para armazenar o período do aluno).
• curso:String (Um atributo para armazenar qual é o curso do aluno).
• Aluno(String nome, int ra, String curso) (Um construtor que permite
construir um objeto aluno com nome, registro acadêmico e curso. Assuma que um objeto criado com esse contrutor permite criar um aluno no primeiro período, isto é, periodo=1).
• Aluno(String nome, int ra, int periodo, String curso) (Um construtor que permite construir um objeto aluno com nome, registro acadêmico, período e
curso).
• setters e getters.
• exibirAluno():void (Um método para exibir todas as informações do aluno).
No pacote ifsuldeminas.funcionarios deve-se implementar a classe Professor
com os seguintes atributos, construtor e métodos:
• nome:String (um atributo String cujo valor é o nome do professor).
• suap:int (um atributo inteiro no intervalo [1000, 9999]).
• Professor(String nome, int suap) (Um construtor que permita criar um objeto que represente um professor com nome e número suap informados).
1
• setters e getters.
• exibirProfessor():void (Um método que exibe as informações do professor).
No pacote ifsuldeminas.academico deve-se implementar a classe Disciplina com
os seguintes atributos, construtor e métodos:
• nome:String (Um atributo que armazena o nome da disciplina).
• int:periodo (Um atributo para armazenar o período em que uma disciplina é ofertada).
• int:numAulasSemana (Um atributo para armazenar o número de aulas da disciplina
por semana).
• int:numTotalAulas (Um atributo para armazenar o número total de aulas da disciplina).
• Professor:professor (Um atributo para armazenar qual é o professor da disciplina).
• ArrayList alunos (Uma lista para armazenar todos os alunos que fazem
determinada disciplina).
• ArrayList notas (Uma lista para armazenar as notas dos alunos na disciplina. Essa lista deverá ter sempre o mesmo tamanho da lista alunos e o valor de
notas.get(i) corresponde ao valor da nota do aluno na posição alunos.get(i)).
• ArrayList frequencias (Uma lista para armazenar as frequências
dos alunos na disciplina. Essa lista deverá ter sempre o mesmo tamanho da lista alunos
e, portanto, o valor de frequencia.get(i) corresponde à frequencia do aluno na
posição alunos.get(i)).
• Disciplina(String nome, int periodo, int numAulasSemana,
int numSemanas) (Um construtor que permita criar uma disciplina com nome, período e número de aulas especificados. O valor do inteiro numSemanas refere-se ao número de semanas que acontecerão as aulas e, portanto,
numTotalAulas = numAulasSemana*numSemanas
Nesse construtor deve-se construir o objeto alunos, o objeto notas, o objeto frequencias
e armazenar no atributo professor o valor null, indicando que a disciplina ainda não
tem professor).
• Disciplina(String nome, int periodo, int numAulasSemana,
int numSemanas, Professor professor) (Um construtor que permita criar
uma disciplina com nome, período, número de aulas e o professor responsável. Nesse construtor deve-se construir o objeto alunos, notas e frequencia. O valor do atributo
numTotalAulas também deve ser configurado adequadamente, conforme descrito na
descrição do construtor anterior).
• matricularAluno(Aluno aluno):boolean (Um método que permita matricular um aluno na disciplina. Ao matricular aluno deve-se registrar uma posição em notas
e em frequencias iguais a zero, isto é, adicionar em notas e em frequencias o
valor zero. O método retorna true se o aluno foi matriculado e false, caso contrário.
Não poderão ser matriculados alunos com o mesmo valor de ra).
2
• desmatricularAluno(int posAluno):boolean (Um método que permite desmatricular um aluno. Este método deve receber como parâmetro a posição do aluno na lista
(posAluno) a ser removido. Consulte na documentação da classe ArrayList um método que permita remover objetos do ArrayList. Você também deverá remover a nota
do aluno na lista de notas e sua frequência na lista de frequência, caso contrário, ambas
ficarão inconsistente. O método retorna true se o aluno foi desmatriculado e false,
caso contrário).
• setProfessor(Professor professor):void (Um método que aloca à disciplina a um professor.).
• removerProfessor():void (Um método que remove um professor da disciplina.
Uma disciplina não possui professor se o atributo professor é null).
• getNumeroAlunos():int (Um método que permite retornar o número de alunos
matriculados na disciplina).
• addNota(int posAluno, double nota):boolean (Um método que permite
configurar para o aluno na posição posAluno a sua nota (nota) na disciplina. Retorne
verdadeiro ou falso se isso for possível. O valor para nota deve estar no intervalo [0,10]).
• addFrequencia(int posAluno, int frequenciaTotal):boolean (Um
método que permite configurar para o aluno na posição posAluno da lista, a sua frequência total na disciplina. Retorne verdadeiro ou falso se isso for possível. O valor de frequenciaTotal
deve estar no intervalo [0,numTotalAulas]).
• estaAprovado(int posAluno):boolean (Um método que permite verificar se
o aluno na posição posAluno da lista está ou não aprovado na disciplina. O método
retorna true se aprovado e false, caso contrário. Um aluno aprovado possui nota maior
OU igual a 6 e frequência maior ou igual a 75%).
• exibirReprovados():void (Um método que permite exibir todos os alunos aprovados na disciplina. Se não houverem alunos reprovados, então deve-se imprimir “Não
há alunos reprovados.”. Se não houver alunos matriculados na disciplina imprimir “Disciplina não possui alunos matriculados”).
• exibirAprovados():void (Um método que permite exibir todos os alunos aprovados. Se não houverem alunos aprovados, então deve-se imprimir “Não há alunos
aprovados.”. Se não houver alunos matriculados na disciplina imprimir “Disciplina
não possui alunos matriculados”).
• calcularMedia():double (Um método que retorna a média das notas de todos os
alunos matriculados na disciplina. Esse valor é a média total da turma).
• exibirMaiorNota():void (Mostra as informações do aluno com a maior nota na
disciplina).
• exibirMenorNota():void (Mostra as informações do aluno com a menor nota na
disciplina).
• getQuantidadeReprovados():int (Método que retorna um inteiro que corresponde à quantidade de alunos reprovados.).
• getQuantidadeAprovados():int (Método que retorna um inteiro que corresponde à quantidade de alunos aprovados.).
3
• exibirProfessor():void (Método para mostrar as informações do professor responsável pela disciplina. Se a disciplina não houver um professor então deve-se exibir
“Disciplina não possui professor”).
• getAproveitamentoAluno(int posAluno):double (Método que retorna o
aproveitamento de um aluno na posição posAluno da lista. O aproveitamento do aluno
é determinado a partir da sua frequência total. Um aluno que nunca faltou tem aproveitamento de 100% e um aluno que faltou metade do número total de aulas tem aproveitamento
de 50%. Nesses casos o método retorna os valores 100 e 50, respectivamente).
• getNotaAluno(int posAluno):double (Método que retorna a nota de um aluno
na posição posAluno da lista.).
• exibirAlunosAcimaMedia():void (Método para exibir todos os alunos acima
da média total da turma. Por exemplo, se a média for 7.2, então todos os alunos com nota
maior OU igual a 7.2 devem ser exibidos. Se não houver alunos matriculados na disciplina
imprimir “Disciplina não possui alunos matriculados”).
• exibirAlunosAbaixoMedia():void (Método para exibir todos os alunos abaixo
da média total da turma. Se não houver alunos matriculados na disciplina imprimir “Disciplina
não possui alunos matriculados”).
• exibirAlunoNotaAproveitamento():void (Método para exibir apenas o nome
dos alunos, suas respectivas notas e aproveitamento na disciplina. Se não houver alunos matriculados na disciplina imprimir “Disciplina não possui alunos matriculados”).
• desmatricularAlunos():void (Um método que permite desmatricular todos os
alunos matriculados na disciplina).
• exibirOrdenadosPorNota():void (Um método para exibir apenas o nome dos
alunos e suas respectivas notas. A exibição deverá ser feita de forma decrescente as nota, isto
é, o aluno com a maior nota deverá ser o primeiro a ser exibido, seguido do aluno com a segunda maior nota e assim até o aluno com a menor nota. Se não houver alunos matriculados
na disciplina imprimir “Disciplina não possui alunos matriculados”).
• exibirDisciplina():void (Um método para exibir todas as informações da disciplina. Deverá ser exibido as informações do professor e dos alunos, a nota e a frequência
de cada aluno na disciplina. Imprimir a média total da turma, a quantidade de alunos a
quantidade de alunos reprovados e aprovados. Quando não houver alunos matriculados
imprimir apenas “Disciplina não possui alunos matriculados”).
No pacote ifsuldeminas.main deve-se implementar a classe Main e fazer as seguintes
simulações:
1 Crie um objeto que represente uma disciplina do primeiro período. Configure o nome, o
número de aulas na semana e o período da disciplina;
2 Crie 10 objetos Aluno do primeiro período;
3 Matricule todos os 10 objetos Aluno no objeto disciplina do passo 1;
4 Configure para cada objeto aluno uma nota e uma frequencia total;
5 Crie um objeto para representar um professor;
4
6 Aloque o professor ao objeto disciplina criado no passo 1.
7 Crie um objeto da classe Scanner que permita fazer leitura de dados do teclado;
8 Armazene em uma variável opcao um valor inteiro fornecido pelo teclado;
9 Enquanto opcao for diferente de zero. Permita que:
– opcao == 1: Imprimir informações da disciplina;
– opcao == 2: Apresentar número de alunos na disciplina, número de reprovados e
número de aprovados;
– opcao == 3: Imprimir aprovados;
– opcao == 4: Imprimir reprovados;
– opcao == 5: Imprimir aluno com a maior e o aluno com menor nota;
– opcao == 6: Imprimir o professor responsável;
– opcao == 7: Imprimir média total da turma e listar todos os alunos acima da média;
– opcao == 8: Imprimir média total da turma e listar todos os alunos abaixo da
média;
– opcao == 9: Imprimir nome dos alunos e suas respectivas notas e aproveitamento;
– opcao == 10: Imprimir alunos ordenados por nota.
– opcao == 11: Matricular aluno. Deve-se ler o nome, registro acadêmico e curso
do aluno usando o objeto Scanner. Como a disciplina é uma disciplina do primeiro
período, assume-se que o aluno é do primeiro período e, portanto, não há necessidades
de ler seu período. Em seguida deve-se criar o objeto que represente o aluno e então
matriculá-lo na disciplina; depois deve-se ler a nota e a frequência total do aluno na
disciplina, esses valores deverão ser corretamente registrados para o aluno. Solicite ao
usuário um valor válido a ser informado. Por exemplo: o registro acadêmico deve estar no intervalo [0, 9999], a nota deve estar no intervalo [0,10] e frequencia total não
pode ser maior que o número total de aulas da disciplina. Apresente para o usuário se
o aluno foi ou não matriculado com sucesso. Perceba que se o registro acadêmico fornecido pelo usuário for igual ao de um aluno já matriculado, então deverá ser exibido
para o usuário que o aluno não foi matriculado, pois seu RA é semelhante ao de um
aluno matriculado na disciplina.
10 Quando opcao for igual a zero, desmatricular todos os alunos, remover o professor da
disciplina e finalizar a execução do programa

Debora_Alves 28 de ago. de 2021

Não tenho tanto conhecimento , estou na POO1. Estou seguindo a ordem dos exercícios e travei na parte de exibirAprovados e reprovados.
Só coloquei o trabalho pq acho que é obrigatório ter 3 ArrayList.

Lucas_Camara 28 de ago. de 2021

Entendi agora. Tenta postar o código que vc fez até agora pra gente ver.

Debora_Alves 28 de ago. de 2021

package aluno;

public class Aluno {
  
  //Atributos do Alunos
  public int periodo;
  public int ra;
  public String nome;
  public String curso;
  
  //Construtor da classe Aluno.
  public Aluno (int ra, String nome, String curso) {
    this.periodo = 1;
    setRa(ra);
    setNome(nome);
    setCurso(curso);
  }
  
  public Aluno (int periodo, int ra, String nome,String curso) {
    setPeriodo(periodo);
    setRa(ra);
    setNome(nome);
    setCurso(curso);
  }
	
  //Metodos 
  public String getNome() {
	  return this.nome;
  }
  
  public void setNome(String nome) {
    this.nome =nome;
  }
  
  public String getCurso() {
	  return this.curso;
  }
  
  public void setCurso(String curso) {
    this.curso =curso;
  }
  
  public int getRa() {
	  return this.ra;
  }
  
  public void setRa(int ra) {
	  if (ra < 1000 || ra > 9999) {
		  System.out.println("RA inválido!");
	  } else {
      this.ra = ra;
    }
  }
  
  public int getPeriodo() {
    return this.periodo;
  }
  
  public void setPeriodo(int periodo) {
    this.periodo =periodo;
  }
  
  public void exibirAluno() {
    System.out.println("Dados do Aluno");
    System.out.println("Nome do Aluno:"+ this.nome);
    System.out.println("Nome do Curso:"+ this.curso);
    System.out.println("Numero do Registro Academico:"+ this.ra);
    System.out.println("Periodo:"+this.periodo);
	}
}

Debora_Alves 28 de ago. de 2021

package funcionarios;

public class Professor {
  
  //Atributos
  public String nome;
  public int suap;
  
  // Construtores
  public Professor (String nome , int suap) {
    setNome(nome);
    setSuap(suap);
  }
  
  // Metodos 
  public String getNome() {
    return this.nome;
  }
  
  public void setNome(String nome) {
    this.nome=nome;
  }
  
  public int getSuap() {
    return this.suap;
  }
  
  public void setSuap(int suap) {
    if (suap >= 1000 && suap <= 9999) {
      this.suap = suap;
    } else {
    	System.out.println("Número de Suap inválido!");
    } 
  }
  
  public void exibirProfessor() {
    System.out.println("/////Dados do Professor/////");
    System.out.println("Nome do Professor:"+ nome);
    System.out.println("Numero do Suap:"+ suap);
  }
}

Debora_Alves 28 de ago. de 2021

package academico;

import java.util.ArrayList;

import aluno.Aluno;
import funcionarios.Professor;

public class Disciplina {
//Atributos
	public String nome;
	public int periodo;
	public int numAulasSemana;
	public int numTotalAulas;
	public int numSemanas;
	Professor professor;
	public ArrayList<Aluno> alunos;
	public ArrayList<Double> notas;
	public ArrayList<Integer> frequencias;
	public ArrayList<Aluno> getNumeroAlunos;
	public ArrayList<Double> posAluno;
	public int frequenciaTotal;

// Construtor

	public Disciplina(String nome, int periodo, int numAulasSemana, int numSemanas) {
		setNome(nome);
		setPeriodo(periodo);
		setNumAulasSemana(numAulasSemana);
		setNumSemanas(numSemanas);
		this.numTotalAulas = getNumAulasSemana() * getNumSemanas();
		alunos = new ArrayList<Aluno>();
		notas = new ArrayList<Double>();
		frequencias = new ArrayList<Integer>();
	}

	public Disciplina(String nome, int periodo, int numAulasSemana, int numSemanas, Professor professor) {
		setNome(nome);
		setPeriodo(periodo);
		setNumAulasSemana(numAulasSemana);
		setNumSemanas(numSemanas);
		alunos = new ArrayList<Aluno>();
		notas = new ArrayList<Double>();
		frequencias = new ArrayList<Integer>();
		this.numTotalAulas = getNumAulasSemana() * getNumSemanas();
		this.professor = professor;
	}

//Métodos
	public int getNumSemanas() {
		return numSemanas;
	}

	public void setNumSemanas(int numSemanas) {
		this.numSemanas = numSemanas;
	}

	public String getNome() {
		return nome;
	}

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

	public int getPeriodo() {
		return periodo;
	}

	public void setPeriodo(int periodo) {
		this.periodo = periodo;
	}

	public int getNumAulasSemana() {
		return numAulasSemana;
	}

	public void setNumAulasSemana(int numAulasSemana) {
		this.numAulasSemana = numAulasSemana;
	}

	public int getNumeroAlunos() {
		return getNumeroAlunos();
	}

	public void setNumeroAlunos() {
		this.getNumeroAlunos = alunos;
	}

	public Professor getProfessor() {
		return professor;
	}

	public void setProfessor(Professor professor) {
		this.professor = null;
	}

	public void removerProfessor() {
		this.professor = null;
	}

	public Aluno getAlunos(int i) {
		return alunos.get(i);
	}

	public void setAlunos(ArrayList<Aluno> alunos) {
		this.alunos = alunos;
	}

	public Double getNotas(int i) {
		return notas.get(i);
	}

	public void setNotas(ArrayList<Double> notas) {
		this.notas = notas;
	}

	public Integer getFrequencias(int i) {
		return frequencias.get(i);
	}

	public void setFrequencias(ArrayList<Integer> frequencias) {
		this.frequencias = frequencias;
	}

	public boolean matricularAluno(Aluno aluno) {
		return alunos.add(aluno);
	}

	public boolean desmatricularAluno(int posAluno) {
		return alunos.remove(posAluno) != null;
	}

	public boolean addNota(int posAluno, double nota) {

		if (nota > 0 || nota < 10) {
			this.posAluno = notas;
			return true;
		} else {

		}
		return false;
	}

	public boolean addFrequencia(int posAluno, int frequenciaTotal) {
		int i = 0;
		if (i > 0 || i < numTotalAulas) {
			this.frequenciaTotal = getFrequencias(frequenciaTotal) * getNumSemanas();
			return true;
		} else {

			return false;
		}
	}

	public boolean estaAprovado(int posAluno, int frequenciaTotal) {
		if (posAluno >= 6 && frequenciaTotal >= (75 / 100)) {
			return true;
		} else {
			return false;
		}
	}

	public void exibirReprovados() {
		int frequenciaTotal = 0;
		int posAluno = 0;
		if (posAluno < 6 && frequenciaTotal < (75 / 100))
			System.out.println("Alunos reprovados:" + alunos);
		else {
			System.out.println("Não há alunos reprovados");
		}
		if (getNumeroAlunos == null)
			System.out.println("Disciplina não possui alunos matriculados");
	}

	public void exibirAprovados() {
		int frequenciaTotal = 0;
		int posAluno = 0;
		if (posAluno >= 6 && frequenciaTotal >= (75 / 100))
			System.out.println("Alunos aprovados:" + alunos);
		else {
			System.out.println("Não há alunos aprovados");
		}
		if (getNumeroAlunos == null)
			System.out.println("Disciplina não possui alunos matriculados");
	}

	public void informacoesDisciplina() {
		System.out.println("Dados da Disciplina:");
		System.out.println("Nome:" + nome);
		System.out.println("Periodo:" + periodo);
		System.out.println("Numero de Aulas na Semana:" + numAulasSemana);
		System.out.println("Numero de semanas:" + numSemanas);
		System.out.println("Numero total de aulas:" + numTotalAulas);
		System.out.println("Professor:");
		professor.exibirProfessor();
	}

	public void exibirProfessor() {
		System.out.println("Nome do Professor:" + professor);
		if (professor == null)
			System.out.println("Disciplina não possui profesor");
	}

	public double calcularMedia() {
		this.mediaTotal= +((Aluno) alunos.get(i)).periodo getMedia
	}
}

Debora_Alves 28 de ago. de 2021

package main;

import java.util.ArrayList;
import java.util.Scanner;

import academico.Disciplina;
import aluno.Aluno;
import funcionarios.Professor;

public class Main {
	public static void main(String args[]) {
		try (Scanner leitura = new Scanner(System.in)) {
			Aluno a1 = new Aluno(1111, "Adriana", "Matemática");
			Aluno a2 = new Aluno(2222, "Adriano", "Matemática");
			Aluno a3 = new Aluno(3333, "Alessandra", "Matemática");
			Aluno a4 = new Aluno(4444, "Alessandro", "Matemática");
			Aluno a5 = new Aluno(5555, "Bruna", "Matemática");
			Aluno a6 = new Aluno(6666, "Bruno", "Matemática");
			Aluno a7 = new Aluno(7777, "Carla", "Matemática");
			Aluno a8 = new Aluno(8888, "Carlos", "Matemática");
			Aluno a9 = new Aluno(9999, "Daniela", "Matemática");
			Aluno a10 = new Aluno(1010, "Daniel", "Matemática");
			Professor professor = new Professor("Einstein", 1879);
			Disciplina disciplina = new Disciplina("Física", 1, 4, 9, professor);

			int opcao = 0;

			do {
				System.out.println("--------------------------");
				System.out.println("Digite a opção desejada:");
				System.out.println("************************************");
				System.out.println("1- Imprimir informações de um aluno");
				System.out.println("************************************");
				System.out.println("2- Imprimir informações da disciplina");
				System.out.println("************************************");
				System.out.println("3-Imprimir o professor resposável");
				System.out.println("************************************");
				System.out.println("4-Finalizar o programa");
				System.out.println("************************************");
				opcao = leitura.nextInt();

				switch (opcao) {
				case 1: {
					a1.exibirAluno();

					break;
				}

				case 2: {
					disciplina.informacoesDisciplina();
					break;
				}
				case 3: {
					professor.exibirProfessor();
					break;
				}

				case 4: {
					System.out.println("Finalizando o programa...");
					opcao = 4;
					break;
				}
				default: {
					System.out.println("Atenção!! Digite outro valor!");
					break;
				}
				}
			} while (opcao != 4);
		}

	}
}

Debora_Alves 28 de ago. de 2021

Obviamente tem bastante erros , mas como disse, não entendo muito bem ( estou ate com dor de cabeça rs)

Lucas_Camara 29 de ago. de 2021

No código da classe Main, reparei que vc cria os alunos, porém não os adiciona na Disciplina.
Os métodos exibirReprovados e exibirAprovados da classe Disciplina deve usar os ArrayList de alunos, notas e frequencias para realizar a lógica. Veja como deve ficar o método exibirReprovados:

// Método que verifica se o aluno está aprovado
public boolean estaAprovado(int posAluno) {
  Double nota = notas.get(posAluno);
  Integer frequencia = frequencias.get(posAluno);

  return (nota >= 6) && (frequencia >= (75 / 100));
}

public void exibirReprovados() {
  if (alunos.isEmpty()) {
    System.out.println("Disciplina não possui alunos matriculados");
    return;
  }

  List<Aluno> alunosReprovados = new ArrayList<>();

  for (int i = 0; i < alunos.size(); i++) {
    if (!estaAprovado(i)) {
      alunosReprovados.add(alunos.get(i));
    }
  }

  if (alunosReprovados.isEmpty()) {
    System.out.println("Não há alunos reprovados!");
    return;
  }

  System.out.println(">> Lista de alunos reprovados: ");
  for (Aluno aluno : alunosReprovados) {
    System.out.println("- " + aluno.getNome());
  }
}

Lembre-se: Para funcionar, os alunos devem ser adicionados na lista de alunos da disciplina pela classe Main.

Debora_Alves 29 de ago. de 2021

Obrigada novamente Lucas ! Depois de fazer todos os métodos , vou adicioná-los no Main.

Vc poderia me orientar em como fazer o método calcularMedia ?

calcularMedia():double (Um método que retorna a média das notas de todos os
alunos matriculados na disciplina. Esse valor é a média total da turma)

Debora_Alves 29 de ago. de 2021

Eu teria que chamar as notas de todos os alunos e dividir pela quantidade de alunos, mas não sei como fazer isso em códigos .

Lucas_Camara 29 de ago. de 2021

Faça um FOR nas notas fazendo a soma numa variável a parte (double soma = 0). Depois divida pela quantidade de notas. A soma pode ser assim: soma += nota (dentro do FOR).

Debora_Alves 29 de ago. de 2021

tá ok . Obrigada

Lucas_Camara 29 de ago. de 2021

Veja esse esquema:

1- declara soma;

2- percorra as notas fazendo a soma na variavel “soma”

3- divida soma pela quantidade de notas (media = somaNotas / quantidadeNotas)

4- imprime a média

Solucao aceita

Debora_Alves 29 de ago. de 2021 1 like

acho que deu certo Lucas, obrigada pela ajuda

Criado 28 de agosto de 2021

Ultima resposta 29 de ago. de 2021

Respostas 19

Participantes 2

19 Respostas

Topicos relacionados