带你从零学大数据系列之Java篇---第四章:方法

温馨提示:如果想学扎实,一定要从头开始看凯哥的一系列文章(凯哥带你从零学大数据系列),千万不要从中间的某个部分开始看,知识前后是有很大关联,否则学习效果会打折扣.

系列文章第一篇是拥抱大数据：凯哥带你从零学大数据系列-学习大数据前奏(必读)(点我)!

上一篇:拥抱大数据：凯哥带你从零学大数据系列之Java篇---第三章:流程控制

课程重点：

• 方法的定义与调用
• 方法的参数使用
• 方法的返回值使用
• 方法的重载

4.1. 方法的简介

4.1.1. 方法的概念

在程序中， 有些情况下， 有些代码是需要被多次执行的。 如果需要在每次使用到这些逻辑的时候， 都去写代码实现， 此时代码将会非常的冗余， 不利于维护。

此时， 我们可以将这些需要被多次执行的逻辑单独包装起来， 在需要的时候直接调用即可。

方法， 就是为了实现这个需求而存在的。

方法， 其实就是一个实现特定功能的代码段， 方法中的逻辑可以被重复使用。

4.1.2. 为什么要使用方法

可以使用方法， 将需要多次执行的逻辑封装起来， 哪里需要， 哪里直接调用即可。

降低了代码的冗余， 提高了代码的复用性与维护性。

4.2. 方法的定义与调用

4.2.1. 方法的定义

[访问权限修饰符] [其他的修饰符] 返回值类型 方法名字([参数列表]) {
	方法体
}

• 访问权限修饰符： 定义了方法的访问权限。 访问权限在面向对象部分讲解， 这部分内容暂不写。
• 其他的修饰符： 定义了方法的其他的修饰。 这部分的修饰符， 在后续的课程中陆续讲解。 这里暂时先写 static。
• 返回值类型： 返回值知识点在4.4中讲解， 暂时先写 void。
• 方法名字： 遵循小驼峰命名法的标识符。
• 参数列表： 将在4.3中讲解， 暂时不写。
• 方法体： 需要封装起来的， 可以被重复执行的代码段。

4.2.2. 第一个方法

// 这个方法中， 封装了一个九九乘法表的逻辑
// 哪里需要输出九九乘法表， 直接调用这个方法即可
static void display () {
   for(int line=1; line<=9; line++) {
       for(int colume=1; colume<=9; colume++) {
           System.out.print (colume+" x "+line+" = "+colume*line+"\t");
      }
       System.out.println ();
  }
}

4.2.3. 方法的调用

方法写完后， 其中的逻辑并不会立即执行。 如果想让程序中的逻辑执行， 需要调用方法。

调用方法， 直接使用方法的名字即可。

/**
* @Description 方法的调用
*/
public class Test {
   public static void main (String[] args) {
       // 方法的调用
       display ();
  }
   // 九九乘法表的逻辑
static void display () {
  for(int line=1; line<=9; line++) {
       for(int colume=1; colume<=9; colume++) {
           System.out.print (colume+" x "+line+" = "+colume * line+"\t");
      }
       System.out.println ();
  }
}
}

4.3. 方法的参数

4.3.1. 参数的概念

多数情况下， 方法与调用者之间需要进行数据的交互。 调用者必须提供必要的数据， 才能使用方法完成相应的功能。

例如:
ATM取款机， 封装了取钱的功能。 用户在使用ATM取款的时候， 需要插入银行卡。 此时， 就是使用者与功能集的数据交互。
自动贩卖机， 封装了贩卖的功能。 用户在使用自动贩卖机的时候， 需要选择购买的物品。 此时， 也是使用者与功能集的数据交互。

调用方法的时候， 需要将一些数据传入到方法中， 实现调用方与方法的数据交互。 这个被传入到方法中的数据， 被称为是 参数。

4.3.2. 参数的定义

参数定义在方法的小括号中， 与变量的定义类似， 使用 数据类型 标识符 的方式定义。

/**
* @Description 方法的调用
*/
public class Test {
   // 定义了一个打印若干个分隔符的方法， 数量由参数count定义。
   static void printSign (int count) {
       for(int i=0; i<count; i++) {
           System.out.print ("-");
      }
       System.out.println ();
  }
}

定义参数的注意事项：

• 参数定义在方法的参数列表中， 使用 数据类型 标识符 的形式定义。
• 如果需要定义多个参数， 多个参数之间以逗号分隔。
• 参数在定义的时候， 不允许赋初始值。
• 即便多个参数的类型都是相同的， 每一个参数也必须显式的定义类型。

4.3.3. 有参方法的调用

在调用有参方法的时候， 必须给每一个参数进行赋值。 直接将这些值写入到小括号里面即可。

/**
* @Description 方法的调用
*/
public class Test{
   public static void main (String[] args) {
       System.out.println ("Hello,凯哥");
       printSign (10);// 将10给参数count进行赋值。
       System.out.println ("欢迎欢迎")；
  }
   // 定义了一个打印若干个分隔符的方法， 数量由参数count定义。
   static void printSign (int count) {
       for(int i=0; i<count; i++) {
           System.out.print ("-");
      }
       System.out.println ();
  }
}

4.3.4. 几个概念

• 形参
  • 定义在方法的参数列表中， 这样的参数只是一个形式。 在方法中并不知道这个参数的值是什么， 只有在调用的时候才知道具体的值是多少。
  • 这样的参数被称为 形式参数， 简称 形参

 

• 实参
  • 定义在方法调用时候的小括号中。 这个参数是形参实际的值。
  • 这样的参数被称为 实际参数， 简称 *实参

 

• 传参
  • 在调用方法的时候， 实参给形参进行赋值。 这个过程被称为 传参

4.4. 方法的返回值

4.4.1. 返回值的概念

在进行方法调用的时候， 有些情况下是需要有逻辑执行结果的。

例如
ATM取款机， 用户在取完钱之后， 一定是要能够得到实际的钱的。 此时就是调用功能集得到的结果。

4.4.2. 返回值的定义

在前面定义方法的时候， 返回值类型部分， 写的是 void。

void: 表示无， 没有返回值。 表示这个方法没有执行结果。

static int add (int a, int b) {
   return a+b;
}

注意事项

如果一个方法的返回值类型不是void， 则方法在执行结束之前， 必须要有return关键字返回一个结果。

4.4.3. return关键字

表示方法的执行结果。
return关键字后面跟上方法的执行结果， 这个值的类型， 必须和方法定义中的返回值类型一致。

static int add (int a, int b) {
 return a + b;// 将 a + b 的运算结果， 作为整个方法的执行结果。
}

• 表示结束方法的执行
  在一个返回值类型为void的方法中， 也可以使用return关键字。 此时， return后面什么都不要写。

return写在方法中， 表示结束方法的结束。
static int add (int a, int b) {
 return a + b;
 // return执行后， 后面的所有的代码都不执行。
 // 方法结束。
}

4.5. 方法的重载

4.5.1. 重载的概念

在一个类的方法中， 如果多个方法满足如下条件， 则他们之间的关系就是重载

• 方法名相同
• 参数不同
  • 参数不同， 体现在参数的数量不同或者参数的类型不同。

注意： 方法的重载， 与返回值没有关系！

4.5.2. 重载方法的定义

/**
* @Description 方法的重载
*/
public class Test {
   static void calculate () {}
   static void calculate (int a) {}
   static void calculate (int a, int b) {}
   static String calculate (String x, String y) {
       return x + y;
  }
}

4.5.3. 重载方法的调用

调用重载方法的时候， 使用实参区分调用不同的方法。

/**
* @Description 方法的调用
*/
public class Test {
   static void calculate () {}
   static void calculate (int a) {}
   static void calculate (int a, int b) {}
   static String calculate (String x, String y) {
       return x + y;
  }
   
   public static void main (String[] args) {
       calculate ();// 无参的方法调用
       calculate (10);// calculate(int a) 方法的调用
       calculate (10, 20);// calculate(int a, int b) 方法的调用
       calculate ("a", "b");// calculate(String x, String y) 方法的调用
  }
}

4.6. 方法的递归

4.6.1. 递归是什么

递归， 是一种程序设计的思想。 在解决问题的时候， 可以将问题拆分成若干个小问题。 通过解决这些小的问题， 逐渐解决这个大的问题。

4.6.2. 何时使用递归

• 当需要解决的问题可以拆分成若干个小问题，大小问题的解决方法相同。
• 有固定规律， 方法中调用自己。

4.6.3. 如何正确使用递归

递归， 由于涉及到方法的循环调用， 因此容易出现死递归的情况。 即所有的方法调用没有出口， 只能将方法压栈执行， 但是无法结束方法。

因此， 在使用递归的时候， 需要设置有效的出口条件， 避免无穷递归。

4.6.4. 递归的案例

/**
* @Description 递归
*/
public class Test {
   public static void main (String[] args) {
       // 计算5的阶乘
       mutiply ( 5 );
  }
   static int mutiply (int number) {
       if(number == 1) {
           return 1;
      }
       return number * mutiply (number - 1);
  }
}