Utilizando as classes criadas no exercício anterior crie uma nova classe Turma como mostrado no diagrama UML abaixo:
Turma
- vetor : ArrayList<Aluno>
+ Turma()
+ numeroAlunos() : int
+ adicionaAluno(aluno : Aluno)
+ toString() : String
+ buscaAluno(nome : String) : ArrayList<Aluno>
+ removeAluno(ra : int) : boolean
+ lerAluno(input : Scanner) : Aluno
+ main(args: String[])
No método main crie um objeto de tipo Turma e um menú com opções para: adicionar um aluno na turma, visualizar as características de todos os alunos da turma, remover um aluno pelo RA, buscar alunos pelo nome e sair do programa. Um aluno só pode ser adicionado se não existe outro idêntico em vetor.

Passo 1

Beleza, vamos lá! O exercício pede para criar uma nova classe chamada Turma usando as classes que você já criou antes. A matéria que vamos usar aqui é Programação Orientada a Objetos em Java, mais especificamente sobre classes, objetos, listas e métodos. Para resolver isso, vamos precisar entender como criar uma classe, adicionar métodos nela, e manipular uma lista de objetos Aluno.

Passo 2

Primeiro, vamos criar a classe Turma. Ela vai ter um atributo chamado vetor, que é uma lista (ArrayList) de objetos do tipo Aluno. Para isso, vamos importar java.util.ArrayList.

Passo 3

Agora, vamos criar o construtor Turma(). Esse método especial é chamado quando criamos um novo objeto da classe. Aqui, vamos inicializar o vetor como uma nova ArrayList de Aluno.

Passo 4

Vamos criar o método numeroAlunos(). Esse método vai retornar a quantidade de alunos na turma. Para isso, usamos o método size() da ArrayList.

Passo 5

Em seguida, vamos criar o método adicionaAluno(Aluno aluno). Esse método vai adicionar um aluno na turma, mas só se não existir outro aluno com o mesmo RA (Registro Acadêmico). Primeiro, vamos verificar se já existe um aluno com o mesmo RA. Se não existir, adicionamos o aluno na lista.

Passo 6

Vamos criar o método toString(). Esse método vai retornar uma representação em string de todos os alunos na turma. Vamos usar um StringBuilder para concatenar as informações de cada aluno.

Passo 7

Agora, vamos implementar o método buscaAluno(String nome). Esse método vai buscar e retornar uma lista de alunos com o nome especificado. Vamos percorrer o vetor e adicionar na lista de resultados os alunos que tiverem o nome igual ao que foi passado.

Passo 8

Vamos criar o método removeAluno(int ra). Esse método vai remover um aluno pelo RA. Percorremos a lista de alunos, e se encontrarmos um com o RA correspondente, removemos ele e retornamos true. Se não encontrarmos, retornamos false.

Passo 9

O método lerAluno(Scanner input) vai ler os dados de um aluno do usuário. Vamos pedir para o usuário digitar o RA, nome e outros dados necessários, e então criar e retornar um objeto Aluno com essas informações.

Passo 10

Finalmente, vamos criar o método main. Dentro dele, vamos criar um objeto da classe Turma e um menu que permite ao usuário adicionar alunos, visualizar todos os alunos, remover um aluno pelo RA, buscar alunos pelo nome e sair do programa. Vamos usar um loop while para mostrar o menu até que o usuário decida sair.

Resposta

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

public class Turma {
    private ArrayList<Aluno> vetor;

    public Turma() {
        this.vetor = new ArrayList<>();
    }

    public int numeroAlunos() {
        return vetor.size();
    }

    public void adicionaAluno(Aluno aluno) {
        for (Aluno a : vetor) {
            if (a.getRa() == aluno.getRa()) {
                System.out.println("Aluno com RA " + aluno.getRa() + " já existe.");
                return;
            }
        }
        vetor.add(aluno);
        System.out.println("Aluno adicionado com sucesso!");
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Aluno a : vetor) {
            sb.append(a.toString()).append("\n");
        }
        return sb.toString();
    }

    public ArrayList<Aluno> buscaAluno(String nome) {
        ArrayList<Aluno> resultado = new ArrayList<>();
        for (Aluno a : vetor) {
            if (a.getNome().equalsIgnoreCase(nome)) {
                resultado.add(a);
            }
        }
        return resultado;
    }

    public boolean removeAluno(int ra) {
        for (Aluno a : vetor) {
            if (a.getRa() == ra) {
                vetor.remove(a);
                System.out.println("Aluno removido com sucesso!");
                return true;
            }
        }
        System.out.println("Aluno com RA " + ra + " não encontrado.");
        return false;
    }

    public Aluno lerAluno(Scanner input) {
        System.out.print("Digite o RA do aluno: ");
        int ra = input.nextInt();
        input.nextLine(); // Consumir a quebra de linha
        System.out.print("Digite o nome do aluno: ");
        String nome = input.nextLine();
        // Adicione mais campos se necessário
        return new Aluno(ra, nome);
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Turma turma = new Turma();
        int opcao = 0;
        while (opcao != 5) {
            System.out.println("Menu:");
            System.out.println("1. Adicionar aluno");
            System.out.println("2. Visualizar alunos");
            System.out.println("3. Remover aluno pelo RA");
            System.out.println("4. Buscar aluno pelo nome");
            System.out.println("5. Sair");
            System.out.print("Escolha uma opção: ");
            opcao = input.nextInt();
            input.nextLine(); // Consumir a quebra de linha
            switch (opcao) {
                case 1:
                    Aluno novoAluno = turma.lerAluno(input);
                    turma.adicionaAluno(novoAluno);
                    break;
                case 2:
                    System.out.println("Alunos na turma:");
                    System.out.println(turma.toString());
                    break;
                case 3:
                    System.out.print("Digite o RA do aluno a remover: ");
                    int ra = input.nextInt();
                    input.nextLine(); // Consumir a quebra de linha
                    turma.removeAluno(ra);
                    break;
                case 4:
                    System.out.print("Digite o nome do aluno a buscar: ");
                    String nome = input.nextLine();
                    ArrayList<Aluno> encontrados = turma.buscaAluno(nome);
                    if (encontrados.isEmpty()) {
                        System.out.println("Nenhum aluno encontrado com o nome " + nome);
                    } else {
                        System.out.println("Alunos encontrados:");
                        for (Aluno a : encontrados) {
                            System.out.println(a.toString());
                        }
                    }
                    break;
                case 5:
                    System.out.println("Saindo do programa.");
                    break;
                default:
                    System.out.println("Opção inválida. Tente novamente.");
            }
        }
        input.close();
    }
}

Exercícios relacionados

O rebanho caprino de uma ilha do mediterrâneo está sujeito a uma radiação natural que provoca a mutação do gene responsável pela pelagem parda ( B , dominante) para o gene responsável pela pelagem albina (b, recessivo), numa taxa de 0,25. Em 2005, dos 8 mil caprinos dessa ilha, 5000 eram homozigotos, dos quais apenas 500 eram albinos. Se, a partir desse ano, uma usina nuclear começa a emitir radiação que desencadeie uma mutação do gene b para o B na taxa de 1:100, qual a frequência genotípica de animais albinos, após uma geração?
Considerando uma população de milho com os alelos (planta normal) e (planta braquítica). Na população em equilíbrio as freqüências dos alelos e br são 0,6 e 0,4, respectivamente. Qual o número de ciclos de seleção que será necessário para obter uma população com a freqüência do alelo ?
Crie uma classe HistoricoInflacao que utiliza as duas classes do exercício anterior como no diagrama UML a seguir:
HistoricoInflacao
- serie : java.util.ArrayList
+ Historicolnflacao()
+ serie() : java.util.ArrayList
+ adicionar(infla: Inflacao)
+ toString() : String
+ lerınflacao(teclado : java.util.Scanner) : Inflacao
+ buscar(ano: int) : Inflacao
+ main(args: String[l])
O método adicionar acrescenta um objeto Inflacao à serie somente se não existe outro igual armazenado. O método lerInflacao cria um objeto de tipo Inflacao a partir dos dados fornecidos pelo usuário através do teclado. O main cria um menú com opções para adicionar, visualizar a serie de inflação armazenada, visualizar os dados da inflação de um determinado ano e encerrar a execução do programa.
Criar as classes Serie e Inflacao como descritas no diagrama UML mostrado a seguir:
Serie
- descricao : String
- dados : double[]
+ Serie(desc: String, dados : double[])
+ dados() : double[]
+ valor(ind : int) : double
+ descricao(): String
+ toString(): String
+ equals(obj : Object) : boolean

Inflacao

  • ano : int
  • acumulado: double
  • Inflacao(desc : String, ano : int, valores : double[], acumulado : double)
  • indices () double[]
  • ano() : int
  • indiceMes(mes : int) : double
  • acumulado() : double
  • toString() : String
  • equals(obj: Object) : boolean
    Observe a assinatura dos métodos para descobrir sua funcionalidade.