Java方法重载基本使用

方法重载基本使用

• 基本介绍

  • java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！

  • 比如：System.out.println(); out 是 PrintStream 类

• 重载的好处

  1. 减轻了起名的麻烦

  2. 减轻了记名的麻烦

• 案例：类：MyCalculator 方法：calculate

  1. calculate(int n1, int n2) //两个整数的和

  2. calculate(int n1, double n2) //一个整数，一个 double 的和

  3. calculate(double n2, int n1) //一个 double ,一个 Int 和

  4. calculate(int n1, int n2,int n3) //三个 int 的和

public class OverLoad {
    public static void main(String[] args) {
        MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1, 2.1));
        System.out.println(mc.calculate(1.1, 2));
        System.out.println(mc.calculate(1,2,3));
    }
}

class MyCalculator  {

	//下面的四个 calculate方法构成了重载
	//两个整数的和
	public int calculate(int n1, int n2)  {
		System.out.println("calculate(int n1, int n2) 被调用");
		return n1 + n2;
	}
	
	//没有构成方法重载, 仍然是错误的，因为是方法的重复定义
	// public void calculate(int n1, int n2)  {
	// 	System.out.println("calculate(int n1, int n2) 被调用");
	// 	int res =  n1 + n2;
	// } 

	//看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了
	// public int calculate(int a1, int a2)  {
	// 	System.out.println("calculate(int n1, int n2) 被调用");
	// 	return a1 + a2;
	// } 
	
	//一个整数，一个double的和
	public double calculate(int n1, double n2) {
		return n1 + n2;
	}
	//一个double ,一个Int和 
	public double calculate(double n1, int n2) {
		System.out.println("calculate(double n1, int n2) 被调用..");
		return n1 + n2;
	}
	//三个int的和
	public int calculate(int n1, int n2,int n3) {
		return n1 + n2 + n2;
	}

}

• 注意事项和使用细节

1. 方法名:必须相同

2. 形参列表:必须不同 (形参类型或个数或顺序,至少有一样不同,参数名无要求)

3. 返回类型:无要求.

• 判断题:

  与void show(int a,char b,double c){}构成重载的有:(BCDE)

  A: void show (int x,char y, doublec z){} // 不是,方法名相同但是形参名不同

  B: int show(int a, double c, char b){} // 是

  C: void show(int a, double c, char b){} // 是

  D: boolean show(int c,char b){} // 是

  E: void show(double c){} // 是

  F:double show(int x, char y,double z){} // 不是

  G: void shows(){} // 不是 方法名不同

• 练习题

  • 编写程序，类Methods中定义三个重载方法并调用。方法名为m。三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。在主类的main 0)方法中分别用参数区别调用三个方法。

    public class OverLoadExercise {
        public static void main(String[] args) {
            //在主类的main ()方法中分别用参数区别调用三个方法
            Methods method = new Methods();
            method.m(10);//100
            method.m(10, 20);//200
            method.m("皮卡丘");//字符串信息
        }
    }
    
    class Methods{
        //分析
        //1 方法名 m
        //2 形参 (int)
        //3.void
        public void m(int n) {
            System.out.println("平方=" + (n * n));
        }
    
        //1 方法名 m
        //2 形参 (int, int)
        //3.void
        public void m(int n1, int n2) {
            System.out.println("相乘=" + (n1 * n2));
        }
    
        //1 方法名 m
        //2 形参 (String)
        //3.void
        public void m(String str) {
            System.out.println("传入的str=" + str);
        }
    }
    

  • 在Methods类，定义三个重载方法max()，第一个方法，返回两个int值中的最大值，第二个方法,返回两个double值中的最大值，第三个方法,返回三个double值中的最大值,并分别调用三个方法。

    public class OverLoadExercise { 
    
    	public static void main(String[] args) {
    
    		Methods method = new Methods();
    
    		System.out.println(method.max(10, 24)); // 24
    		System.out.println(method.max(10.0, 21.4)); // 21.4
    		System.out.println(method.max(10.0, 1.4, 30.0)); // 30.0
    	}
    }
    
    class Methods {
    	//分析
    	//1 方法名 max
    	//2 形参 (int,int) 
    	//3.int
    	public int max(int n1, int n2) {
    		return n1 > n2 ? n1 : n2;
    	}
    
    	//分析
    	//1 方法名 max
    	//2 形参 (double,double) 
    	//3.double
    	public double max(double n1, double n2) {
    		return n1 > n2 ? n1 : n2;
    	}
    
    	//1 方法名 max
    	//2 形参 (double,double,double) 
    	//3.double
    	public double max(double n1, double n2, double n3) {
    		
    		//求出n1 和  n2的最大值
    		double max1 = n1 > n2 ? n1 : n2;
    		return max1 > n3 ? max1 : n3;
    	}
    
    }