Java方法重载_编写程序,用方法重载实现相加两个int,两个double,一个double和一个int的方法。

如果一个类中有多个具有相同名称但参数不同的方法，则称为方法重载。如果只需要执行一个操作，具有相同的方法名称将增加程序的可读性。
假设必须执行给定数值的添加操作(求和)，但是参数的数量不固定，如果为两个参数编写add1(int，int)方法，为三个参数编写add2(int，int，int)方法.可以用重载：
两个参数相加：

int add(int num1，int num2){
	return num1 + num2;
}
1
2
3

三个参数相加

int add(int num1,int num2 ,int num3){
	return num1 + num2 + num3;
}
1
2
3

无数个参数相加

static int add(int... args) {
		int result = 0;
		for(int i = 0;i < args.length;i ++) {
			result += args[i];
		}
		return result;
}
1
2
3
4
5
6
7

eg:
public class VariableLengthParameter {

public static void main(String[] args) {
	System.out.println(add(465465,465465,31,36465,41,31,465,41,3,1654,654,1,32,165,465,4,3213,246,54,65,465454654));
	System.out.println(add(1,2));
	System.out.println(add(1,2,3));
}

static int add(int... nums) {
	int result = 0;
	for(int i = 0;i < nums.length;i ++) {
		result += nums[i];
	}
	return result;
}

static int add(int num1,int num2) {
	return num1 + num2;
}

static int add(int num1,int num2,int num3) {
	return num1 +num2 + num3;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

}
输出结果

466429214
3
6
1
2
3

q) 为什么要方法重载
a) 方法重载可以提高可读性。如果没有重载，两个参数的add(int num1,int num2)存在后，就不能存在三个参数的add(int num1,int num2,int num3),或者说三个参数的add方法必须改名，也就是add1(int num1,int num2,int num3);而重载可以解决以上问题。

重载的不同方法

两种不同方式

通过改变参数的数量

三个方法,参数数目不同构成重载

add(int num1,int num2){}
add(int num1,int num2,int num3){}
add(int... args){}
1
2
3

通过改变参数类型

class Add{
	int add(int num1,int num2){
		return num1 + num2;
	}

	double add(double num1,double num2){
		return num1 + num2;
	}
}
1
2
3
4
5
6
7
8
9

两个参数add参数类型不同，可以称为重载

add(int num1,int num2){}
add( num1,double num2){}
1
2

重载与返回类型无关

Java通过返回类型来实现重载，不太现实

class Add(){
	static int add(int num1,int num2){
		return num1 + num2;
	}
	static double add(int num1,int num2){
		return num1 + num2;
	}

	public static void main(String args){
		add(1,2);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

以上函数当点用add的时候，该找哪个函数呢？是int add(){} 还是double add(){}?所以根据返回数据类型来重载，是很容易造成混淆，因为不知道调用哪个返回类型的add方法。

在这里，编译时错误优于运行时错误。 所以，如果你声明相同的方法具有相同的参数，java编译器就不知道执行哪个方法，造成不确定的错误。

Q)Java main() 方法可以重载吗？
A)main()方法也是普通方法，可以重载，只不过虚拟机只调用带字符串公共类型的方法，public static void main（String[] args）{},但是你可以自定义你用的main()方法，main（int a）;main(String a);

class TestOverloading{  
    public static void main(String[] args){System.out.println("main with String[]");}  
    public static void main(String args){System.out.println("main with String");}  
    public static void main(){System.out.println("main without args");}  
}
1
2
3
4
5

输出结果

main with String[]
1

虚拟机只执行一个main方法。
如果你在虚拟机执行的main方法中调用其他方法

class TestOverloading{  
    public static void main(String[] args){System.out.println("main with String[]");main("234");main()}  
    public static void main(String args){System.out.println("main with String");}  
    public static void main(){System.out.println("main without args");}  
}
1
2
3
4
5

输出结果

main with String[]；
main with String；
main without args；
1
2
3

方法重载和类型提升

如果没有找到匹配的数据类型，那么会隐式地将一个类型提升到另一个类型。 让我们通过下面的图示来理解这个概念：

其中8字节的long可以自动整型提升为4字节的float，且4字节的float的最大值大于long的最大值，float的最小值小于long的最小值；

public class LongToFloat {

	public static Logger log = Logger.getLogger(LongToFloat.class.getName());
	
	public static void main(String[] args) {
		final long MAX_VALUE_TO_LONG = Long.MAX_VALUE;
		final long MIN_VALUE_TO_LONG = Long.MIN_VALUE;
		final float MAX_VALUE_TO_FLOAT = Float.MAX_VALUE;
		final float MIN_VALUE_TO_FLOAT = Float.MIN_VALUE;                       //正数的最小值
		float NEGATIVE_MIN_VALUE_TO_FLOAT = -1 * MAX_VALUE_TO_FLOAT - 1.01E31f;
		log.info("\n" + MAX_VALUE_TO_FLOAT
				+ "\n" + MIN_VALUE_TO_FLOAT + "(float正数的最小值)"
				+ "\n" + MAX_VALUE_TO_LONG
				+ "\n" + MIN_VALUE_TO_LONG
				+ "\nfloat最大的数 - long最大的数：" + (MAX_VALUE_TO_FLOAT - MAX_VALUE_TO_LONG)
				+ "\n" + NEGATIVE_MIN_VALUE_TO_FLOAT);
		float longToFloatMax = MAX_VALUE_TO_LONG;                                                   //long最大值可以自动整型提升转换成float
		log.info("\n把long最大值转换成float"
				+ "\n\t转换前:" 
				+ MAX_VALUE_TO_LONG
				+ "\n\t转换后"
				+ longToFloatMax);
//		long floatToLongMax = MAX_VALUE_TO_FLOAT;      编译报错，float不能转换long            
//		long floatToLongMin = MIN_VALUE_TO_FLOAT;      编译报错，float不能转换long
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

输出结果为

3.4028235E38                                                                        //float正数最大值
1.4E-45(float正数的最小值)                                                    //float正数最小值
9223372036854775807                                                         //long最大值
-9223372036854775808                                                       //long最小值
float最大的数 - long最大的数：3.4028235E38                     //float最大值比long最大值大的多
-3.4028235E38                                                                      //大约计算后的float的最小值

把long最大值转换成float
	转换前:9223372036854775807
	转换后9.223372E18                                                   //long可以不丢失原因精确转换成float;
1
2
3
4
5
6
7
8
9
10

具体原因请移步float和double类型的范围和精度。
关于整型提升的三个案例
eg1:

class OverloadingCalculation1 {
    void sum(int a, long b) {
        System.out.println(a + b);
    }

    void sum(int a, int b, int c) {
        System.out.println(a + b + c);
    }

    public static void main(String args[]) {
        OverloadingCalculation1 obj = new OverloadingCalculation1();
        obj.sum(20, 20);                                                // now second int literal will be promoted to long
        obj.sum(20, 20, 20);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出结果

40
60
1
2

这里的方法sum(20,20)，第一给参数是int,第二个是long,这里吧默认的参数20自动整形提升为20L。
第二个例子

lass OverloadingCalculation2 {
    void sum(int a, int b) {
        System.out.println("int arg method invoked");
    }

	void sum(long a, long b) {
    	System.out.println("long arg method invoked");
 }

	public static void main(String args[]) {
   	 	OverloadingCalculation2 obj = new OverloadingCalculation2();
   	 	obj.sum(20, 20);                                                     // now int arg sum() method gets invoked
 }
1
2
3
4
5
6
7
8
9
10
11
12
13

}

输出

int arg method invoked
1

这里因为能找到与自己相匹配的类型所以不会整形提升
eg3:

class OverloadingCalculation3 {
    void sum(int a, long b) {
        System.out.println("a method invoked");
    }
    void sum(long a, int b) {
        System.out.println("b method invoked");
    }
    public static void main(String args[]) {
        OverloadingCalculation3 obj = new OverloadingCalculation3();
        obj.sum(20, 20);                                                                            // now ambiguity
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

这里会报编译错误，sum(20,20)无论执行那个方法都需要整形提升，但同时整型提升后，两个方法都可以执行，所以产生混淆。

总之，当你传入参数后，虚拟机不知道该执行哪个方法，则会在编译的时候就会报错。
Java中double不会整形提升，因为在8种基本变量类型中，它是老大。