Atividade feita em aula. Comentários adicionado depois para explicar melhor o código.

Média notas de alunos By Ailton.

~~ Adicionar esse código dentro do Main

// Cria uma lista vazia de alunos utilizando a classe ArrayList
List<Aluno> listaAlunos = new ArrayList<Aluno>();

// Cria um objeto da classe Scanner para ler entrada do usuário
Scanner scanner = new Scanner(System.in);

// Pede ao usuário que informe quantos alunos ele deseja adicionar nota
System.out.println("Quantos alunos você vai adicionar nota? ");

// Lê o valor informado pelo usuário e adiciona 1 (para incluir um índice a mais no loop)
int quantidadeAluno = scanner.nextInt() + 1;

// Loop para iterar sobre cada aluno
for (int i = 1; i < quantidadeAluno; i++) {

    // Pede ao usuário que informe a primeira nota do aluno atual
    System.out.println("Por favor informe a primeira nota do aluno " + i + ": ");
    float nota1 = scanner.nextFloat();

    // Pede ao usuário que informe a segunda nota do aluno atual
    System.out.println("Por favor informe a segunda nota do aluno " + i + ": ");
    float nota2 = scanner.nextFloat();

    // Cria um objeto Aluno com as notas informadas e adiciona-o à lista de alunos
    Aluno aluno = new Aluno(nota1, nota2);
    listaAlunos.add(aluno);
}

// Loop para exibir as notas e médias de cada aluno
System.out.println(" ----- ");
for (int i = 1; i < quantidadeAluno; i++) {
    // Obtém o objeto Aluno da lista de acordo com o índice atual
    Aluno a = listaAlunos.get(i - 1);

    // Exibe as notas e a média final do aluno atual
    System.out.print("Aluno " + i);
    System.out.print(": ");
    System.out.print("Nota 1: " + a.nota1);
    System.out.print(" - ");
    System.out.print("Nota 2: " + a.nota2);
    System.out.println("");
    System.out.println("Nota final: " + a.notaFinal);
    System.out.println(" ----- ");
}

~~ Classe Aluno

public class Aluno {
   // Declaração dos atributos da classe Aluno: nota1, nota2 e notaFinal
   float nota1;
   float nota2;
   float notaFinal;
   
   // Construtor da classe Aluno, recebe as notas como parâmetros
   public Aluno(float nota1, float nota2){
       // As notas informadas são atribuídas aos atributos nota1 e nota2
       this.nota1 = nota1;
       this.nota2 = nota2;
       // O método calcularNotaFinal é chamado para calcular e atribuir a nota final
       calcularNotaFinal();
   }
   
   // Método responsável por calcular a nota final do aluno com base nas notas 1 e 2
   void calcularNotaFinal(){
       this.notaFinal = this.nota1 + this.nota2;
   }
}

O código cria uma lista de alunos (do tipo Aluno) usando a classe ArrayList. Em seguida, utiliza a classe Scanner para solicitar ao usuário a quantidade de alunos que ele deseja adicionar nota.

O loop for é usado para solicitar a primeira e a segunda nota de cada aluno e criar um novo objeto Aluno para armazenar essas notas. Em seguida, o objeto Aluno é adicionado à lista de alunos.

Por fim, outro loop for é utilizado para exibir as notas de cada aluno e sua média final. A média final é calculada pela classe Aluno e armazenada em seu atributo notaFinal.

No geral, o código é responsável por criar uma lista de alunos e calcular a média final de cada um com base em suas notas, permitindo que sejam exibidas as notas e as médias na tela.

Classe chamada Aluno, contém alguns atributos (nota1, nota2 e notaFinal) e métodos.

O construtor da classe recebe duas notas como parâmetro e as atribui aos atributos nota1 e nota2 do objeto recém-criado. Em seguida, o método calcularNotaFinal() é chamado para calcular e atribuir a notaFinal com base nas notas informadas.

O método calcularNotaFinal() simplesmente soma as notas informadas e atribui o resultado ao atributo notaFinal do objeto.

Em geral, a classe Aluno é responsável por armazenar as notas de um aluno e calcular sua nota final. A nota final é calculada assim que um objeto Aluno é criado, tornando-o pronto para ser utilizado em outras partes do código. No entanto, é importante notar que a classe Aluno não lida com entradas do usuário ou exibição de resultados - isso é feito em outras partes do código.

É possível usar arrays para a lista. Você pode declarar um array do tipo de objeto desejado e definir seu tamanho para a quantidade de elementos que você deseja armazenar. Por exemplo, se você quiser armazenar uma lista de objetos Aluno, pode criar um array assim:

Aluno[] listaAlunos = new Aluno[10];

Isso cria um array que pode armazenar até 10 objetos Aluno. Para adicionar um novo aluno à lista, você precisa especificar o índice onde deseja armazenar o objeto. Por exemplo:

listaAlunos[0] = new Aluno("João", 8.0, 9.0);

Isso cria um novo objeto Aluno com nome "João" e notas 8.0 e 9.0, e armazena-o no primeiro índice do array (índice 0).

Uma das limitações de usar arrays para criar uma lista é que o tamanho do array é fixo e não pode ser alterado. Se você precisar adicionar mais elementos à lista do que o tamanho do array permite, precisará criar um novo array com um tamanho maior e copiar todos os elementos do array anterior para o novo array. Isso pode ser trabalhoso e pode afetar o desempenho do seu aplicativo, especialmente se você precisar fazer isso com frequência. Por isso, geralmente é recomendado usar uma das implementações de lista fornecidas pela biblioteca padrão do Java, como o ArrayList, em vez de usar arrays para criar listas.

Existem várias formas de melhorar o código, coisas que não foi explicado em aula ainda, mas deixo aqui umas sugestões:

1. Encapsulamento: Em vez de expor diretamente os atributos nota1, nota2 e notaFinal na classe Aluno, é melhor torná-los privados e fornecer métodos públicos para acessá-los e modificá-los. Por exemplo, você pode adicionar os métodos getNota1(), getNota2() e getNotaFinal() para permitir o acesso aos atributos e métodos setNota1(), setNota2() e setNotaFinal() para permitir a modificação dos atributos.

2. Validação: O código não realiza nenhum tipo de validação nas notas que são inseridas pelo usuário. É importante validar essas entradas para garantir que elas estejam dentro do intervalo esperado (por exemplo, entre 0 e 10). Você pode adicionar uma validação no construtor da classe Aluno para garantir que as notas sejam válidas antes de armazená-las nos atributos da classe.

3. Uso de construtores padrão: O código atualmente só fornece um construtor que recebe as notas do aluno como parâmetros. Seria útil adicionar um construtor padrão sem parâmetros que inicializa as notas com valores padrão (por exemplo, 0), para que seja possível criar um objeto Aluno sem especificar as notas.

4. Uso de constantes: O código usa números mágicos em vários lugares (por exemplo, o número 2 é usado para representar a segunda nota). É melhor definir constantes com nomes significativos para esses valores para tornar o código mais legível e fácil de entender.

5. Uso de try-catch: O código usa a classe Scanner para ler entrada do usuário, mas não usa um bloco try-catch para tratar possíveis exceções que podem ser geradas durante a leitura. É uma boa prática envolver as chamadas de método que podem gerar exceções em um bloco try-catch para que o código possa lidar com essas exceções de forma adequada.

6. Uso de outras classes de lista: Como mencionado anteriormente, o ArrayList não é a única implementação de lista disponível no Java. Dependendo das necessidades específicas do seu código, outras implementações de lista, como LinkedList ou Vector, podem ser mais adequadas.

7. Melhor organização do código: O código atualmente não está muito bem organizado em termos de responsabilidade. Seria melhor dividir o código em métodos separados para realizar tarefas específicas, como ler as notas do usuário, calcular as notas finais dos alunos, exibir a lista de alunos na tela, etc. Isso tornaria o código mais modular e mais fácil de entender e manter.

Tendo um maior aproveitamento da aula do prof, tudo deveria ficar dessa forma no main, separados em métodos menores para fácil aproveitamento:

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

public class Main {
    public static void main(String[] args) {
        List<Aluno> listaAlunos = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);

        System.out.println("Quantos alunos você vai adicionar nota? ");
        int quantidadeAluno = scanner.nextInt();

        adicionarNotas(listaAlunos, scanner, quantidadeAluno);
        exibirNotas(listaAlunos);
    }

    private static void adicionarNotas(List<Aluno> listaAlunos, Scanner scanner, int quantidadeAluno) {
        for (int i = 1; i <= quantidadeAluno; i++) {
            System.out.println("Por favor informe a primeira nota do aluno " + i + ": ");
            float nota1 = scanner.nextFloat();

            System.out.println("Por favor informe a segunda nota do aluno " + i + ": ");
            float nota2 = scanner.nextFloat();

            Aluno aluno = new Aluno(nota1, nota2);
            listaAlunos.add(aluno);
        }
    }

    private static void exibirNotas(List<Aluno> listaAlunos) {
        System.out.println(" ----- ");
        for (int i = 0; i < listaAlunos.size(); i++) {
            Aluno a = listaAlunos.get(i);
            System.out.print("Aluno " + (i + 1));
            System.out.print(": ");
            System.out.print("Nota 1: " + a.nota1);
            System.out.print(" - ");
            System.out.print("Nota 2: " + a.nota2);
            System.out.println("");
            System.out.println("Nota final: " + a.notaFinal);
            System.out.println(" ----- ");
        }
    }
}

Se você não gosta de FOR, pode usar WHILE. Exemplo:

List<Aluno> listaAlunos = new ArrayList<Aluno>();
Scanner scanner = new Scanner(System.in);

System.out.println("Digite as notas dos alunos (digite 'fim' para sair): ");

String input = scanner.nextLine();

while(!input.equalsIgnoreCase("fim")) {

    String[] notas = input.split(" ");

    float nota1 = Float.parseFloat(notas[0]);
    float nota2 = Float.parseFloat(notas[1]);

    Aluno aluno = new Aluno(nota1, nota2);
    listaAlunos.add(aluno);

    input = scanner.nextLine();
}