Does overidden method with var-args parameters break polymorphism?

[Richard Hayward]

A Dog is an Animal, so I'm expecting that anything an Animal can do, a Dog should be able to do.

import static java.lang.System.out;                                                                                                                  
                                                                                                                                                     
class BreakPolymorphism {                                                                                                                            
  static class Animal {                                                                                                                              
    void makeNoise(String... noises){                                                                                                                
      for(String string:noises) out.print(string);                                                                                            
      out.println(" Animal makeNoise");                                                                                                              
    }                                                                                                                                                
  }                                                                                                                                                  
  static class Dog extends Animal {                                                                                                                  
    @Override          //confirm this is indeed an override                                                                                          
    void makeNoise(String[] noises){                                                                                                                 
      for(String string:noises) out.print(string);                                                                                            
      out.println(" Dog makeNoise");                                                                                                                 
    }                                                                                                                                                
  }                                                                                                                                                  
  public static void main(String[] args) {                                                                                                           
    Animal animal = new Animal();                                                                                                                    
    animal.makeNoise(new String[] {"A", "B"});     //AB Animal makeNoise                                                                             
    animal.makeNoise("C", "D");                    //CD Animal makeNoise                                                                             
    Dog dog = new Dog();                                                                                                                             
    dog.makeNoise(new String[] {"K", "L"});        //KL Dog makeNoise                                                                                
    //dog.makeNoise("M", "N");                     //error: method makeNoise in class Dog cannot be applied to given types;                          
    ((Animal) dog).makeNoise("O", "P");            //OP Dog makeNoise                                                                                
  }                                                                                                                                                  
} 

But here, that seems to not be the case. Although I can call animal.makeNoise("C", "D"), that same method call on dog won't compile.

Does that not break polymorphism?

[Carey Brown]

No, that is not an override. The compiler under Eclipse even issues a warning about it.

[Stephan van Hulst]

It does not break polymorphism.

Polymorphism allows you to swap the actual type of an object that a variable refers to without changing the validity of the program.

You didn't just change the type of the object that the variable refers to, you also changed the type of the variable itself. That is not covered by polymorphism.

[Richard Hayward]

Carey Brown wrote:No, that is not an override

ok, I thought @Override at least gave a compile time message if the annotated method wasn't overriding something.

For example

import static java.lang.System.out;                                                                                                                                                             
                                                                                                                                                                                                
public class OverrideTest {                                                                                                                                                                     
                                                                                                                                                                                                
  private static class Animal {                                                                                                                                                                 
    public void eat() {                                                                                                                                                                         
      out.println("Animal eats");                                                                                                                                                               
    }                                                                                                                                                                                           
  }                                                                                                                                                                                             
                                                                                                                                                                                                
  private static class Dog extends Animal {                                                                                                                                                     
    @Override                                                                                                                                                                                   
    public void eat() {                                                                                                                                                                         
      out.println("Dog eats");                                                                                                                                                                  
    }                                                                                                                                                                                           
    @Override   //error: method does not override or implement a method from a supertype                                                                                                        
    public void bark(){                                                                                                                                                                         
      out.println("woof!");                                                                                                                                                                     
    }                                                                                                                                                                                           
  }                                                                                                                                                                                             
                                                                                                                                                                                                
  public static void main(String[] args) {                                                                                                                                                      
    new Dog().bark();                                                                                                                                                                           
  }                                                                                                                                                                                             
                                                                                                                                                                                                
}    

Line 12 is ok because Dog.eat() does indeed override Animal.eat()

but javac gives an error at line 16 because Dog.bark() isn't overriding anything.

$ javac OverrideTest.java OverrideTest.java:16: error: method does not override or implement a method from a supertype    @Override   //error: method does not override or implement a method from a supertype    ^ 1 error

[Mike Simmons]

Richard - you are correct, that (your original code, before you edited the post and added more) is a legal override.  @Override would actually prevent compilation if it were not a valid override.  

I don't know what warning Carey sees in Eclipse... maybe some warning that there's no good reason to do this, since it limits your options when using a Dog reference.  But it is legal.  It doesn't break polymorphism though, in the sense that you can still use the method exactly the same as before, if you use a reference declared as Animal.  So it satisfies the substitution principle just fine.

    Animal dog = new Dog();
    dog.makeNoise(new String[] {"K", "L"});        //KL Dog makeNoise                                                                                
    dog.makeNoise("M", "N");                     // MN Dog makeNoise
    ((Animal) dog).makeNoise("O", "P");            //OP Dog makeNoise

[Carey Brown]

Warning: "Varargs methods should only override other varargs methods"

[Richard Hayward]

Stephan van Hulst wrote:
Polymorphism allows you to swap the actual type of an object that a variable refers to without changing the validity of the program.

So maybe I have a mistaken idea of what polymorphism means. Here, I 'swap the actual type of an object that a variable refers to'.

import static java.lang.System.out;                                                                                                                  
                                                                                                                                                     
class BreakPolymorphism2 {                                                                                                                           
  static class Animal {                                                                                                                              
    void makeNoise(String... noises){                                                                                                                
      for(String string:noises) out.print(string);                                                                                                   
      out.println(" Animal makeNoise");                                                                                                              
    }                                                                                                                                                
  }                                                                                                                                                  
  static class Dog extends Animal {                                                                                                                  
    @Override          //confirm this is indeed an override                                                                                          
    void makeNoise(String[] noises){                                                                                                                 
      for(String string:noises) out.print(string);                                                                                                   
      out.println(" Dog makeNoise");                                                                                                                 
    }                                                                                                                                                
  }                                                                                                                                                  
  public static void main(String[] args) {                                                                                                                                                                                                                                                                                                                                                        
//  Animal animal = new Animal();                                                                                                                    
    Animal animal = new Dog();                                                                                                                       
    animal.makeNoise(new String[] {"A", "B"});     //AB Dog makeNoise                                                                                
    animal.makeNoise("C", "D");                    //CD Dog makeNoise                                                                                
  }                                                                                                                                                  
}   

At line 18, instead of using a new Animal(), I use a new Dog() and the code still works.

It still seems weird though. By referencing the Dog via an Animal variable, I can invoke the Dog's makeNoise method with arguments that it shouldn't accept.
The compiler wouldn't allow:

Dog dog = new Dog();                                                                                                                             
dog.makeNoise("A", "B"); 

I've noticed a similar thing with interfaces. An interface method with an int... parameter can be implemented by a method with an int[] parameter.

For example

public class VarArgsInterface{                                                                                                                       
  interface CanAdd {                                                                                                                                 
    void add(int... ia);                                                                                                                             
  }                                                                                                                                                  
  static class Adder implements CanAdd{                                                                                                              
    public void add(int[] ia){                                                                                                                       
      int sum=0;                                                                                                                                     
      for(int i:ia){sum += i;}                                                                                                                       
      System.out.printf("sum=%d\n", sum);                                                                                                            
    };                                                                                                                                               
  }                                                                                                                                                  
  public static void main(String[] args){                                                                                                            
    //use the interface                                                                                                                              
    CanAdd canAdd = new Adder();                                                                                                                     
    canAdd.add(new int[]{4, 5, 6});        //15                                                                                                      
    //The following works, even though the implementing method couldn't accept these arguments                                                       
    canAdd.add(100, 200, 300);             //600                                                                                                     
  }                                                                                                                                                  
}

$ java VarArgsInterface sum=15 sum=600

[Paul Clapham]

Well, this is what Cary's compiler warning message is trying to say. The fact is that void makeNoise(String... noises) and void makeNoise(String[] noises) mean exactly the same thing and can be used interchangeably. So using both of them doesn't break polymorphism, it's just confusing.

[Mike Simmons]

Paul Clapham wrote:The fact is that void makeNoise(String... noises) and void makeNoise(String[] noises) mean exactly the same thing and can be used interchangeably.

Except when they can't, as shown in the first post in this thread.  When using a Dog reference, you can't call dog.makeNoise("M", "N"); you have to call dog.makeNoise(new String[] {"M","N"}) or ((Animal) dog).makeNoise("M","N").  When using an Animal reference, this problem goes away. I  don't think that breaks polymorphism, but it's not exactly interchangeable either.

[Piet Souris]

What I do not get is that

dog.makeNoise("M", "N");

does not compile, but

((Animal) dog).makeNoise("O", "P"); 

runs fine.

(Animal) dog

is still an instance of Dog, and I thought that at runtime the method of the dog-version would have been called, so it should at least not run. But it does. Perhaps it has been explained above and I missed it, but what am I missing?

[Stephan van Hulst]

You need to completely ignore the runtime type. The compiler only considers the type of expression that you're calling the method on. The compiler doesn't know what the runtime type of the expression is.

In dog.makeNoise("M", "N"), the compiler checks only the Dog class. Dog does not have a method that accepts two strings. It doesn't inherit makeNoise(string...) because it overrides it, and the overridden version doesn't have a varargs parameter.

In ((Animal) dog).makeNoise("O", "P"), the compiler checks only the Animal class. It doesn't know that the expression actually refers to a Dog. Animal has a method that accepts two string arguments by virtue of the varargs parameter.

Polymorphism doesn't come into play at all in deciding what method signature belongs to a specific method invocation, and it doesn't come into play at all in deciding what the correct syntax is to call a method with that signature. Overload resolution is done statically, at compile time.

[Mike Simmons]

There is something a little backward going on there, because when we override, we're not allowed to make a method more private, or change to an incompatible return type, or throw new checked exceptions.  But we are allowed to take away the vararg calling syntax, at least when using a reference of the new type.  I suspect that if varargs had been part of the language from the beginning, they might not have allowed that, for consistency.  But I think they might have chosen to allow it here, in order to make it easier for users to migrate to the  then-new feature of varargs.  This way, you can change the declaration of a method in a base class, moving from an array type argument to a vararg, without automatically breaking any subclasses that have not also been modified the same way.  The array and the vararg are equivalent, as far as overrides are concerned.  But the compiler still respects the behavior according to the declared type of a reference.  It's a weird compromise, but i think it made it easier to adopt the new feature.