¿Por qué Java y C# difieren en Ups?

Question

1) ¿Por qué difieren los siguientes códigos?

C#:

class Base 
{ 
    public void foo() 
    { 
    System.Console.WriteLine("base"); 
    } 
} 

class Derived : Base 
{ 
    static void Main(string[] args) 
    { 
    Base b = new Base(); 
    b.foo(); 
    b = new Derived(); 
    b.foo(); 
    } 
    public new void foo() 
    { 
    System.Console.WriteLine("derived"); 
    } 
} 

Java:

class Base { 
    public void foo() { 
    System.out.println("Base"); 
    } 
} 

class Derived extends Base { 
    public void foo() { 
    System.out.println("Derived"); 
    } 

    public static void main(String []s) { 
    Base b = new Base(); 
    b.foo(); 
    b = new Derived(); 
    b.foo(); 
    } 
} 

2) Cuando se migra de un idioma a otro lo que son las cosas que necesitamos para asegurar una transición suave.

Answer 1

La razón es que en Java, los métodos son virtual de forma predeterminada. En C#, los métodos virtuales deben marcarse explícitamente como tales.
El siguiente código C# es equivalente al código Java - en cuenta el uso de virtual en la clase base y override en la clase derivada:

class Base 
{ 
    public virtual void foo() 
    { 
     System.Console.WriteLine("base"); 
    } 
} 

class Derived 
    : Base 
{ 
    static void Main(string[] args) 
    { 
     Base b = new Base(); 
     b.foo(); 
     b = new Derived(); 
     b.foo(); 

    } 

    public override void foo() 
    { 
     System.Console.WriteLine("derived"); 
    } 
} 

El código C# informados esconde el método foo en la clase Derived. Esto es algo que normalmente no desea hacer, porque causará problemas con la herencia.

Usando las clases que posteaste, el siguiente código de salida de cosas diferentes, aunque siempre es la misma instancia:

Base b = new Derived(); 
b.foo(); // writes "base" 
((Derived)b).foo(); // writes "derived" 

El código fijo que he proporcionado anteriormente es la salida "derivado" en ambos casos.

Answer 2

El código C# se compilará con advertencias, ya que allí se ocultan los métodos.

En Java, los métodos de clase son siempre virtuales, mientras que en C# no lo son, y debe marcarlos explícitamente como "virtuales".

En C#, que tendrá que hacer esto:

public class Base 
{ 
    public virtual void Foo() 
    { 
     Console.WriteLine ("Base"); 
    } 
} 

public class Derived : Base 
{ 
    public override void Foo() 
    { 
     Console.WriteLine ("Derived."); 
    } 
}