Java-7 方法定義、值傳遞、引用傳遞、方法重載

/**
 * 方法：
 *  語法：
 *      <修飾符> 返回值類型  方法名（[參數類型  參數名稱，參數類型  參數名稱，....]）
 *      {
 *          方法體;
 *          return 返回值; 
 *      }
 * 
 *      修飾符：public (default) protected private 權限控制修飾符
 *           static 靜態方法，表示方法可以通過"類名.方法名"進行調用
 *           final 表示方法不能被重寫
 * 
 *      返回值類型：可以爲基本數據類型、引用類型，或沒有返回值void
 *                     必須與return語句的返回值類型保持一致，否則報錯
 * 
 *      方法名：camel命名法（駝峯法）：首字母小寫，其餘單詞首字母大寫，例如：methodOne
 *      
 *      參數列表：參數可以沒有，可以一個或者多個，多個參數中間","隔開    
 *               
 *                 形式參數(形參)：定義在方法的參數列表中，指定參數類型以及參數名稱，告訴使用該方法的人需要傳遞什麼類型的參數,例如：add(double x,double y)中的x 與 y
 *                 實際參數（實參）：調用方法時，傳遞的參數值，不需要指定參數類型，例如add(10.2,20.3)的10.2 與 20.3
 *      
 *      return:當返回值類型 爲void時，可省略；
 *             當返回值類型爲基本數據類型、引用類型時，return語句必須返回對應的類型值
 *             return語句之後定義的語句不執行。
 * 
 *  方法分類：參考有無參數，有無返回值
 *          ① 有參數，有返回值
 *          ② 有參數，無返回值
 *          ③ 無參數，有返回值
 *          ④ 無參數，無返回值
 */


/**
 * ① 有參數，有返回值
 * @param x 參數1
 * @param y 參數2
 * @return 返回值 double
 */
public static double add(double x,double y)
{
    double result = x + y;

    return result;
}
/**
 * ② 有參數，無返回值
 * @param num1  參數1
 * @param num2  參數2
 */
public static void minus(int num1,int num2)
{
    int result = num1 - num2;

    System.out.println("求差：" + result);

    //return; //無返回值，return可省略
}

/**
 * ③ 無參數，有返回值
 * @return 返回值double
 */
public static double multiply()
{
    double x = 10;
    double y = 20;

    double result = x * y;

    return result;
}

/**
 *  ④ 無參數，無返回值
 */
public static void divide()
{
    int num1 = 10;
    int num2 = 3;

    int result = num1/num2;

    System.out.println("求商：" + result);

    //return; //無返回值，return可省略
}

調用：

    //① 有參數，有返回值
    double result = add(10.2,20.3);
    System.out.println("求和：" + result);

    //② 有參數，無返回值
    minus(20,10);

    //③ 無參數，有返回值
    double result2 = multiply();
    System.out.println("求積：" + result2);

    // ④ 無參數，無返回值
    divide();

---

/**
 * 基本數據類型-----值傳遞：基本數據類型、String均爲值傳遞，方法中對參數的任何修改，均不影響實際傳遞的參數的值
 */
public static void getX(int x)
{
    x += 30;

    System.out.println("getX:" + x);//40
}

/**
 * 引用類型--------引用地址傳遞:引用類型爲引用地址傳遞，方法中對參數的修改，即爲對傳遞對象的修改
 */
public static void getArray(int[] array)
{
    array[0] = 100;

    System.out.println("getArray地址值:" + array);//[I@6a2437ef
    System.out.println("getArray:" + array[0]); //100
}


//值傳遞
    int x = 10;
    getX(x);

    System.out.println("main:" + x);//10

    //引用地址傳遞
    int[] array = new int[]{1,2,3,4};
    getArray(array);

    System.out.println("main地址值:" + array);//[I@6a2437ef
    System.out.println("main:" + array[0]); //100

---

    /**
     * 重載（overload）：
     *      通過調用同一方法名，傳遞不同的參數，實現同一的功能
     * 
     *      規則：
     *          1.方法名一致
     *          2.參數列表不一致（參數類型不一致，參數個數不一致，參數順序不一致）
     *          3.返回值類型可以一致，可以不一致
     */

/**
     * @param x 參數1
     * @param y 參數2
     * @return 返回值 double
     */
    public static double add(double x,double y)
    {
        double result = x + y;

        return result;
    }

    /**
     * @param x 參數1
     * @param y 參數2
     * @return 返回值 int
     */
    public static int add(int x,int y)
    {
        int result = x + y;

        return result;
    }

    /**
     * @param x 參數1
     * @param y 參數2
     * @param z 參數3
     * @return 返回值 int
     */
    public static int add(int x,int y,int z)
    {
        int result = x + y + z;

        return result;
    }

    /**
     * @param x 參數1
     * @param y 參數2
     * @return 返回值 double
     */
    public static double add(int x,double y)
    {
        double result = x + y;

        return result;
    }

    /**
     * @param x 參數1
     * @param y 參數2
     * @return 返回值 double
     */
    public static double add(double x,int y)
    {
        double result = x + y;

        return result;
    }


    double result = MethodOverload.add(10.12, 20.24);
    System.out.println(result);//30.36

    int result2 = MethodOverload.add(10, 20);
    System.out.println(result2);//30

    int result3 = MethodOverload.add(10, 20, 30);
    System.out.println(result3);//60

    double result4 = MethodOverload.add(10, 20.22);
    System.out.println(result4);//30.22

    double result5 = MethodOverload.add(10.22, 20);
    System.out.println(result5);//30.22