Diferencia entre reflexión y vinculación tardía en Java con ejemplos en tiempo real

Question

Mientras estudiaba tutoriales en Java, Reflection y Late Binding me han confundido. En algunos tutoriales, han escrito que ambos son iguales, y que no hay ninguna diferencia entre Reflection y Late Binding. Pero otros tutoriales dicen que hay una diferencia.

Estoy confundido, por lo que alguien puede explicar qué Reflection y Late Binding están en Java, y si es posible, por favor dame algunos ejemplos del mundo real de ambos.

Gracias ..

Answer 1

enlace tardío (también conocido como envío dinámico) no necesita reflexión - que todavía tiene que saber lo que miembro de unirse dinámicamente a en tiempo de compilación (es decir, la firma de el miembro es conocido en tiempo de compilación), a pesar de que la vinculación a los miembros anulados ocurre en tiempo de ejecución.

Al hacer la reflexión, que ni siquiera sabe miembros que que está usando (ni siquiera el nombrees conocido en tiempo de compilación, por no hablar de la firma) - todo lo que sucede en Run- tiempo, entonces es mucho más lento.

Answer 2

Java usa unión tardía al polimorfismo de soporte; lo que significa que la decisión de cuál de los muchos métodos se debe usar se difiere hasta el tiempo de ejecución.

Tomemos el caso de N clases que implementan un método abstracto de una interfaz (o una clase abstracta, fwiw).

public interface IMyInterface { 

    public void doSomething();  
} 

public class MyClassA implements IMyInterface { 

    public void doSomething(){ ... } 
} 

public class MyClassB implements IMyInterface { 

    public void doSomething(){ ... } 
} 

public class Caller { 

    public void doCall(IMyInterface i){ 
     // which implementation of doSomething is called? 
     // it depends on the type of i: this is late binding 
     i.doSomething(); 
    } 
} 

Reflection se utiliza en su lugar para describir el código que puede inspeccionar otro código, es decir. saber qué métodos o atributos están disponibles en una clase, llamar a un método (o cargar una clase) por nombre, y hacer muchas cosas muy interesantes en tiempo de ejecución.

Una muy agradable explicación de la reflexión está aquí: What is reflection and why is it useful?

Answer 3

ejemplos del mundo real:

Si usted construye su proyecto con jdesktop 0,8, pero nave con jdesktop 0.9, el código se siguen utilizando los 0.9 características, porque aprovecha la vinculación tardía, es decir, el código que llama el código es la versión que carga el cargador de clases, independientemente de la versión contra la que se compiló. (Esto es opuesto a los enlazadores, que incorporan la versión en tiempo de compilación del código llamado en la aplicación.)

Para su reflexión, supongamos que está tratando de apuntar a Java 1.5 y 1.6, pero quiere usar componentes de tabulación en 1.6 si están disponibles, entonces verificará su presencia mediante el uso de la reflexión en la clase JTabbedPane para encontrar el método setTabComponentAt. En este caso, compila contra Java 1.5, que no tiene esas características, por lo que no puede invocarlas directamente o la compilación fallará. Sin embargo, si en el sistema del usuario final se encuentra ejecutando en contra de 1.6 (el enlace atrasado entra en juego aquí) puede usar el reflejo para llamar a los métodos que no existían en 1.5.

Están relacionados; muchos usos de la reflexión se basan en el enlace tardío para ser útil, pero son aspectos fundamentalmente diferentes del lenguaje y su implementación.

Answer 4

Una cuestión importante que aborda el "Enlace tardío" es el polimorfismo, es decir, que la llamada del método apropiado reemplazado a lo largo de la jerarquía de clase se determina durante el tiempo de ejecución, no durante la compilación.La reflexión es la función para recopilar y manipular información sobre sus objetos durante el tiempo de ejecución. P.ej. puedes obtener todos los atributos o nombres de métodos de un objeto usando su atributo 'Clase' durante el tiempo de ejecución y llamar a esos métodos o manipular sus atributos.

En el código siguiente puede crear dinámicamente un nuevo objeto mediante la reflexión (vea cómo se recupera y accede al constructor utilizando una clase, en lugar de simplemente usar obj = new MyClass ("MyInstance")). De forma similar, es posible acceder a otras formas, métodos y atributos de constructor. Para obtener más información acerca de la reflexión en la visita java: http://java.sun.com/developer/technicalArticles/ALT/Reflection/

 

... in some method of some class ... 
Class c = getClass(); 
Constructor ctor = c.getConstructor(String.class); 
Object obj = ctor.newInstance("MyInstance"); 
 

Answer 5

puedo estar de acuerdo con la mayoría de las respuestas aquí -

todos llaman lo que hace de Java en términos de reducción a cero en una implementación del método en tiempo de ejecución en fecha tan tardía vinculante, pero en mi opinión no es correcto usar el término enlace tardío para lo que hace java.

La vinculación tardía no implica absolutamente ninguna comprobación de una llamada al método en tiempo de compilación y no hay errores de compilación si el método no existe.

Java, sin embargo, arrojará un error de compilación si el método no existe en algún lugar de la jerarquía de tipos del tipo que califica la llamada al método (siendo algo aproximado al describir el comportamiento aquí). Esto no es pura unión tradicional tardía. Lo que Java hace en una llamada a método no estático no privado no final normal se denominaría mejor como despacho dinámico.
Sin embargo, si utilizamos la reflexión en Java, entonces Java realiza el enlace final puro, ya que el compilador simplemente no puede verificar si el método llamado existe o no. Aquí se muestra un ejemplo:

class A 
{ 
    public void foo() 
    { 
     System.out.println("Foo from A"); 
    } 
} 

class B extends A 
{ 
    public void foo() 
    { 
     System.out.println("Foo from B"); 
    } 
} 
public class C 
{ 
    public static void main(String [] args) 
    { 
     A a=new A(); 
     B b=new B(); 
     A ref=null; 
     Class ref1 = null; 
     ref1 = b.getClass(); 
     ref.foo1();//will not compile because Java in this normal method 
     //call does some compile time checks for method and method 
     //signature existence. NOT late binding in its pure form. 
     try { 
      ref1.getMethod("foo1").invoke(null); //will throw a 
      //NoSuchMethodException at runtime, but compiles perfectly even 
      //though foo1 does not exist. This is pure late binding. 
     } catch (Exception e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
     } 
}