Como resolvo esse problema?

Olá, sou nova em programação e estou a horas tentando resolver essa questão e não consigo.

"Escreva um programa que converta uma avaliação escolar baseada em letras para uma nota numérica.

As letras sao A,B,C,D e F, possivelmente seguidas por + ou -.
Seus valores numericos sao 4,3,2,1 e 0. Não existe F+ ou F-.

Um + aumenta o valor numérico em 0.3, um - diminui o valor em 0.3.

Mas um A+ tem o valor de 4.0."

public double converteNova(String nota) {
    switch(nota) {
        case "A+":
            return 4.3;
        case "A":
            return 4;
        case "A-":
           return 3.7;
....

        default:
            0.00
    }
}

ai voce faz um case para cada leta com e com o + e -

Estava tentando fazer também, mas a nota A+ representa 4. Acredito q seja assim

    private static String mostra_letra() {
        String letra_coisada = "";
        if (nota == 4) {
            letra_coisada = "A+";
        } else if (nota <= 3.7 && nota >= 3.5) {
            letra_coisada = "A";
        } else if (nota <= 3.4 && nota >= 3) {
            letra_coisada = "A-";
        }
        return letra_coisada;
    }

exercício legal até

Fiz de uma jeito aqui para estimular uma outra forma de fazer (a lógica na classe Nota pode ser melhorada):

Nota

import java.util.Arrays;
import java.util.stream.Stream;

public class Nota {

	private static final double VALOR_SINAL = 0.3;
	private final Letra letra;
	private final Sinal sinal;
	
	private Nota(Letra letra, Sinal sinal) {
		this.letra = letra;
		this.sinal = sinal;
	}
	
	public static Nota of(String nota) {
		if (nota == null || nota.isEmpty()) {
			throw new IllegalArgumentException("Nota inválida");
		}
		
		String[] partes = nota.split("");
		Letra letra = Letra.of(partes[0]);
		Sinal sinal = null;
		
		if (partes.length > 1) {
			sinal = Sinal.of(partes[1]);
		}
		
		return new Nota(letra, sinal);
	}
	
	private enum Letra {
		A(4.0), B(3.0), C(2.0), D(1.0), F(0.0);
		
		private Double valor;
		
		private Letra(Double valor) {
			this.valor = valor;
		}

		private static Letra of(String valor) {
			return Stream.of(values()).filter(i -> i.name().equals(valor.toUpperCase())).findFirst()
			.orElseThrow(() -> new IllegalArgumentException("Letra inválida. Valores válidos: " + Arrays.toString(values())));
		}

		public Double getValor() {
			return valor;
		}
	}
	
	private enum Sinal {
		PLUS("+"), MINUS("-");
		
		private String sinal;
		
		private Sinal(String sinal) {
			this.sinal = sinal;
		}
		
		private static Sinal of(String valor) {
			return Stream.of(values()).filter(i -> i.sinal.equals(valor)).findFirst()
			.orElseThrow(() -> new IllegalArgumentException("Sinal inválido. Valores válidos: [+, -]"));
		}
	}
	
	public Double getValor() {
		if (sinal == null) {
			return getValorSemSinal();
		}
		
		return getValorComSinal();
	}
	
	private Double getValorSemSinal() {
		return letra.getValor();
	}
	
	private Double getValorComSinal() {
		if (letra == Letra.A && sinal == Sinal.PLUS || letra == Letra.F) {
			return letra.getValor();
		}
		
		if (Sinal.PLUS == sinal) {
			return letra.getValor() + VALOR_SINAL;
		}
		
		return letra.getValor() - VALOR_SINAL;
	}
}

NotaTest

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import org.junit.jupiter.api.Test;

class NotaTest {

	@Test
	void deveRetornarNotaA() {
		Nota actual = Nota.of("A");
		Nota actualPlus = Nota.of("A+");
		Nota actualMinus = Nota.of("A-");
		
		assertEquals(4.0, actual.getValor());
		assertEquals(4.0, actualPlus.getValor());
		assertEquals(3.7, actualMinus.getValor());
	}
	
	@Test
	void deveRetornarNotaB() {
		Nota actual = Nota.of("B");
		Nota actualPlus = Nota.of("B+");
		Nota actualMinus = Nota.of("B-");
		
		assertEquals(3.0, actual.getValor());
		assertEquals(3.3, actualPlus.getValor());
		assertEquals(2.7, actualMinus.getValor());
	}
	
	@Test
	void deveRetornarNotaC() {
		Nota actual = Nota.of("C");
		Nota actualPlus = Nota.of("C+");
		Nota actualMinus = Nota.of("C-");
		
		assertEquals(2.0, actual.getValor());
		assertEquals(2.3, actualPlus.getValor());
		assertEquals(1.7, actualMinus.getValor());
	}
	
	@Test
	void deveRetornarNotaD() {
		Nota actual = Nota.of("D");
		Nota actualPlus = Nota.of("D+");
		Nota actualMinus = Nota.of("D-");
		
		assertEquals(1.0, actual.getValor());
		assertEquals(1.3, actualPlus.getValor());
		assertEquals(0.7, actualMinus.getValor());
	}
	
	@Test
	void deveRetornarNotaF() {
		Nota actual = Nota.of("F");
		Nota actualPlus = Nota.of("F+");
		Nota actualMinus = Nota.of("F-");
		
		assertEquals(0.0, actual.getValor());
		assertEquals(0.0, actualPlus.getValor());
		assertEquals(0.0, actualMinus.getValor());
	}
	
	@Test
	void deveLancarExcecaoNovaVazia() {
		IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Nota.of(""));
		assertTrue(exception.getMessage().contains("Nota inválida"));
	}
	
	@Test
	void deveLancarExcecaoNovaNull() {
		IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Nota.of(null));
		assertTrue(exception.getMessage().contains("Nota inválida"));
	}
	
	@Test
	void deveLancarExcecaoLetraInvalida() {
		IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Nota.of("G"));
		assertTrue(exception.getMessage().contains("Letra inválida"));
	}
	
	@Test
	void deveLancarExcecaoSinalInvalida() {
		IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Nota.of("A*"));
		assertTrue(exception.getMessage().contains("Sinal inválido"));
	}
}
1 curtida

Se ela chega com esse código nem precisa estudar os outros semetres kkkkkkkk, muito bom!!

1 curtida