重温 Thinking in Java - 2 Method Overloading

Distinguishing overloaded methods

If the methods have the same name, how can Java know which method you mean? There's a simple rule: Each overload method must take a unique list of argument types.

 

Overloading with primitives

 

public class PrimitiveOverloading {
	void f1(char x){
		System.out.println("f1(char) ");
	}
	
	void f1(byte x){
		System.out.println("f1(byte) ");
	}
	
	void f1(short x){
		System.out.println("f1(short) ");
	}
	
	void f1(int x){
		System.out.println("f1(int) ");
	}
	
	void f1(long x){
		System.out.println("f1(long) ");
	}
	
	void f1(float x){
		System.out.println("f1(float) ");
	}
	
	void f1(double x){
		System.out.println("f1(double) ");
	}
	
	//function f2
	void f2(byte x){
		System.out.println("f2(byte) ");
	}
	
	void f2(short x){
		System.out.println("f2(short) ");
	}
	
	void f2(int x){
		System.out.println("f2(int) ");
	}
	
	void f2(long x){
		System.out.println("f2(long) ");
	}
	
	void f2(float x){
		System.out.println("f2(float) ");
	}
	
	void f2(double x){
		System.out.println("f2(double) ");
	}
	
	//function f3
	void f3(short x){
		System.out.println("f3(short) ");
	}
	
	void f3(int x){
		System.out.println("f3(int) ");
	}
	
	void f3(long x){
		System.out.println("f3(long) ");
	}
	
	void f3(float x){
		System.out.println("f3(float) ");
	}
	
	void f3(double x){
		System.out.println("f3(double) ");
	}
	
	//function f4
	void f4(int x){
		System.out.println("f4(int) ");
	}
	
	void f4(long x){
		System.out.println("f4(long) ");
	}
	
	void f4(float x){
		System.out.println("f4(float) ");
	}
	
	void f4(double x){
		System.out.println("f4(double) ");
	}
	
	//function f5
	void f5(long x){
		System.out.println("f5(long) ");
	}
	
	void f5(float x){
		System.out.println("f5(float) ");
	}
	
	void f5(double x){
		System.out.println("f5(double) ");
	}
	
	//function f6
	void f6(float x){
		System.out.println("f6(float) ");
	}
	
	void f6(double x){
		System.out.println("f6(double) ");
	}
	
	//function f7
	void f7(double x){
		System.out.println("f7(double) ");
	}
	
	void testConstVal(){
		System.out.println("5: ");
		f1(5);//f1(int)
		f2(5);//f2(int)
		f3(5);//f3(int)
		f4(5);//f4(int)
		f5(5);//f5(long)
		f6(5);//f6(float)
		f7(5);//f7(double)
	}
	
	void testChar(){
		char x = 'x';
		System.out.println("char: ");
		f1(x);//f1(char)
		f2(x);//f2(int)
		f3(x);//f3(int)
		f4(x);//f4(int)
		f5(x);//f5(long)
		f6(x);//f6(float)
		f7(x);//f7(double)
		//char produces a slightly different effect, since if it doesn't find an exact char match,
		//it is promoted to int.
	}
	
	void testByte(){
		byte x = 0;
		System.out.println("byte: ");
		f1(x);//f1(byte)
		f2(x);//f2(byte)
		f3(x);//f3(short)
		f4(x);//f4(int)
		f5(x);//f5(long)
		f6(x);//f6(float)
		f7(x);//f7(double)
	}
	
	void testShort(){
		short x = 0;
		System.out.println("short: ");
		f1(x);//f1(short)
		f2(x);//f2(short)
		f3(x);//f3(short)
		f4(x);//f4(int)
		f5(x);//f5(long)
		f6(x);//f6(float)
		f7(x);//f7(double)
	}
	
	void testInt(){
		int x = 0;
		System.out.println("int: ");
		f1(x);//f1(int)
		f2(x);//f2(int)
		f3(x);//f3(int)
		f4(x);//f4(int)
		f5(x);//f5(long)
		f6(x);//f6(float)
		f7(x);//f7(double)
	}
	
	void testLong(){
		long x = 0;
		System.out.println("long: ");
		f1(x);//f1(long)
		f2(x);//f2(long)
		f3(x);//f3(long)
		f4(x);//f4(long)
		f5(x);//f5(long)
		f6(x);//f6(float)
		f7(x);//f7(double)
	}
	
	void testFloat(){
		float x = 0;
		System.out.println("float: ");
		f1(x);//f1(float)
		f2(x);//f2(float)
		f3(x);//f3(float)
		f4(x);//f4(float)
		f5(x);//f5(float)
		f6(x);//f6(float)
		f7(x);//f7(double)
	}
	
	void testDouble(){
		double x = 0;
		System.out.println("double: ");
		f1(x);//f1(double)
		f2(x);//f2(double)
		f3(x);//f3(double)
		f4(x);//f4(double)
		f5(x);//f5(double)
		f6(x);//f6(double)
		f7(x);//f7(double)
	}
	
	public static void main(String[] args){
		PrimitiveOverloading p = new PrimitiveOverloading();
		p.testConstVal();
		p.testChar();
		p.testByte();
		p.testShort();
		p.testInt();
		p.testLong();
		p.testFloat();
		p.testDouble();
	}
}

 

If you have a data type that is smaller than the argument in the method, that data type is promoted. char produces a slightly different effect, since if it doesn't find an exact char match, it is promoted to int.

 

What happens if your argument is bigger than the argument expected by the overloaded method?

public class Demotion {

	void f1(char x){
		System.out.println("f1(char)");
	}
	
	void f1(byte x){
		System.out.println("f1(byte)");
	}
	
	void f1(short x){
		System.out.println("f1(short)");
	}
	
	void f1(int x){
		System.out.println("f1(int)");
	}
	
	void f1(long x){
		System.out.println("f1(long)");
	}
	
	void f1(float x){
		System.out.println("f1(float)");
	}
	
	void f1(double x){
		System.out.println("f1(double)");
	}
	
	//function f2
	void f2(char x){
		System.out.println("f2(char)");
	}
	
	void f2(byte x){
		System.out.println("f2(byte)");
	}
	
	void f2(short x){
		System.out.println("f2(short)");
	}
	
	void f2(int x){
		System.out.println("f2(int)");
	}
	
	void f2(long x){
		System.out.println("f2(long)");
	}
	
	void f2(float x){
		System.out.println("f2(float)");
	}
	
	//function f3
	void f3(char x){
		System.out.println("f3(char)");
	}
	
	void f3(byte x){
		System.out.println("f3(byte)");
	}
	
	void f3(short x){
		System.out.println("f3(short)");
	}
	
	void f3(int x){
		System.out.println("f3(int)");
	}
	
	void f3(long x){
		System.out.println("f3(long)");
	}
	
	//function f4
	void f4(char x){
		System.out.println("f4(char)");
	}
	
	void f4(byte x){
		System.out.println("f4(byte)");
	}
	
	void f4(short x){
		System.out.println("f4(short)");
	}
	
	void f4(int x){
		System.out.println("f4(int)");
	}
	
	//function f5
	void f5(char x){
		System.out.println("f5(char)");
	}
	
	void f5(byte x){
		System.out.println("f5(byte)");
	}
	
	void f5(short x){
		System.out.println("f5(short)");
	}
	
	//function f6
	void f6(char x){
		System.out.println("f6(char)");
	}
	
	void f6(byte x){
		System.out.println("f6(byte)");
	}
	
	//function f7
	void f7(char x){
		System.out.println("f7(char)");
	}
	
	void testDouble(){
		double x = 0;
		System.out.println("double argument:");
		f1(x);//f1(double)
		f2((float)x);//f2(float)
		f3((long)x);//f3(long)
		f4((int)x);//f4(int)
		f5((short)x);//f5(short)
		f6((byte)x);//f6(byte)
		f7((char)x);//f7(char)
	}
	
	public static void main(String[] args){
		Demotion p = new Demotion();
		p.testDouble();
	}
}

 

If your argument is wider, then you must perform a narrowing conversion with a cast.

 

Overloading on return values

We cannot use return value types to distinguish overloaded methods, so we cannot do it.

 

<EOA>