El ejercicio consiste en decir, dadas dos fechas, cual es anterior, haciendo comprobaciones anteriores para saber si son correctas,contando años bisiestos.

Si la primera fecha es incorrecta la salida será: Primera fecha incorrecta.
Si la segunda fecha es incorrecta la salida será: Segunda fecha incorrecta.
Si son iguales: Representan el mismo día.
Si la primera fecha es anterior a la segunda: La primera es anterior.
Si la segunda fecha es anterior a la primera: La segunda es anterior.

Mi solución es la siguiente:

import java.util.*;
 
public class fechaCorrecta
{
    public byte dia = 0,mes = 0;
    public short anyo = 0;  
 
    public fechaCorrecta(byte dia,byte mes,short anyo)
    {
        this.dia = dia;
        this.mes = mes;
        this.anyo = anyo;
    }
 
    public boolean compruebaFecha()
    {
        boolean esBisiesto;
        esBisiesto = (this.anyo % 4 == 0 && this.anyo % 100 != 0) || ( this.anyo % 400 == 0);
        switch(mes)
        {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                if(this.dia < 0 || this.dia > 31) return false;
                else return true;
            case 4:
            case 6:
            case 9:
            case 11:
                if(this.dia < 0 || this.dia > 30) return false;
                else return true;
            case 2:
                if(esBisiesto)
                {
                    if(this.dia < 0 || this.dia > 29) return false;
                    else return true;
                }
                else
                {
                    if(this.dia < 0 || this.dia > 28) return false;
                    else return true;
                }
            }
            return false;
    }
 
    public boolean equals(Object o)
    {
        return (o instanceof fechaCorrecta) && (this.dia == ((fechaCorrecta)o).dia) && (this.mes == ((fechaCorrecta)o).mes) && (this.anyo == ((fechaCorrecta)o).anyo);
    }
 
    public boolean compruebaMenorUno(fechaCorrecta fechaDos)
    {
        return (this.anyo < fechaDos.anyo) || (this.anyo == fechaDos.anyo && this.mes < fechaDos.mes) || (this.anyo == fechaDos.anyo && this.mes == fechaDos.mes && this.dia < fechaDos.dia);
    }
 
    public static void main(String args[])
    {
        Scanner entradaTeclado = new Scanner(System.in).useLocale(Locale.US);
        byte diaUno = 0,mesUno = 0,diaDos = 0,mesDos = 0;
        short anyoUno = 0,anyoDos = 0;
        diaUno = entradaTeclado.nextByte();
        mesUno = entradaTeclado.nextByte();
        anyoUno = entradaTeclado.nextShort();
        diaDos = entradaTeclado.nextByte();
        mesDos = entradaTeclado.nextByte();
        anyoDos = entradaTeclado.nextShort();
        fechaCorrecta fechaUno = new fechaCorrecta(diaUno,mesUno,anyoUno);
        fechaCorrecta fechaDos = new fechaCorrecta(diaDos,mesDos,anyoDos);
 
        if(!fechaUno.compruebaFecha()) System.out.print("Primera fecha incorrecta.");
        else 
        {
            if(!fechaDos.compruebaFecha()) System.out.print("Segunda fecha incorrecta.");
            else
            {
                if(fechaUno.equals(fechaDos)) System.out.print("Representan el mismo día");
                else
                {
                     if(fechaUno.compruebaMenorUno(fechaDos)) System.out.print("La primera es anterior.");
                     else System.out.print("La segunda es anterior.");
                }
            }
        }
    }
}

Todos los casos que yo he probado a mano me han dado resultados correctos, sin embargo a la hora de entregarlo en el portal de autocorrección de la universidad me marca errores por codificación ( siendo los resultados numéricos correctos ). Le he enviado un correo al profesor y me ha contestado que ve un fallo gordo en una comparación que falla por haberla puesto como asignación.

No veo ningún fallo así de gordo, de hecho esos los marca el compilador, ¿ a que creéis que hace referencia?

Un saludo