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