方法的重载:
    方法重载，这在我们生活中也是常见的的。比如说洗衣服，洗汽车。这两种动作都是洗，但我我们发现，我们并没有说用洗衣服的方式洗衣服，用洗汽车的方式去洗汽车。我们可以根据不同的语境来判断不同的动作行为。同样我们在程序中有如何让计算机也具备同样的功能呢——方法的重载。

    1. public OverLoading{
    2. }class Number{
    3.      void test(int i){
    4.          System.out.println("i的值为"+i);
    5.      }
    6.     void test(String str){
    7.         System.out.println("str");
    8.     }
    9.      void test(int i,int b){
    10.            int c=i+b;
    11.          System.out.println("i+b的值为"+c);
    12.      }
    13. }
    14. public class OverLoading {
    15.     public static void main(String[] args) {
    16.         Number number = new Number();
    17.         number.test(1);
    18.         number.test(3,4);
    19.         number.test("方法的重载");
    20.     }
    21. }

    我们发现，通过上面的代码可以看出，同一个test()方法，却能执行出不同的行为。这种情况就叫做方法的重载。同样的，一个类中的构造方法我们也可进行重载

    1. class Tree{
    2.      Tree(int a){
    3.          System.out.println("这课树长了"+a+"米");
    4.      }
    5.      Tree(String name){
    6.          System.out.println("这课树叫"+name+"树");
    7.      }
    8. }
    9. public class OverLoading2 {
    10.     public static void main(String[] args) {
    11.         Tree tree = new Tree(12);
    12.         Tree tree1 = new Tree("杨树");
    13.     }
    14. }

    我们发现，我们在创建同一个对象的不同引用时，进行不同的初始化操作，会去自动找到响应的有参构造方法。

    区分重载方法
    这个时候我们都应该非常好奇，java是如何根据同一个方法名来判断出来我们需要执行的方法呢？我们发现每一个重载的方法都有一个独一无二的参数类型列表。所以说，正是因为这些参数类型不同，java才可以去重载方法。甚至说，每个参数的位置不同也是区份两个方法的原因，但那样会使我们的代码变的不容易维护。所以，一般我们不这样去做。
    返回值来区分：
    我看可能也会想到，方法的返回值应该也可以去作为区分的依据。我们看下面的代码

    1. void f(){};
    2. int f(){return 1;}

    如果这个时候我们调用f()方法的时候，此时java该如何去进行一个判断呢。这些写的话别人有该怎样去理解呢？所1以我们不这样去区分重载方法，所以如果我们这样书写，那编译器也不会给我们通过的。
    基本类型的重载。
    基本类型会重较小的类型自己动转化成较大类型，那么这个过程如果涉及到重载中呢？我们来看下面的列子

    1. public class Demotion {
    2.  static void f(char x){
    3.       System.out.println("char类型");
    4.   }
    5.     static  void f(byte x){
    6.         System.out.println("byte类型");
    7.     }
    8.     static void f(short x){
    9.         System.out.println("short类型");
    10.     }
    11.     /*static void f(int x){
    12.         System.out.println("int类型");
    13.     }*/
    14.     static void f(long x){
    15.         System.out.println("long类型");
    16.     }
    17.     static void f(float x){
    18.         System.out.println("float类型");
    19.     }
    20.     static void f(double x){
    21.         System.out.println("double类型");
    22.     }
    23.     public static void main(String[] args) {
    24.          int i=7;
    25.          f(i);
    26.     }
    27. }
    • 在上面的代码中，我们设置了一个int类型的变量i，同时，我们同f(int x)这个方法给他注释掉我们运行发现输出为“long类型”，所以我们可以发现。当我把一个较小类型的参数，传给到一个较大类型的方法里面，那么他会自动提出为较大的类型。如果这个时候我们传入的类型大于方法中的类型呢？我们把方法中的参数类型为char的代码注释掉。同时把int 类型变为char。此时为发现，程序会报错，需要我进行强制类型转化。