Q:

Eliminar año de LocalDate - Exception: Text '20-04' could not be parsed at index 0

Estoy realizando un programa sobre el zodiaco.  Básicamente consta de que metiendo una fecha localDate te devuelva cuál es tu signo del zodiaco.  Para ello dispongo de dos clases, una es tipo enum donde defino cada uno de los signos (teniendo en cuenta la fecha de inicio, la fecha final y el elemento de cada signo: Fire, Earth, Air y Water) y una clase main desde donde hago preguntas ha esta clase. 
Incluyo ambas clases:
    //Prueba para ver si devuelve correctamente el nombre
    System.out.println("Nombre del signo:");
    System.out.println(Zodiac. AQUARIUS.name());
    System.out.println("");

    //Prueba para ver si devuelve correctamente el toString del signo solicitado 
    System.out.println("Información sobre el signo:");
    System.out.println(Zodiac. LEO.toString());
    System.out.println("");

    //Devuelve el elemento de cada signo
    System.out.println("Elemento del signo:");
    System.out.println(Zodiac. LEO.getElement());
    System.out.println("");

    //Devuelve la posición que guarda
    System.out.println("Posición que ocupa el signo:");
    System.out.println(Zodiac. SCORPIO.ordinal());
    System.out.println("");

    //Devuelve el signo de la fecha introducida
    System.out.println("Signo de fecha concreta:");
    System.out.println(Zodiac.getZodiac(LocalDate.of(2019, 4, 20)));
    System.out.println("");

La clase enum es la siguiente:
ARIES (LocalDate.of(2019, 3 ,21), LocalDate.of(2019, 4 ,19), "Fire"),
TAURUS(LocalDate.of(2019, 4 ,20),LocalDate.of(2019, 5 ,20),"Earth"),
GEMINI(LocalDate.of(2019, 5 ,21),LocalDate.of(2019, 6 ,20),"Air"),
CANCER(LocalDate.of(2019, 6 ,21),LocalDate.of(2019, 7 ,22),"Water"),
LEO(LocalDate.of(2019, 7 ,23),LocalDate.of(2019, 8 ,22),"Fire"),
VIRGO(LocalDate.of(2019, 8 ,23),LocalDate.of(2019, 9 ,22),"Earth"),
LIBRA(LocalDate.of(2019, 9 ,23),LocalDate.of(2019, 10 ,22),"Air"),
SCORPIO(LocalDate.of(2019, 10 ,23),LocalDate.of(2019, 11 ,21),"Water"),
SAGITTARIUS(LocalDate.of(2019, 11 ,22),LocalDate.of(2019, 12 ,21),"Fire"),
CAPRICORN(LocalDate.of(2019, 12 ,22),LocalDate.of(2020, 1 ,19),"Earth"),
AQUARIUS(LocalDate.of(2020, 1 ,20),LocalDate.of(2020, 2 ,18),"Air"),
PISCES(LocalDate.of(2020, 2 ,19),LocalDate.of(2020, 3 ,20),"Water");

private  String element;
private  LocalDate begining = LocalDate.of(2019, 01 ,01); 
private  LocalDate ending = LocalDate.of(2019, 01 ,01);

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM");

private Zodiac(LocalDate begining, LocalDate ending, String element) {
            this.begining=begining;
            this.ending=ending;
            this.element=element;
}

public LocalDate getBegining() {
    return begining;
}

public LocalDate getEnding() {
    return ending;
}

public String getElement() {
    return element;
}

public static String getZodiac(LocalDate birthdate) throws Exception{

    LocalDate localDate = birthdate;
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM");
    String birthdateFormatted = localDate.format(formatter);

    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("20-03")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("20-04"))) {
        return ARIES.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("19-04")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("21-05"))) {
        return TAURUS.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("20-05")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("21-06"))) {
        return GEMINI.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("20-06")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("23-07"))) {
        return CANCER.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("22-07")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("23-08"))) {
        return LEO.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("22-08")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("23-09"))) {
        return VIRGO.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("22-09")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("23-10"))) {
        return LIBRA.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("22-10")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("22-11"))) {
        return SCORPIO.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("21-11")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("22-12"))) {
        return SAGITTARIUS.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("21-12")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("20-01"))) {
        return CAPRICORN.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("19-01")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("19-02"))) {
        return AQUARIUS.name();
    }
    if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("18-02")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("21-03"))) {
        return PISCES.name();
    }
    else {
        throw new Exception("It has been impossible to obtain the zodiac sign for the date" + birthdate);
    }

}
@Override
public String toString() {
    return name()+ " ("+begining.format(formatter)+"-"+ending.format(formatter)+")"+" - "+ getElement();
}

Ahora bien, al ejecutar System.out.println(Zodiac.getZodiac(LocalDate.of(2019, 4, 20))); debería recibir simplemente el nombre del signo al que corresponde dicha fecha.  Pues recibo el siguiente mensaje exception: 
Exception in thread "main" java.time.format. DateTimeParseException: **Text '20-04' could not be parsed at index 0**
    at java.base/java.time.format.DateTimeFormatter.parseResolved0(DateTimeFormatter.java:2049)
    at java.base/java.time.format.DateTimeFormatter.parse(DateTimeFormatter.java:1951)
    at java.base/java.time.LocalDate.parse(LocalDate.java:428)
    at java.base/java.time.LocalDate.parse(LocalDate.java:413)
    at PAC2_ex4/PAC2_ex4.Zodiac.getZodiac(Zodiac.java:51)
    at PAC2_ex4/PAC2_ex4.Check.main(Check.java:33)

Como se puede ver tengo que hacer la llamada al método getZodiac con un localdate.of(2019,4,20), ya que es el formato que admite localdate.  Pues bien, mi intención dentro del método getZodiac es darle un formato de ("dd-MM") y para ello utilizó el siguiente código:
   LocalDate localDate = birthdate;
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM");
        String birthdateFormatted = localDate.format(formatter);

Para después poder usar isAfter y isBefore con las fechas de cada zodiaco.  Un ejemplo sería:
if(LocalDate.parse(birthdateFormatted).isAfter(LocalDate.parse("20-03")) && LocalDate.parse(birthdateFormatted).isBefore(LocalDate.parse("20-04"))) {
        return ARIES.name();
    }

No se por que me salta el error o que debo modificar.  Os agradecería que me echaseis una mano ya que llevo un tiempo con este problema y no encuentro solución. 

A:

Puedes crear un Array con los meses y los signos, el cual una vez indiquen la fecha el código hace unas cuantas comprobaciones de que todos los datos estén correctamente y vemos que signo es.  En este código usamos el año en caso de que inserten un año bisiesto. 
Usando el calendario instanciado ponemos que día empieza un signo hasta el siguiente, así en cada comprobación el que se encuentre en el rango le asigna ese signo. 
He comentado un poco para poder guiar en diferentes partes. 
public class Main {

    private static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {

        System.out.println(FechaFormateador.format(calendario.getTime()));

        int dia = 0;
        int mes = 0;
        int anyo = 0;

        while (true) {

            System.out.print("Inserta el año: ");
            anyo = sc.nextInt();

            while (true) {
                System.out.print("Inserta un mes, siendo Enero el 1 hasta Diciembre siendo el 12: ");
                mes = sc.nextInt();

                if (MesValido(--mes)) // restamos uno para no salirnos del array

                    break;
            }

            while (true) {
                System.out.print("Inserta el dia: ");
                dia = sc.nextInt();

                if (DiaValido(dia, mes, anyo))
                    break;
            }

            // Aqui comprobamos que signo es
            calendario.set(anyo, mes, dia);

            for (int i = 0; i < SignoCalendar.length; ++i) {
                SignoCalendar[i].set(GregorianCalendar. YEAR, anyo);
            }

            for (int i = 0; i < SignoCalendar.length; ++i) {
                if (calendario.after(SignoCalendar[i])
                        && calendario.before(SignoCalendar[(i + 1) % SignoCalendar.length])) {
                    System.out.println(FechaFormateador.format(calendario.getTime()) + " pertenece al signo de " + Signos[i]);
                    break;
                }
            }

            // Por si quieres repetir
            System.out.println("¿Quieres volver a probarlo? ( Indica Y(Si) o N(No))?"); 
            if (! opcion()) {
                break;
            }
        }
    }

    // Validar el mes
    private static boolean MesValido(int mes) {
        if (mes >= 0 && mes <= 11)
            return true;
        else
            System.out.println("Debes indicar entre el 1 (Enero) y el 12 (Diciembre)."); 
        return false;
    }

    // Validamos el dia
    private static boolean DiaValido(int dia, int mes, int anyo) {
        /*
         * Un dia valido es entre el 1 y el 31 a excepción de
         * Abril, Junio, Septiembre, o Noviembre - menos de 29 si es Febrero y
         * si no es bisiesto - menos de 30 si es bisiesto
         */
        if (dia < 0 || dia > 31) {
            System.out.println("El valor de los dias debe ser entre el 1 y el 31."); 
            return false;
        }

        if (dia > 30 && (mes == 3 || mes == 5 || mes == 8 || mes == 10)) {
            System.out.println(
                    "Estos dias deben de ser menos de 31 si son"
                            + diameses[mes] + ".  Pruebe otra vez."); 
            return false;
        }

        // Posibles bisiestos V1
        if (dia > 28 && mes == 1 && ! calendario.isLeapYear(anyo)) {
            System.out.println(anyo + " No es bisiesto "
                    + " asi que debe ser menos de 29."); 
            return false;
        }

        // Posibles bisiestos V2
        return dia <= 29 || mes ! = 1 || ! calendario.isLeapYear(anyo);

    }

    private static boolean opcion() {
        String stSoN = null;
        while (true) {
            try {
                stSoN = br.readLine().trim();
            } catch (IOException e) {
                System.out.println("Error..." + e.getMessage());
            }

            if (stSoN ! = null) {
                if (stSoN.equalsIgnoreCase("Y")) {
                    return true;
                } else if (stSoN.equalsIgnoreCase("N")) {
                    break;
                } else {
                    System.out.print("Debes insertar Y o N: ");
                }
            }
        }
        return false;
    }

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    // Nombres de los signos y su dia de comienzo.  Recuerda que por el array, el mes empieza en 0.  No se si los nombres son así en castellano. 
    private static String[] Signos = { "Aquario", "Pisci", "Aries", "Tauro",
            "Geminis", "Cancer", "Leo", "Virgo",
            "Libra", "Escopion", "Sagitario", "Capricornio" };

    private static GregorianCalendar[] SignoCalendar = { new GregorianCalendar(2002, 0, 20), // Aqui es Aquarius
            new GregorianCalendar(2002, 1, 19), // Pisces
            new GregorianCalendar(2002, 2, 21), // Aries
            new GregorianCalendar(2002, 3, 20), // Tauro
            new GregorianCalendar(2002, 4, 21), // Gemini
            new GregorianCalendar(2002, 5, 21), // Cancer
            new GregorianCalendar(2002, 6, 23), // Leo
            new GregorianCalendar(2002, 7, 23), // Virgo
            new GregorianCalendar(2002, 8, 23), // Libra
            new GregorianCalendar(2002, 9, 23), // Escorpion
            new GregorianCalendar(2002, 10, 22), // Sagitario
            new GregorianCalendar(2002, 11, 22), // Capricornio
    };

    private static GregorianCalendar calendario = new GregorianCalendar();

    public static final String[] diameses = { "Enero", "Febrero", "Marzo",
            "Abril", "Mayo", "Junio", "Julio",
            "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre" };

    // Formateador de la fecha
    public static DateFormat FechaFormateador = DateFormat.getDateInstance(DateFormat. LONG);
}

Compruébalo y ojala te sirva de ayuda. 

A:

Al final el resultado es más fácil que todo esto.  Y es que dado que el zodiaco no cambia de fechas año tras año, nos da igual que año mandemos.  Pero al crear cada signo en el enum creamos un LocalDate.of(YYYY, MM, DD) (uno de fecha inicio y otro fecha final). 
Pues bien, en vez de jugar con la fecha lo que haremos en el método getZodiac será lo siguiente:
    public static Zodiac getZodiac(LocalDate date) {

    date = date.withYear(2019); 

    for(Zodiac zodiac : values()) {

        if ((zodiac.init.isBefore(date) || zodiac.init.isEqual(date))
                && (zodiac.end.isAfter(date) || zodiac.end.isEqual(date))) {
            return zodiac;
        }

    }

Así al meter, por ejemplo, que signo es el 14 de abril de 1984, este método pasará el 1984 a 2019 y así podrá buscar dentro de los enum creados.  
Espero que alguien pueda aprovechar esto algún día. 
Un saludo!