java 方法重载详解

区分重载方法

要是几个方法有相同的名字，Java如何才能知道你指的是哪一个呢？其实规则很简单：每个重载的方法都必须有一个独一无二的参数类型列表，包括参数类型顺序。注意：不考虑方法的返回类型。

例子：

package s1;

public class O {
	public static void main(String[] args) {
		O1 o1 = new O1();
		o1.test(3);
		o1.test(1, "gui");
	}
}

class O1 {
	void test(int i) {
		System.out.println("test: int");
	}
	void test(long l) {
		System.out.println("test: long");
	}
	void test(int i, String s) {
		System.out.println("test: i, String");
	}
	void test(String s, int i) {
		System.out.println("test: String, i");
	}
}

运行结果：

test: int
test: i, String

基本类型的重载

基本类型匹配方法的时候先找有没有和自己类型一样的，如果有则匹配该方法；如果没有，基本类型能从一个"较小"的基本类型自动提升至一个“较大”的基本类型；如果没有可转成“较大”的基本类型，则会尝试转换成基本类型所对应的对象类型(int会尝试转换成Integer)；如果不能转换成所对应的对象类型，则会尝试转换成Number对象；如果不能转换成Number对象，则会尝试转换成Object对象。此过程一旦涉及到重载，可能会造成一些混淆。

下面举个例子，关于从“较小”类型转换成“较大”的基本类型：

package s1;

public class P {
	void f1(char x) { System.out.print("f1 char    ");}
	void f1(byte x) { System.out.print("f1 byte    ");}
	void f1(short x) { System.out.print("f1 short    ");}
	void f1(int x) { System.out.print("f1 int    ");}
	void f1(long x) { System.out.print("f1 long    ");}
	void f1(float x) { System.out.print("f1 float    ");}
	void f1(double x) { System.out.print("f1 double    ");}
	
	void f2(byte x) { System.out.print("f2 byte    ");}
	void f2(short x) { System.out.print("f2 short    ");}
	void f2(int x) { System.out.print("f2 int    ");}
	void f2(long x) { System.out.print("f2 long    ");}
	void f2(float x) { System.out.print("f2 float    ");}
	void f2(double x) { System.out.print("f2 double    ");}
	
	void f3(short x) { System.out.print("f3 short    ");}
	void f3(int x) { System.out.print("f3 int    ");}
	void f3(long x) { System.out.print("f3 long    ");}
	void f3(float x) { System.out.print("f3 float    ");}
	void f3(double x) { System.out.print("f3 double    ");}
	
	void f4(int x) { System.out.print("f4 int    ");}
	void f4(long x) { System.out.print("f4 long    ");}
	void f4(float x) { System.out.print("f4 float    ");}
	void f4(double x) { System.out.print("f4 double    ");}
	
	void f5(long x) { System.out.print("f5 long    ");}
	void f5(float x) { System.out.print("f5 float    ");}
	void f5(double x) { System.out.print("f5 double    ");}
	
	void f6(float x) { System.out.print("f6 float    ");}
	void f6(double x) { System.out.print("f6 double    ");}
	
	void f7(double x) { System.out.print("f7 double    ");}
	
	void testChar() {
		char x = 'x';
		f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
	}
	void testByte() {
		byte x = 1;
		f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
	}
	void testShort() {
		short x = 1;
		f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
	}
	void testInt() {
		int x = 1;
		f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
	}
	void testLong() {
		long x = 1;
		f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
	}
	void testFloat() {
		float x = 1.0f;
		f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
	}
	void testDouble() {
		double x = 1.0;
		f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
	}
	
	public static void main(String[] args) {
		P p = new P();
		p.testChar();
		p.testByte();
		p.testShort();
		p.testInt();
		p.testLong();
		p.testFloat();
		p.testDouble();
	}
}

运行结果：

f1 char    f2 int    f3 int    f4 int    f5 long    f6 float    f7 double    
f1 byte    f2 byte    f3 short    f4 int    f5 long    f6 float    f7 double    
f1 short    f2 short    f3 short    f4 int    f5 long    f6 float    f7 double    
f1 int    f2 int    f3 int    f4 int    f5 long    f6 float    f7 double    
f1 long    f2 long    f3 long    f4 long    f5 long    f6 float    f7 double    
f1 float    f2 float    f3 float    f4 float    f5 float    f6 float    f7 double    
f1 double    f2 double    f3 double    f4 double    f5 double    f6 double    f7 double    

上面的例子可以发现：“较小”的基本类型如果找不到以该基本类型作为参数的方法，则会自动转变成“较大”的基本类型。char类型有所不同，如果找不到恰好接受char参数的方法，则会将char提升至int型。short类型也有所不同，如果找不到恰好接受short参数的方法，则会将short提升至int型。这里有一点需要注意：char和short都占16bits，但是char是无符号型的，short是有符号型。所以各自表示的数据范围不一样。

下面举个例子关于“较小”基本类型不仅可以转换成“较大”的基本类型，还可以转换成基本类型所对应的对象类型，甚至转换成Number或者Object。以int类型为例，转换顺序：int->long->float->double->Integer->Number->Object(这里需要意识到：Integer继承Number，Number继承Object)

package s1;

public class Q {
	void f1(int x) { System.out.print("f1 int    ");}
	void f1(long x) { System.out.print("f1 long    ");}
	void f1(Integer x) { System.out.print("f1 Integer    ");}
	void f1(Number x) { System.out.print("f1 Number    ");}
	void f1(Object x) { System.out.print("f1 Object    ");}
	
	void f2(long x) { System.out.print("f2 long    ");}
	void f2(Integer x) { System.out.print("f2 Integer    ");}
	void f2(Number x) { System.out.print("f2 Number    ");}
	void f2(Object x) { System.out.print("f2 Object    ");}
	
	void f3(Integer x) { System.out.print("f3 Integer    ");}
	void f3(Number x) { System.out.print("f3 Number    ");}
	void f3(Object x) { System.out.print("f3 Object    ");}
	
	void f4(Number x) { System.out.print("f4 Number    ");}
	void f4(Object x) { System.out.print("f4 Object    ");}
	
	void f5(Object x) { System.out.print("f5 Object    ");}
	
	void test1() {
		int i = 1;
		f1(i);f2(i);f3(i);f4(i);f5(i);System.out.println();
	}
	
	public static void main(String[] args) {
		Q q = new Q();
		q.test1();
	}
}

运行结果：

f1 int    f2 long    f3 Integer    f4 Number    f5 Object    

对象类型重载

对象类型匹配方法的时候先找有没有和自己类型一样的，如果有则匹配该方法；如果没有，则向上转变为最近一层父类，在匹配有没有和该父类类型一样的，如果有则匹配方法；如果没有，则再向上转变为最近一层父类，在匹配有没有和该父类类型一样的，如果有则匹配该方法；如果没有，继续向上转变为最近一层父类，再匹配；如此循环，直至转变为Object(所有类的父类)。

例子：

package s1;

public class T {
	void f1(Object t) {
		System.out.println("f1 Object");
	}
	void f1(T1 t) {
		System.out.println("f1 T1");
	}
	void f1(T2 t) {
		System.out.println("f1 T2");
	}
	void f1(T3 t) {
		System.out.println("f1 T3");
	}
	
	void f2(Object t) {
		System.out.println("f2 Object");
	}
	void f2(T1 t) {
		System.out.println("f2 T1");
	}
	void f2(T2 t) {
		System.out.println("f2 T2");
	}
	
	void f3(Object t) {
		System.out.println("f3 Object");
	}
	void f3(T1 t) {
		System.out.println("f3 T1");
	}
	
	void f4(Object t) {
		System.out.println("f4 Object");
	}
	
	public static void main(String[] args) {
		T3 t3 = new T3();
		T t = new T();
		t.f1(t3);
		t.f2(t3);
		t.f3(t3);
		t.f4(t3);
	}
}

class T1 {
	
}

class T2 extends T1 {
	
}

class T3 extends T2 {
	
}

运行结果：

f1 T3
f2 T2
f3 T1
f4 Object

基本类型其它

结合代码，讲解一下使用基本类型应该注意的地方(纯属个人总结，欢迎各位补充)

package s1;

public class R {
	void f1(char x) { System.out.print("f1 char    ");}
	void f1(byte x) { System.out.print("f1 byte    ");}
	void f1(short x) { System.out.print("f1 short    ");}
	void f1(int x) { System.out.print("f1 int    ");}
	void f1(long x) { System.out.print("f1 long    ");}
	void f1(float x) { System.out.print("f1 float    ");}
	void f1(double x) { System.out.print("f1 double    ");}
	
	public static void main(String[] args) {
		// 此处数值1会被转换成char类型
		char value1 = 1;
		// 编译错误：此处数值22222222已经超过char类型的最大值，被认为int类型
		char value2 = 22222222;
		// 编译错误：浮点数1.0后面没有跟类型符(f、d)，默认为double(d)类型
		float value3 = 1.0;
		double value4 = 1.0;
		
		R r = new R();
		// 此处没有指明数值4是什么类型，默认为int类型，因此调用f1(int x)
		r.f1(4);
		// 此处没有指明数值1.0是什么类型，默认为double类型，因此调用f1(double x)
		r.f1(1.0);
	}
}