Método compila y se pasa obras con un tipo incorrecto de variables

Mak:

Así que aquí es parte del código que estoy probando:

interface sample
{
    Vector Sum(Vector vec);
    Vector Subtraction(Vector vec);
    int Product(Vector vec);
    boolean Compare(Vector vec);
    String ToString();
}

abstract class Vector implements sample
{       
     int[] coordinates; 
     public Vector (int[] coordinates)
     {
         this.coordinates=coordinates;
     }
}

abstract Vector resVec();

public boolean Compare(Vector vec)
{
    if (this.coordinates.length == vec.coordinates.length)
    {
        for (int i = 0; i<vec.coordinates.length; i++)
        {
            if (this.coordinates[i] == vec.coordinates[i])
                continue;
            else return false;
        }
    }
    else 
    {
        throw new ArithmeticException("Can't compare vectors of different length");
    }
    return true;
}

Y aquí es clases que yo llamo los métodos de: 1)

class Vector3D extends Vector
{

public Vector3D(int n1,int n2,int n3) 
{
    super(new int[]{n1,n2,n3});
}
public Vector3D resVec()
{
    Vector3D resVec = new Vector3D(0,0,0);
    return resVec;
}

public boolean Compare(Vector3D vec)
{
    return super.Compare(vec);
}

2)

class VectorND extends Vector
{
    public VectorND(int...n) 
    {       
            super(n);
    }
    public VectorND resVec()
    {
        VectorND resVec = new VectorND();
        return resVec;
    }

    public boolean Compare(VectorND vec)
      {
          return super.Compare(vec);
      }
}

Así que el problema es que por alguna razón si escribo algo así en el principal:

public class main {

    public static void main(String[] args) 
    {
        Vector3D B = new Vector3D(1,-3,3);
        VectorND A = new VectorND(1,-3,3);
        System.out.println(A.Compare(B));
    }
}

Es perfectamente funciona y devuelve verdadero si bien debería haber escrito una excepción que VectorND se esperaba en la llamada de comparación de A. ¿Cuál podría ser el problema?

En Magnus:

El problema es que no se está reemplazando el Compare()método de la clase base Vectoren VectorNDy Vector3D. En su lugar, usted está declarando nuevos métodos que toman un objeto del mismo tipo ( VectorNDo Vector3D) de sus subclases. El original Compare()método de la clase base está disponible en las subclases, y es que el método get que llama cuando se llama A.Compare(B).

Para que quede más claro, usted tiene

Vector{
    public boolean Compare(Vector vec){ ... }
}

class Vector3D extends Vector {
    public boolean Compare(Vector vec){ ... }
    public boolean Compare(Vector3D vec){ ... } 
}

class VectorND extends Vector {
    public boolean Compare(Vector vec){ ... }
    public boolean Compare(VectorND vec){ ... } 
}

Así que cuando se llama

A.Compare(B)

y no hay se Compare(Vector3D)declararon en clase VectorND, lo que está haciendo en realidad es llamado

Vector.Compare(Vector)

ya que tanto Ay Bse derivan de la clase base Vector.

Si realmente desea anular el Comparemétodo Vectorcon los de sus subclases, es necesario declararlos de forma idéntica en las subclases (es decir, con el mismo tipo de parámetro).

Y si realmente desea que el método para producir una excepción en el caso específico, es necesario comprobar explícitamente el tipo de la Vectorusando el instanceofoperador, y lanzar una excepción si no es del mismo tipo.

public class Vector3D extends Vector {
    @Override
    public boolean Compare(Vector vec){
        if( !(vec instanceof Vector3D) )
            throw new IllegalArgumentException("Vector3D can only be compared to Vector3D!");

        // Compare and return true or false
    }
}

La @Overrideanotación indica que la intención de reemplazar un método en la clase base. Si no existe un método correspondiente en la clase base, por ejemplo, si se intenta hacer

@Override
public boolean Compare(Vector3D vec)

el compilador / IDE emitirá un error para notificarle que usted no está anulando cualquier cosa (ya que la Vectorclase no tiene ningún Compare(Vector3D vec)método).