overloading

i'm trying to understand java behaviour. Using this interfaces : public interface IA {} public interface IB extends IA {} public class myClass implements IB {} I'm overloading a method like this : public void method(IA a); public void method(IB b); When calling method with the following object : IA a = new myClass(); method(a); Why does java use : public void method(IA a); instead of public void method(IB b); ? Thanks Because the compiler only knows that a is an instance of IA . Overloads are determined at compile time based on the compile-time types of the expressions involved, and the

Given the following overloaded methods: public string Test(long item) { return "Test with a long was called!"; } public string Test(int item) { return "Test with an int was called!"; } public string Test(object item) { return "Test with an object was called!"; } When I call Test() , passing a short , like this: short shortValue = 7; var result = Test(shortValue); Why is the value result equal to "Test with an int was called!" , instead of "Test with an object was called!" ? Why is the value result equal to "Test with an int was called!", instead of "Test with an object was called!"? The

When overloading a templated function, how should the compiler chose which version of the function to call if it has the option to either: Call a templated version of the function (such as func<T>(foo) ). Call an overloaded version of the function which is not itself templated but where the type of the parameter being passed to the function inherits from the type specified in the overloaded function template. Consider the following C++ code: #include <stdio.h> struct Parent {}; struct Child : public Parent {}; template <typename T> void func(T) { printf("func(T)\n"); } void func(Parent) {

public void add(long... x){} public void add(Integer... x){} add(2); this produces error...why overlaoding is not performed with both widening and boxing? but overloading without vararg works fine public void add(long x){} public void add(Integer x){} add(2); here add(long x) will be executed that is widening beats boxing...why not same concept with var arguments axtavt Java compiler performs three attempts to choose an appropriate method overload ( JLS §15.12.2.1 ): Phase 1: Identify Matching Arity Methods Applicable by Subtyping (possible boxing conversions and methods with varargs are

The final committee draft of the upcoming C++0x standard says: Every C header, each of which has a name of the form name.h, behaves as if each name placed in the standard library namespace by the corresponding cname header is placed within the global namespace scope. It is unspecified whether these names are first declared or defined within namespace scope (3.3.6) of the namespace std and are then injected into the global namespace scope by explicit using-declarations (7.3.3). Earlier C++ standards read similarly. My question is, when the C++ header #include<cname> uses overloaded functions,

Let's say we have this class A: class A { public: int a; A(int b) { a = b; } }; I would like to create a + overload such that I could use it like this A a(1),b(2),c(3),&d; d = a + b + c; without modifying the content of each object. The next logical thing would be allocating a new chunk of memory each time like this: A &operator+ (const A &b) { A *c = new A(a+b.a); return *c; } But this would create a new problem: intermediate results are lost, causing memory leaks. I could have easily solved this problem by making a static function that takes three A object references and stores the sum of