1、方法重载机制
/*
方法重载机制?
1、以下程序先不使用方法重载机制,分析程序的缺点???
以下程序没有语法错误,运行也是正常的,你就分析一下代码风格存在什么缺点!
sumInt、sumLong、sumDouble不是功能“相同”,是功能“相似”。
三个方法功能不同,但是相似,分别起了三个不同的名字,有什么缺点?
缺点包括两个:
第一个:代码不美观(不好看、不整齐)。【这是次要的】
第二个:程序员需要记忆更多的方法名称,程序员比较累。
*/
public class OverloadTest01{
//主方法
public static void main(String[] args){
int x = sumInt(10, 20);
System.out.println(x);
long y = sumLong(10L, 20L);
System.out.println(y);
double z = sumDouble(10.0, 20.0);
System.out.println(z);
}
// 定义一个计算int类型数据的求和方法
public static int sumInt(int a, int b){
return a + b;
}
// 定义一个计算long类型数据的求和方法
public static long sumLong(long a, long b){
return a + b;
}
// 定义一个计算double类型数据的求和方法
public static double sumDouble(double a, double b){
return a + b;
}
}
/*
使用方法重载机制。解决之前的两个缺点。
优点1:代码整齐美观。
优点2:“功能相似”的,可以让“方法名相同”,更易于以后的代码编写。
在java语言中,是怎么进行方法区分的呢?
首先java编译器会通过方法名进行区分。
但是在java语言中允许方法名相同的情况出现。
如果方法名相同的情况下,编译器会通过方法的参数类型进行方法的区分。
*/
public class OverloadTest02{
public static void main(String[] args){
// 对于程序员来说,只需要记忆一个方法名即可。
System.out.println(sum(10, 20));
System.out.println(sum(10L, 20L));
System.out.println(sum(10.0, 20.0));
}
// 定义一个计算int类型数据的求和方法
public static int sum(int a, int b){
System.out.println("int求和");
return a + b;
}
// 定义一个计算long类型数据的求和方法
public static long sum(long a, long b){
System.out.println("long求和");
return a + b;
}
// 定义一个计算double类型数据的求和方法
public static double sum(double a, double b){
System.out.println("double求和");
return a + b;
}
}
/*
方法重载(overload):
什么时候需要考虑使用方法重载?
在同一个类当中,如果“功能1”和“功能2”它们的功能是相似的,
那么可以考虑将它们的方法名一致,这样代码既美观,又便于
后期的代码编写(容易记忆,方便使用)。
注意:方法重载overload不能随便使用,如果两个功能压根不相干,
不相似,根本没关系,此时两个方法使用重载机制的话,会导致
编码更麻烦。无法进行方法功能的区分。
什么时候代码会发生方法重载?
条件1:在同一个类当中
条件2:方法名相同
条件3:参数列表不同
参数的个数不同算不同
参数的类型不同算不同
参数的顺序不同算不同
只要同时满足以上3个条件,那么我们可以认定方法和方法之间发生了
重载机制。
注意:
不管代码怎么写,最终一定能让java编译器很好的区分开这两个方法。
方法重载和方法的“返回值类型”无关。
方法重载和方法的“修饰符列表”无关。
*/
public class OverloadTest03{
public static void main(String[] args){
m1();
m1(100);
m2(10, 3.14);
m2(3.14, 10);
m3(100);
m3(3.14);
}
public static void m1(){
System.out.println("m1无参数的执行!");
}
// 这个方法的参数个数和上面的方法的参数个数不同。
public static void m1(int a){
System.out.println("m1有一个int参数执行!");
}
public static void m2(int x, double y){
System.out.println("m2(int x, double y)");
}
// 参数的顺序不同,也算不同。
public static void m2(double y, int x){
System.out.println("m2(double y, int x)");
}
public static void m3(int x){
System.out.println("m3(int x)");
}
// 参数的类型不同。
public static void m3(double d){
System.out.println("m3(double d)");
}
//分析:以下两个方法有没有发生重载?
// 编译器报错了,不是重载,这是重复了:呵呵。
/*
public static void m4(int a, int b){
}
public static void m4(int x, int y){
}
*/
// 这两个方法有没有发生重载呢?
// 这不是重载,这是方法重复了。方法重载和返回值类型无关。
/*
public static int m5(){
return 1;
}
public static double m5(){
return 1.0;
}
*/
//这两个方法重载了吗?
// 这个方法没有修饰符列表
// 这不是重载,是重复了。
/*
void m6(){
}
// 这个有修饰符列表
public static void m6(){
}
*/
}
class MyClass{
// 不在同一个类当中,不能叫做方法重载。
public static void m1(int x, int y){
}
}
public class OverloadTest04{
public static void main(String[] args){
// 大家是否承认:println是一个方法名。
// println我承认是方法名了,但是这个方法谁写的?SUN公司的java团队写的。
// 你直接用就行。
// println()方法肯定是重载了。(不信,你可以翻阅一下SUN公司写的源代码看看。)
// 对于println()方法来说,我们只需要记忆这一个方法名就行。
// 参数类型可以随便传。这说明println()方法重载了。
System.out.println(10);
System.out.println(3.14);
System.out.println(true);
System.out.println('a');
System.out.println("abc");
System.out.println(100L);
System.out.println(3.0F);
// 调用m方法
m(100);
}
public static void m(int i){
}
}