我的Java学习之路——方法重载

方法重载（Overload）
java中允许同一个类中多个同名方法的存在，但要求形参列表不一致！
比如：System.out.println();
out是PrintStream类型

简单测试
public class Main{
    public static void main(String[]args){
        System.out.println(100);
        //整数类型
        System.out.println("hello world");
        //字符串类型
        System.out.println('h');
        System.out.println(true);
        //布尔类型
        //可以输出不同的类型
    }
}

重载的好处：
减轻了起名与记名的麻烦
例如：
printlnt
printChar
printString
可见不同形参要去不同方法名，过于麻烦

 

案例：类：MyCalculator（计算），方法：calculate
calculate(int n1, int n2)//两个整数和
calculate(int n1, double n2)//一个整数，一个double和
calculate(int n1, int n2， int n3)// 三个整数和

public class Main{
    public static void main(String[]args){
        MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1, 2.5));
        System.out.println(mc.calculate(1, 2, 3));
    }
}
 class MyCalculator {
     public int calculate(int n1, int n2) {
         return n1 + n2;
     }
     public double calculate(int n1, double n2){
         return n1 + n2;
     }
     public int calculate(int n1, int n2, int n3){
         return n1 + n2 + n3;
     }
 }

 

编译可以通过
结论：下面四个calculate方法构成了重载

1.方法名不相同，不能构成重载
 类如：
      public int calculate(int n1, int n2) {
          return n1 + n2;
      }
      public double calculate02(int n1, double n2){
          return n1 + n2;
      }

 

2.形参列表必须不同，形参类型或个数或顺序至少有一样不同，参数名无要求
列如：
      public int calculate(int n1, int n2) {
          return n1 + n2;
      }
      public double calculate02(int n1, double n2){
          return n1 + n2;
      }
虽然方法名相同，但形参个数不一样

 

3.顺序不一样也可构成重载

      public double calculate(int n1, double n2) {
          return n1 + n2;
      }
      public double calculate02(double n1, int n2){
          return n1 + n2;
      }

 

4.参数名无要求

      public int calculate(int n1, int n2) {
          return n1 + n2;
      }
      public int calculate02(int a1, int a2){
          return n1 + n2;
      }
虽然参数名不同，但不能构成重载

 

5.返回
      public int calculate(int n1, int n2) {
          return n1 + n2;
      }
      public void calculate02(int a1, int a2){
          int res = n1 + n2;
      }
      即便返回值不同也不能构成重载，因为方法重复定义

     //练习：
     public class Main{
         /*
          编写程序，类Methods中定义三个重载方法并调用，方法名为m
          */
         public static void main(String[]args) {
             Methods methods = new Methods();
             methods.m(2);
             methods.m(2, 3);
             methods.m("java is better");
         }
     }
      class Methods {
          public void m(int n) {
              System.out.println("平方=" + (n * n));
          }
          public void m(int n1, int n2) {
              System.out.println("相乘=" + (n1 * n2));
          }
          public void m(String str) {
              System.out.println("传入的string=" + str);
          }
      }

 

//练习2：
public class Main{
    /*
     编写程序，类Methods中定义三个重载方法并调用，方法名为m
     */
    public static void main(String[]args) {
        Methods methods = new Methods();
        System.out.println(methods.m(6, 7));
        System.out.println(methods.m(3.2, 5.4));
        System.out.println(methods.m(5.1, 6.5, 3.2));
    }
}
 class Methods {
     public int m(int n1, int n2) {
         return n1 > n2 ? n1 : n2;
     }
     public double m(double n1, double n2) {
         return n1 > n2 ? n1 : n2;
     }
     public double m(double n1, double n2, double n3) {
         double max = n1 > n2 ? n1 : n2;
         return max > n3 ? max : n3;
     }
 }