¿Qué es el método virtual llamando en java?

Question

He visto el siguiente párrafo en alguna prueba de informática y espero poder obtener aquí una buena explicación de lo que significa porque lo busqué en Google durante una hora y no puedo encontrar nada ..

"Cuando decir que el lenguaje Java tiene método virtual llamando a nos referimos a que en las aplicaciones Java el método ejecutado está determinado por el tipo de objeto en tiempo de ejecución "

¿Qué significa? ¿Alguien puede explicarlo mejor?

Answer 1

El autor de estas líneas utilizaron el C++ terminología de virtual.

Una mejor terminología es dynamic binding/dynamic dispatch.

Eso significa que el objeto type dinámico es "elegir" qué método se invocará, y no el tipo estático.

Por ejemplo: [pseudo código]:

class A { 
    public void foo() { } 
} 
class B extends A { 
    public void foo() { } 
} 

cuando se invoca:

A obj = new B(); 
obj.foo(); 

B.foo() se invocará, y NO A.foo(), ya que el tipo dinámico de obj es B.

Answer 2

queremos decir que en las aplicaciones Java el método ejecutado es determinado por el tipo de objeto en tiempo de ejecución

interface Animal{ 
    public void eat(); 
} 


class Person implements Animal{ 
    public void eat(){ System.out.println("Eating Food");} 
} 



class Eagle implements Animal{ 
    public void eat(){ System.out.println("Eating Snake");} 
} 

en principal

Animal animal = new Person(); 
animal.eat(); //it will print eating food 
animal = new Eagle(); 
animal.eat(); //it will print eating snake 

Answer 3

Supongamos que tiene una clase Fruit, con dos subclases Orange y Banana. Y supongamos que Fruit tiene un método String getColor().

Orange puede anular el método getColor() para devolver "naranja". Lo mismo para Banana, que puede hacer que vuelva "amarillo".

Cuando algún método utiliza un objeto de tipo Fruta, y llama al método getColor(), el método que se llamará es Banana.getColor() si el tipo de Fruta es, de hecho, Plátano.

private void printColor(Fruit f) { 
    System.out.println(f.getColor()); 
} 

... 

Fruit fruit1 = new Banana(); 
Fruit fruit2 = new Orange(); 
printColor(fruit1); // prints yellow 
printColor(fruit2); // prints orange  

Answer 4

Employee.java

public class Employee 
{ 
    private String name; 
    private String address; 
    private int number; 
    public Employee(String name, String address, int number) 
    { 
     System.out.println("Constructing an Employee"); 
     this.name = name; 
     this.address = address; 
     this.number = number; 
    } 
    public void mailCheck() 
    { 
     System.out.println("Mailing a check to " + this.name 
     + " " + this.address); 
    } 
} 

VirtualMethod.java

class Salary extends Employee 
{ 
    private double salary; //Annual salary 
    public Salary(String name, String address, int number, double 
     salary) 
    { 
     super(name, address, number); 
     this.salary=salary; 
    } 
    public void mailCheck() 
    { 
     System.out.println("Within mailCheck of Salary class "); 
     System.out.println("Mailing check to " 
     + " with salary " + salary); 
    } 

} 

public class VirtualMethod 
{ 
    public static void main(String [] args) 
    { 
     Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00); 
     Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00); 
     System.out.println("Call mailCheck using Salary reference --"); 
     s.mailCheck(); 
     System.out.println("\n Call mailCheck using Employee reference--"); 
     e.mailCheck(); 
    } 
} 

salida

Constructing an Employee 
Constructing an Employee 
Call mailCheck using Salary reference -- 
Within mailCheck of Salary class 
Mailing check to with salary 3600.0 

Call mailCheck using Employee reference-- 
Within mailCheck of Salary class 
Mailing check to with salary 2400.0 

Explicación

aquí, tenemos una instancia dos Salary objetos. Uno que usa una referencia Salarys, y el otro que usa una referencia Employeee.

Invocando s.mailCheck() el compilador ve mailCheck() en la clase Salary en tiempo de compilación, y la JVM invoca mailCheck() en la clase Salary en tiempo de ejecución.

Invocar mailCheck() en e es bastante diferente porque e es una referencia Employee. Cuando el compilador ve e.mailCheck(), el compilador ve el método mailCheck() en la clase Employee.

Aquí, en tiempo de compilación, el compilador usó mailCheck() en Employee para validar esta afirmación. Sin embargo, en tiempo de ejecución, la JVM invoca mailCheck() en la clase Salary.