exercicio 1

public class Aluno {

private int matricula;
private String nome;
private double notaProva1;
private double notaProva2;
private double notaTrabalho;

public Aluno(int matricula, String nome, double notaProva1, double notaProva2,

double notaTrabalho) {
this.matricula = matricula;
this.nome = nome;
this.notaProva1 = notaProva1;
this.notaProva2 = notaProva2;
this.notaTrabalho = notaTrabalho;
}

public double calculaMedia() {

double mediaProvas = (notaProva1 + notaProva2) * 2.5;
double mediaTrabalho = notaTrabalho * 2;
return (mediaProvas + mediaTrabalho) / 10;
}

public double calculaFinal() {

double media = calculaMedia();
if (media < 6.0) {
return Math.max(0, 10 - media); // Quanto falta para atingir a nota
mínima (6.0)
} else {
return 0; // Não precisa fazer a prova final
}
}

// Getters e Setters
public int getMatricula() {
return matricula;
}

public String getNome() {

return nome;
}

public double getNotaProva1() {

return notaProva1;
}

public double getNotaProva2() {

return notaProva2;
}

public double getNotaTrabalho() {

return notaTrabalho;
}

public void setMatricula(int matricula) {

this.matricula = matricula;
}

public void setNome(String nome) {

 this.nome = nome;
}

public void setNotaProva1(double notaProva1) {

this.notaProva1 = notaProva1;
}

public void setNotaProva2(double notaProva2) {

this.notaProva2 = notaProva2;
}

public void setNotaTrabalho(double notaTrabalho) {

this.notaTrabalho = notaTrabalho;
}

public static void main(String[] args) {

Aluno aluno = new Aluno(1, "João", 7.5, 8.0, 9.0);

System.out.println("Média: " + aluno.calculaMedia());

System.out.println("Nota necessária na prova final: " +
aluno.calculaFinal());
}
}
exercicio 2
public class Data implements Cloneable {
private int dia;
private int mes;
private int ano;

public Data(int dia, int mes, int ano) {

if (isDataValida(dia, mes, ano)) {
this.dia = dia;
this.mes = mes;
this.ano = ano;
} else {
this.dia = 1;
this.mes = 1;
this.ano = 1;
}
}

private boolean isDataValida(int dia, int mes, int ano) {

if (ano < 1 || mes < 1 || mes > 12 || dia < 1) {
return false;
}

int ultimoDiaNoMes = 31;

if (mes == 4 || mes == 6 || mes == 9 || mes == 11) {
ultimoDiaNoMes = 30;
} else if (mes == 2) {
if (ano % 4 == 0 && (ano % 100 != 0 || ano % 400 == 0)) {
ultimoDiaNoMes = 29;
} else {
ultimoDiaNoMes = 28;
}
}

return dia <= ultimoDiaNoMes;

}
 public int compara(Data outraData) {
if (ano > outraData.ano || (ano == outraData.ano && mes > outraData.mes) ||
(ano == outraData.ano && mes == outraData.mes && dia > outraData.dia)) {
return 1;
} else if (ano < outraData.ano || (ano == outraData.ano && mes <
outraData.mes) || (ano == outraData.ano && mes == outraData.mes && dia <
outraData.dia)) {
return -1;
}
return 0;
}

public int getDia() {

return dia;
}

public int getMes() {

return mes;
}

public String getMesExtenso() {

String[] meses = {"Janeiro", "Fevereiro", "Março", "Abril", "Maio",
"Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"};
return meses[mes - 1];
}

public int getAno() {

return ano;
}

public boolean isBissexto() {

return (ano % 4 == 0 && (ano % 100 != 0 || ano % 400 == 0));
}

@Override
public Data clone() {
return new Data(this.dia, this.mes, this.ano);
}

public static void main(String[] args) {

Data data1 = new Data(15, 8, 2023);
Data data2 = new Data(10, 8, 2023);

System.out.println("Comparação: " + data1.compara(data2));

System.out.println("Mês por extenso: " + data1.getMesExtenso());
System.out.println("Ano bissexto: " + data1.isBissexto());

Data cloneData = data1.clone();

System.out.println("Clone: Dia " + cloneData.getDia() + ", Mês " +
cloneData.getMes() + ", Ano " + cloneData.getAno());
}
}
exercicio 3
public class Voo {
private int numeroVoo;
private Data data;
private boolean[] ocupacao; // Array de ocupação das cadeiras
private int vagasDisponiveis;
 public Voo(int numeroVoo, Data data) {
this.numeroVoo = numeroVoo;
this.data = data;
this.ocupacao = new boolean[100]; // Inicializa array de ocupação com 100
cadeiras
this.vagasDisponiveis = 100; // Inicialmente todas as cadeiras estão vagas
}

public int proximoLivre() {

for (int i = 0; i < ocupacao.length; i++) {
if (!ocupacao[i]) {
return i + 1; // O número da cadeira é índice + 1
}
}
return -1; // Não há cadeiras livres
}

public boolean verifica(int numeroCadeira) {

if (numeroCadeira >= 1 && numeroCadeira <= 100) {
return ocupacao[numeroCadeira - 1];
}
return false; // Número de cadeira inválido
}

public boolean ocupa(int numeroCadeira) {

if (numeroCadeira >= 1 && numeroCadeira <= 100 && !ocupacao[numeroCadeira -
1]) {
ocupacao[numeroCadeira - 1] = true;
vagasDisponiveis--;
return true;
}
return false; // Número de cadeira inválido ou já ocupada
}

public int vagas() {

return vagasDisponiveis;
}

public int getVoo() {

return numeroVoo;
}

public Data getData() {

return data;
}

@Override
public Voo clone() {
Voo cloneVoo = new Voo(this.numeroVoo, this.data.clone());
cloneVoo.ocupacao = this.ocupacao.clone();
cloneVoo.vagasDisponiveis = this.vagasDisponiveis;
return cloneVoo;
exercicio 4
public class Prova {
private Gabarito gabarito;
private char[] respostasAluno;
private int contadorQuestao;
 public Prova(Gabarito gabarito) {
this.gabarito = gabarito;
this.respostasAluno = new char[15];
this.contadorQuestao = 0;
}

public void respostaAluno(char resposta) {

if (contadorQuestao >= 0 && contadorQuestao < 15) {
respostasAluno[contadorQuestao] = resposta;
contadorQuestao++;
}
}

public int acertos() {

int acertos = 0;
for (int i = 0; i < respostasAluno.length; i++) {
if (respostasAluno[i] == gabarito.respostaQuestao(i + 1)) {
acertos++;
}
}
return acertos;
}

public double nota() {

int acertos = acertos();
double nota = (acertos <= 10) ? acertos * 0.5 : 5 + (acertos - 10);
return nota;
}

public static Prova maior(Prova prova1, Prova prova2) {

int acertosProva1 = prova1.acertos();
int acertosProva2 = prova2.acertos();

if (acertosProva1 > acertosProva2) {

return prova1;
} else if (acertosProva2 > acertosProva1) {
return prova2;
} else {
double notaProva1 = prova1.nota();
double notaProva2 = prova2.nota();

if (notaProva1 > notaProva2) {

return prova1;
} else if (notaProva2 > notaProva1) {
return prova2;
} else {
return prova1; // Em caso de empate, retorna a primeira prova
}
}
}

public static void main(String[] args) {

Gabarito gabarito = new Gabarito(); // Supondo que você já tenha a classe
Gabarito implementada
Prova prova1 = new Prova(gabarito);
Prova prova2 = new Prova(gabarito);

prova1.respostaAluno('A');
prova1.respostaAluno('B');
 // ... continua para as outras questões

prova2.respostaAluno('A');
prova2.respostaAluno('C');
// ... continua para as outras questões

System.out.println("Acertos da prova 1: " + prova1.acertos());

System.out.println("Nota da prova 1: " + prova1.nota());

System.out.println("Acertos da prova 2: " + prova2.acertos());

System.out.println("Nota da prova 2: " + prova2.nota());

Prova provaMaior = Prova.maior(prova1, prova2);

System.out.println("A prova com a maior nota ou mais acertos é a prova " +
provaMaior);
}
}
exercicio 5
public class Vetor {
private String[] elementos;
private int tamanho;

public Vetor(int tamanhoInicial) {

elementos = new String[tamanhoInicial];
tamanho = 0;
}

public void insert(String elemento) {

if (tamanho == elementos.length) {
aumentarTamanho();
}
elementos[tamanho] = elemento;
tamanho++;
}

public String get(int posicao) {

if (posicao >= 0 && posicao < tamanho) {
return elementos[posicao];
}
return null;
}

public int size() {

return tamanho;
}

private void aumentarTamanho() {

int novoTamanho = elementos.length * 2;
String[] novoVetor = new String[novoTamanho];
for (int i = 0; i < elementos.length; i++) {
novoVetor[i] = elementos[i];
}
elementos = novoVetor;
}

public static void main(String[] args) {

Vetor vetor = new Vetor(5);

vetor.insert("Primeiro");
 vetor.insert("Segundo");
vetor.insert("Terceiro");
vetor.insert("Quarto");
vetor.insert("Quinto");
vetor.insert("Sexto");

System.out.println("Elemento na posição 3: " + vetor.get(2));

System.out.println("Tamanho do vetor: " + vetor.size());
}
}

exercicio 6
public class VetorOrdenado {
private String[] elementos;
private int tamanho;

public VetorOrdenado(int tamanhoInicial) {

elementos = new String[tamanhoInicial];
tamanho = 0;
}

public void insert(String elemento) {

if (tamanho == elementos.length) {
aumentarTamanho();
}

int posicaoInsercao = 0;
while (posicaoInsercao < tamanho &&
elemento.compareTo(elementos[posicaoInsercao]) > 0) {
posicaoInsercao++;
}

for (int i = tamanho; i > posicaoInsercao; i--) {

elementos[i] = elementos[i - 1];
}

elementos[posicaoInsercao] = elemento;
tamanho++;
}

public VetorOrdenado merge(VetorOrdenado outroVetor) {

VetorOrdenado vetorMerged = new VetorOrdenado(this.tamanho +
outroVetor.tamanho);

int indiceVetor1 = 0;
int indiceVetor2 = 0;

while (indiceVetor1 < this.tamanho && indiceVetor2 < outroVetor.tamanho) {

if
(this.elementos[indiceVetor1].compareTo(outroVetor.elementos[indiceVetor2]) < 0) {
vetorMerged.insert(this.elementos[indiceVetor1]);
indiceVetor1++;
} else {
vetorMerged.insert(outroVetor.elementos[indiceVetor2]);
indiceVetor2++;
}
}

while (indiceVetor1 < this.tamanho) {

 vetorMerged.insert(this.elementos[indiceVetor1]);
indiceVetor1++;
}

while (indiceVetor2 < outroVetor.tamanho) {

vetorMerged.insert(outroVetor.elementos[indiceVetor2]);
indiceVetor2++;
}

return vetorMerged;
}

private void aumentarTamanho() {

int novoTamanho = elementos.length * 2;
String[] novoVetor = new String[novoTamanho];
for (int i = 0; i < elementos.length; i++) {
novoVetor[i] = elementos[i];
}
elementos = novoVetor;
}

public static void main(String[] args) {

VetorOrdenado vetor1 = new VetorOrdenado(5);
VetorOrdenado vetor2 = new VetorOrdenado(5);

vetor1.insert("Banana");
vetor1.insert("Maçã");
vetor1.insert("Pêra");

vetor2.insert("Laranja");
vetor2.insert("Uva");
vetor2.insert("Abacaxi");

VetorOrdenado mergedVetor = vetor1.merge(vetor2);

for (int i = 0; i < mergedVetor.tamanho; i++) {

System.out.println(mergedVetor.elementos[i]);
}
}
}
exercicio 7
public class VooAprimorado extends Voo {
private int maxVagas;
private int cadeirasFumantes;

public VooAprimorado(int numeroVoo, Data data, int maxVagas, int

cadeirasFumantes) {
super(numeroVoo, data);
this.maxVagas = maxVagas;
this.cadeirasFumantes = cadeirasFumantes;
}

@Override
public int proximoLivre() {
int vagasDisponiveis = maxVagas - getVagas();
if (vagasDisponiveis > 0) {
return super.proximoLivre();
}
return -1; // Não há vagas disponíveis
 }

@Override
public boolean verifica(int numeroCadeira) {
if (numeroCadeira >= 1 && numeroCadeira <= maxVagas) {
return super.verifica(numeroCadeira);
}
return false; // Número de cadeira inválido
}

@Override
public boolean ocupa(int numeroCadeira) {
if (numeroCadeira >= 1 && numeroCadeira <= maxVagas) {
return super.ocupa(numeroCadeira);
}
return false; // Número de cadeira inválido
}

public int maxVagas() {

return maxVagas;
}

public int cadeirasFumantes() {

return cadeirasFumantes;
}

public char tipo(int numeroCadeira) {

if (numeroCadeira > maxVagas - cadeirasFumantes) {
return 'F'; // Cadeira para fumantes
}
return 'N'; // Cadeira para não fumantes
}

public static void main(String[] args) {

Data dataVoo = new Data(15, 8, 2023);
VooAprimorado voo = new VooAprimorado(123, dataVoo, 150, 30);

System.out.println("Próxima cadeira livre: " + voo.proximoLivre());

System.out.println("Tipo da cadeira 110: " + voo.tipo(110));
}
}
exercicio 8
public class EquipamentoCorrigido extends Equipamento {
private int mesCorrente;

public EquipamentoCorrigido(int numeroEquipamentos, int mesCorrente) {

super(numeroEquipamentos);
this.mesCorrente = mesCorrente;
}

public int getMesCompra(int numeroEquipamento) {

return super.getValor(numeroEquipamento);
}

public void setMesCompra(int numeroEquipamento, int mesCompra) {

super.setValor(numeroEquipamento, mesCompra);
}

public void corrige(double percentualCorrecao) {

 for (int i = 0; i < getNumeroEquipamentos(); i++) {
if (getMesCompra(i) == mesCorrente) {
double valorAtual = getValor(i);
double valorCorrigido = valorAtual * (1 + percentualCorrecao /
100);
setValor(i, valorCorrigido);
}
}

mesCorrente++;
if (mesCorrente > 12) {
mesCorrente = 1;
}
}

public void substitui(EquipamentoCorrigido outroEquipamento) {

if (getNumeroEquipamentos() == outroEquipamento.getNumeroEquipamentos()) {
for (int i = 0; i < getNumeroEquipamentos(); i++) {
double valor = outroEquipamento.getValor(i);
int mesCompra = outroEquipamento.getMesCompra(i);
setValor(i, valor);
setMesCompra(i, mesCompra);
}
}
}

public static void main(String[] args) {

EquipamentoCorrigido equipamentos = new EquipamentoCorrigido(5, 1); // Mês
corrente começa em janeiro

equipamentos.setValor(0, 100.0);
equipamentos.setValor(1, 200.0);
equipamentos.setValor(2, 300.0);
equipamentos.setValor(3, 400.0);
equipamentos.setValor(4, 500.0);

equipamentos.setMesCompra(0, 1);
equipamentos.setMesCompra(1, 2);
equipamentos.setMesCompra(2, 3);
equipamentos.setMesCompra(3, 4);
equipamentos.setMesCompra(4, 5);

System.out.println("Valores antes da correção:");

for (int i = 0; i < equipamentos.getNumeroEquipamentos(); i++) {
System.out.println("Equipamento " + i + " - Valor: " +
equipamentos.getValor(i) +
", Mês de Compra: " + equipamentos.getMesCompra(i));
}

equipamentos.corrige(10);

System.out.println("\nValores após a correção:");

for (int i = 0; i < equipamentos.getNumeroEquipamentos(); i++) {
System.out.println("Equipamento " + i + " - Valor: " +
equipamentos.getValor(i) +
", Mês de Compra: " + equipamentos.getMesCompra(i));
}
}
}