Java方法重载

在java中，同一个类中的多个方法可以有相同的名字，只要它们的参数列表不同就可以，这被称为方法重载(method overloading).
参数列表又叫参数签名，包括参数的类型，参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。
重载是面向对象的一个基本特性。
下面看一个详细的实例。

public class Demo
{
  //一个普通方法，不带参数
  void test()
  {
    System.out.println("No parameters");
  }
  //重载上面的方法，并且带了一个整形参数
  void test(int a)
  {
    System.out.println("a: " + a);
  }
  //重载上面方法，并且带了两个参数
  void test(int a,int b)
  {
    System.out.println("a and b: " + a + " " + b);
  }
  //重载上面的方法，并且带了一个双精度参数
  double test(double a)
  {
    System.out.println("double a: " + a);
    return a * a;
  }

  public static void main(String[] args)
  {
    Demo obj = new Demo();
    obj.test();
    obj.test(2);
    obj.test(2,3);
    obj.test(2.0);
  }
}

运行结果：
No parameters
a: 2
a and b: 2 3
double a: 2.0

通过上面的实例，读者可以看出，重载就是在一个类中，有相同的函数名称，但形参不同的函数。重载的结果，可以让一个程序段尽量减少代码和方法的种类。

说明：
• 参数列表不同包括：个数不同、类型不同和顺序不同。
• 仅仅参数变量名称不同是不可以的。
• 跟成员方法一样，构造方法也可以重载。
• 声明为final的方法不能被重载。
• 声明为static的方法不能被重载，但是能够被再次声明。

方法的重载的规则：
• 方法名称必须相同。
• 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
• 方法的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以成为方法的重载。

方法重载的实现：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，这叫做重载分辨。
再来一个例子:

package day24;

public class Compute 
{
    public static int sum(int a,int b)
    {
        System.out.println("sum(int,int)");
        return a + b;
    }

    public static double sum(double a,double b)
    {
        System.out.println("sum(double,double)");
        return a + b;
    }

    public static int sum(int a,int b,int c)
    {
        System.out.println("sum(int,int,int)");
        return a+b+c;
    }

    public static void test1(String s,int a)
    {

    }

    public static void test1(int a,String s)
    {

    }
}

package day24;
/*
 * 方法的重载
 *   在一个类中可以有多个方法共享同一个名称
 *   只要他们的参数不同就可以，根据参数类型
 *   和参数数量来决定要调用的方法
 *   
 *   重载：具有相同的方法名称，不同的参数列表
 *   不同的参数列表指的是:参数类型不同，参数数量不同，参数次序不同
 *   
 *   public static int sum(int a,int b){}
 *   我们再确定是否重载的时候，判定依据是sum(int a,int b)
 *   至于public static int 这几个东西，我们不理会
 */
public class Test 
{
    public static void main(String[] args)
    {
        //Compute c = new Compute();
        int sum = Compute.sum(3, 4);
        //int sum = c.sum(3, 4);
        System.out.println(sum);

        int sum1 = Compute.sum(5,1,2);
        System.out.println(sum1);

        double sum2 = Compute.sum(4.5,3.9);
        System.out.println(sum2);
    }
}

构造方法的重载

package day26;

public class Student
{
    String name;
    String stuNo;
    int age;
    String pickName;

    public Student()
    {
        /*name = null;
        stuNo = null;
        age = 0;
        pickName = null;*/
    }

    public Student(String name)
    {
        this.name = name;
    }

    public Student(String name,String stuNo)
    {
        //this(name);
        this.name = name;
        this.stuNo = stuNo;
    }

    public Student(String name,String stuNo,int age)
    {
        //this(name,stuNo);
        this.name = name;
        this.stuNo = stuNo;
        this.age = age;
    }

    public Student(String name,String stuNo,int age,String pickName)
    {
        //this(name,stuNo,age);
        this.name = name;
        this.stuNo = stuNo;
        this.age = age;
        this.pickName = pickName;
    }
}

package day26;
//构造方法的重载
public class TestStudent 
{
    public static void main(String[] args)
    {
        Student s1 = new Student();
        printStudent(s1);
        Student s2 = new Student("张三");
        printStudent(s2);
        Student s3 = new Student("张三","49");
        printStudent(s3);
        Student s4 = new Student("张三","49",12);
        printStudent(s4);
        Student s5 = new Student("张三","49",12,"小张");
        printStudent(s5);
    }
    public static void printStudent(Student s)
    {
        System.out.println("姓名:"+s.name);
        System.out.println("学号:"+s.stuNo);
        System.out.println("年龄:"+s.age);
        System.out.println("昵称:"+s.pickName);
        System.out.println("---------------------");
    }
}