CODEWITHSUNDEEP
c#javagenericsoverloading
Sergey Savenko
Sergey Savenko

Reputation: 666

Call of overloaded method from generic method issue

I've run into interesting thing (works same in both Java and C#). Java code:

public class TestStuff {

    public static void main(String[] args) {
        Printer p = new PrinterImpl();
        p.genericPrint(new B());    
    }

}

class PrinterImpl implements Printer {

    void print(A a) {
        System.out.println("a");
    }

    void print(B b) {
        System.out.println("b");
    }

    @Override
    public <T extends A> void genericPrint(T b) {
        print(b);
    }

}

interface Printer {
    public <T extends A> void genericPrint(T a);
}

class A {

}

class B extends A{

}

C# code:

namespace TestStuff
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var printer = new Printer();
            printer.GenericPrint(new B());
        }

    }

    public class Printer
    {

        public void Print(A a)
        {
            Console.WriteLine("a");
        }

        public void Print(B b)
        {
            Console.WriteLine("b");
        }

        public void GenericPrint<T>(T a) where T : A
        {
            Print(a);
        }

    }

    public class B : A
    {

    }

    public class A
    {

    }

}

When I wrote something like this I expected to see "b" printed in both cases. But, as you can see, it is "a" what is printed.

I've read C# language specification and it says overloaded method is selected at compile-time. It explains why it works that way.

However, I had no time to check it out in Java language specification.

Could somebody please give a more detailed explanation of what is happening and why? And how could I achieve what I wanted?

Thanks in advance!

Upvotes: 4

Views: 259

Answers (3)

shams
shams

Reputation: 3508

The key is to understand that generics are only available at compile time in java. It is just syntax sugar that the compiler uses while compiling, but throws away while generating the class files.

As such, the code:

   public <T extends A> void genericPrint(T b) {
      print(b);
   }

is compiled into:

   public void genericPrint(A b) {
      print(b);
   }

Since the argument to print is of type A, the overloaded version print(A a) is the one resolved. I'd suggest using polymorphic calls on instances of A or the Visitor pattern to callback into PrinterImpl for your use case.

Something like:

interface Visitor {
   void visit(A a);

   void visit(B b);
}

class PrinterImpl implements Printer, Visitor {

   void print(A a) {
      System.out.println("a");
   }

   void print(B b) {
      System.out.println("b");
   }

   public <T extends A> void genericPrint(T b) {
      b.accept(this);
   }

   public void visit(A a) {
      print(a);
   }

   public void visit(B b) {
      print(b);
   }
}

interface Printer {
   public <T extends A> void genericPrint(T a);
}

class A {
   public void accept(Visitor v) {
      v.visit(this);
   }
}

class B extends A {
   public void accept(Visitor v) {
      v.visit(this);
   }
}

Upvotes: 5

Anand
Anand

Reputation: 14955

Its true that overloaded methods are selected at compile time and its true for java also(dynamic method dispatch). However Generics works a little differently. Your method GenericPrinter can only work Types A or its derivative. Its a constraint on that method. Suppose in your GenricPrinter class you have invoked a method thats defined in A. 

public class A
{
    void DoSomethingA()
    {
    }    
}
.
.
.
public void GenericPrint<T>(T a) where T : A
{
    //constraint makes sure this is always valid
    a.DoSomethingA();
    Print(a);
}

So this constraint would make sure that only A or its sub classes, that contains the above method would only be allowed. Although you pass in an instance of A's subclass but due to constaint, GenericPrinter would treat the subclass as A. Just remove the constraint part (T:A) and B would be printed as you expect.

Upvotes: 1

Matthias
Matthias

Reputation: 16209

There is no runtime check of which type a is in your GenericPrint method. The only thing you enforce with the where T : A part, is that you can call Print.

Btw, apart from that generic method: If you want a to be printed, although it is an instance of B, then you have to declare that variable as A obj = new B().

Upvotes: 0

Related Questions