las - interfaces en java pdf

La interfaz Java arroja una excepción, pero la implementación de la interfaz no arroja una excepción.

Question

Leí este código donde la interfaz arroja una excepción, pero la clase que lo implementa no arroja uno ni atrapa uno, ¿por qué? ¿Es legal o seguro en Java?

import java.rmi.*;
public interface MyRemote extends Remote {
    public String sayHello() throws RemoteException;
}

import java.rmi.*;
import java.rmi.server.*;
public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote{
    public String sayHello() {
        return "Server says, ''Hey''";
    }
    public MyRemoteImpl() throws RemoteException {}
    public static void main (String[] args) {
        try {
             MyRemote service = new MyRemoteImpl();
             Naming.rebind("RemoteHello", service);
        } catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

Answer 1

Una regla general de implementación y extensión es que puede hacer que su nueva clase o interfaz sea "menos restrictiva" pero no "más restrictiva". Si considera el requisito de manejar una excepción como una restricción, una implementación que no declara la excepción es menos restrictiva. Cualquiera que codifique en la interfaz no tendrá problemas con tu clase.

- Stan James

Como parte de la discusión en coderanch.com/t/399874/java/java/…

Answer 2

Gran respuesta de @Chetter Hummin.

Una forma de ver esto, y me resulta fácil de recordar, es que las implementaciones de la interfaz pueden ser más específicas pero no más generales.

Por ejemplo, en interfaz void test() throws Exception significa "prueba puede arrojar excepción"

entonces la implementación puede ser void test() significa "prueba no arrojará excepción" (más específica)

o implementación puede ser void test() throws NullpointerException (más específica)

interface x {
    void testException() throws Exception;
}

public class ExceptionTest implements x {
    @Override
    public void testException() {   //this is fine
    }

    ////// or

    @Override
    public void testException() throws NullPointerException {  // this is fine
    }
}

Answer 3

Si un método Java anula a otro en una clase principal, o implementa un método definido en una interfaz, puede que no arroje excepciones comprobadas adicionales, pero puede arrojar menos.

public class A {
    public void thrower() throws SQLException {...}
}

public class B extends A {
    @Override
    public void thrower() throws SQLException, RuntimeException, NamingException {...}
}

SQLException está bien; está declarado en el método reemplazado. Incluso podría ser reemplazado por una subclase como SerialException .

RuntimeException está bien; esos se pueden usar en cualquier lugar.

NamingException es ilegal. No es una RuntimeException , y no está en la lista de A, incluso como un subtipo.