Java-方法

知识点1-方法的定义及声明形式

1、方法的作用

Java语言中的“方法”（Method）在其他语言当中也可能被称为“函数”（Function）。对于一些复杂的代码逻辑，如果希望重复使用这些代码，并且做到“随时任意使用”，那么 就可以将这些代码放在一个大括号“{}”当中，并且起一个名字。使用代码的时候，直接找 到名字调用即可。

2、定义: 成员方法是类中进行数据处理（对象的行为），实现相关功能的函数。

方法决定了一个对象能够接收什么样的消息。方法的基本组成部分包括：名称、参数、返回值和方法体。

3、声明形式：

4、方法的各部分解析

• ①方法的命名：方法名的第一个单词应以小写字母作为开头，后面的单词则使用驼峰命名法。例如： sendMessge

• ②访问权限修饰符及修饰符：都在后续学习中详细学习

• ③返回值类型 :即方法运行后的返回结果的数据类型。返回类型可以是任意的Java数据类型，当一个方法不需要返回值时，返回类型为void。

  有返回值的情况：返回值类型和return后的返回值的数据类型必须一致. 无返回值的情况：返回值类型用void，此时return可以省略不写或者return;

• ④形式参数列表:就是变量列表，用于存储调用方法时传递给方法的实际参数。

  语法：方法名(数据类型1 参数名1,数据类型2 参数名2,数据类型3 参数名3....)
  ​
   注意：参数的个数可以是0个、1个或者多个

• ⑤return：用于结束方法以及返回方法指定类型的值。

• ⑥返回值：该方法执行后的结果，该结果会返回给调用者。

• ⑦方法体：方法体里面不能再定义方法，但可以调用其他，可以写局部变量、运算符、流程控制、数组等一切符合java规范的代码

5、如何写一个方法呢？思考以下三个方面：

• ①明确方法是否有返回的结果，如果有，返回什么类型的结果？

• ②明确方法是否需要参数，如果需要，需要几个什么类型的参数？

• ③方法如何才能正确得到想要的结果？

6、有明确返回值的方法调用：

• 单独调用，没有意义

• 输出调用，有意义，但是不够好，因为我不一定非要把结果输出

• 赋值调用，推荐方式

7、没有明确返回值的方法调用

• 其实就是void类型方法的调用

• 只能单独调用

8、总结方法的特点：

• 定义方法可以将功能代码进行封装。

• 方法只有被调用才会执行。

• 方法的出现提高代码的复用性。

• 方法若没有返回值，则用关键字void表示，那么该方法中的return语句如果在最后一行可以省略不写。

• 方法中可以调用方法，不可以在方法内部定义方法。

• 定义方法时，方法的结果应返回给调用者，交由调用者来处理

9、常见错误

• 方法的返回类型为void，方法中不能有return返回值！
• 方法不能返回多个值，如果想返回多个值，可以定义一个类，把多个值定义成成员变量，最后返回自定义类的对象。

10、综合案例：

import java.util.Scanner;
public class MethodTest {
    //定义一个方法，计算三个整数之和
    //名称、参数、返回值、方法体
    public int addInt(int a, int b, int c) {
        int sum = a + b + c;//三个参数相加赋值 sum变量
        return sum; //把sum变量值返回
        //return "abc"; //返回值的类型 要与int保持一致
    }
    public void add(int a, int b, int c) {
        //方法体里面不能再定义方法//int sum = a + b + c;
        //方法体里可以调用其他方法
        int sum = addInt(a, b, c);
        //return; void返回值类型 直接写return; 或者 return可以不写
        return;  //return; 结束方法，return;后面的就会不执行了
    }

    /**
     * 求三个数的平均值*/
    public double avgInt(int a, int b, int c) {
        double avg = (a + b + c) / 3.0;
        return avg;
    }
    /**
     * 求2个数的最大值
     * @param a 第一个整数
     * @param b 第二个整数
     * @return 最大值
     */
    public int maxInt(int a, int b) {
        int max = a > b ? a : b;
        return max;
    }
    /**
     * 判断2个数是否相等
     *
     * @param a
     * @param b
     * @return
     */
    public boolean compare(int a, int b) {
        boolean result = a == b ? true : false;
        return result;
    }
    /**
     * 打印星号
     *
     * @param rows 行数
     * @param cols 列数
     */
    public void printStar(int rows, int cols) {
        //双层循环，外控制行，里层控制列
        //控制行的循环
        for (int i = 0; i < rows; i++) {
            //控制列的循环
            for (int j = 0; j < cols; j++) {
                System.out.print("*\t");
            }
            //换行
            System.out.println("");
        }
        //可以省略
        return;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数:");
        //接收用户输入的第一个整数
        int a = sc.nextInt();
        System.out.println("请输入第二个整数:");
        int b = sc.nextInt();
        System.out.println("请输入第三个整数:");
        int c = sc.nextInt();
        //使用new 创建MethodTest对象
        MethodTest test = new MethodTest();
        //调用对象addInt方法，接收方法返回值
        int sum = test.addInt(a, b, c);
        System.out.println("三个数的和为：" + sum);
        System.out.println("=======三个数的平均值===========");
        //调用avgInt方法
        double avg = test.avgInt(a, b, c);
        System.out.println("三个数的平均值为：" + avg);
        //有返回值方法，单独调用没有意义
        //test.avgInt(a, b, c);
        //有返回值的方法，输出调用有意义，但是需求中不一定要输出调用
        //System.out.println(test.avgInt(a, b, c));
        System.out.println("=========两个数最大值============");
        //调用maxInt方法
        int max = test.maxInt(a, b);
        System.out.println("两个数a和b最大值为：" + max);
        System.out.println("==========判断两个数是否相等========");
        //调用compare
        boolean result = test.compare(b, c);
        System.out.println("两个数b和c是否相等：" + result);
        System.out.println("==========打印星号=============");
        //调用printStar
        test.printStar(3, 4);
    }
}

知识点2-方法的调用以及参数传递

• 方法创建后如何调用？

  语法：对象名.方法名(实际参数列表)

  注意：1.实际参数就是传递实际的值。

  2.实际参数可以是0个、1个或者多个，多个实际参数使用逗号分隔。

• 调用无返回值的方法；调用用返回值的方法

public class PersonTest {
    public void print() {
        System.out.println("无返回值");
    }
    public static int add(int a, int b) {//形参
        int c = a + b;
        return c;
    }
    public static void main(String[] args) {
        //创建PersonTest对象
        PersonTest test = new PersonTest();
        //调用无返回值的方法
        test.print();
        int a = 1, b = 1;//实参
        //调用有返回值的方法
        int c = add(a, b);
        System.out.println(a + "+" + b + "=" + c);
    }
}

知识点3-可变参数

J2SE 1.5中提供了一种允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

1、可变参数定义形式：

2、如果有多个参数，可变参数一定放在最后，并且一个方法只能有一个可变参数。

3、可变参数使用

public class VariableParamTest {
    //求和
    public int add(int... val) {
        //val看成数组处理
        int sum = 0;
        for (int i = 0; i < val.length; i++) {
            sum += val[i];
        }
        return sum;
    }
    //comp方法叫重载，方法名称相同，但形参列表不同（形参个数不同，参数类型不同）
    //comp(1,2,3,4)
    public void comp(int... items) {
        System.out.println("调用了comp(int... items)");
    }
    //变参数和数组作为参数去实现重载时，会报错，说明可变参数与数组冲突以像操作数组一样操作该参数
//    public void comp(int[] vals) {
//
//    }
    public void comp(int a, int b) {
        System.out.println("调用了comp(int a, int b)");
    }
    public void comp(String a, String b) {
    }
    //abc方法名名称没有定义过
    public void abc(int[] vals) {
    }
    public static void main(String[] args) {
        //1、创建VariableParamTest对象
        VariableParamTest test = new VariableParamTest();
        System.out.println(test.add(3, 4, 5));//传3个参数
        System.out.println(test.add(7, 8, 9, 10, 12));//传5个参数
        System.out.println(test.add()); //传0个参数
        int[] a = {10, 20, 30};
        //可变参数，实参可以使用数组类型传入
        System.out.println(test.add(a));
        //调用comp方法
        test.comp(1, 2); //优先调用参数定长的
    }
}

知识点4：可变参数与注意事项

• Java中可变参数的特点：

  • Java把可变参数当做数组处理

  • 可变参数必须位于最后一项。当可变参数个数多余一个时，必将有一个不是最后一项，所以只支持有一个可变参数。因为参数个数不定，所以当其后边还有相同类型参数时，java无法区分传入的参数属于前一个可变参数还是后边的参数，所以只能让可变参数位于最后一项

  • 可变参数用...代替标识， ...位于变量类型和变量名之间，前后有无空格都可以

  • 用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数

知识点5：匿名类型，基本数据类型，引用数据类型当参数

• 匿名对象

  • 没有名字的对象，在创建对象时，只通过new的动作在堆内存开辟空间，没有把堆内存空间的地址值赋值给栈内存的某个变量用以存储

  • 匿名对象不会当成垃圾

• 基本数据类型当参数：

  • 基本数据类型传递的是值，独立的空间，相互不影响的。

• 引用数据类型当参数

  • 引用数据类型传递的是地址。但是String类型和基本数据类型的值传递一致

public class PassValueTest {
    int age = 10;
    public void print(PassValueTest t) {
        System.out.println("age=" + t.age);
    }
    public void add(int x) {
        x++;
        System.out.println("add(int x):" + x);
    }
    public static void main(String[] args) {
        PassValueTest test = new PassValueTest();
        test.age = 30;
        System.out.println(test.age);
        //PassValueTest t= new PassValueTest();
        //打印结果是10
        test.print(new PassValueTest());//匿名对象不会被当成垃圾
        //基本数据类型传递的是值，独立的空间，相互不影响的。
        int x = 100;
        test.add(x);
        System.out.println("main:x=" + x);
        System.out.println("===============");
        //引用数据类型传递的是地址
        int[] a = {1, 2, 3, 5, 6};
        test.getValue(a);
        for (int val : a) {
            System.out.println(val);
        }
    }
    public void getValue(int[] a) {
        a[0] = 300;
    }
}
/*
30
age=10
add(int x):101
main:x=100
===============
300
2
3
5
6
 */

知识点6：方法递归

• 在程序设计中,方法直接或者间接调用其自身叫做递归调用，简称递归，其设计方法被应用到很多特殊问题的解决上

　　

 

• 递归要点：

  • 每次递归调用都要使问题简单化

  • 必然后一个边界条件

  • 使用递归代码往往更加简洁，可读性强。

• 案例:使用Java代码求5的阶乘(5*4*3*2*1)

  (1)边界条件：阶乘，乘到最后一个数，即1的时候，返回1，程序执行到底；

  (2)递归前进段：当前的参数不等于1的时候，继续调用自身；

  (3)递归返回段：从最大的数开始乘，如果当前参数是5，那么就是5*4，

  即5(5-1)，即nf(n-1) 54321

  public class RecursionTest {
      public static void main(String[] args) {
          int result = f(5);
          System.out.println("5的阶乘(5!)是：" + result);
      }
      public static int f(int n) {
          if (1 == n) {
              return 1;
          } else {
              return n * f(n - 1);
          }
      }
  }
  /**
   * 5的阶乘(5!)是：120
   */