java笔记7----java中的方法、递归

1、方法

1. 方法的定义

   在程序开发的过程中，会编写到很多重复的代码，，可以使用方法对这些代码进行管理，可以使用方法实现对代的管理和重用(重复使用)，可以把方法理解成一个可以重复多次使用的功能。

2. 方法的格式

   在给方法和变量起名的时候都要注意，一定要起个有意义的名字，做到见名知意。

   [访问权限] [修饰符] 返回类型 方法名称(参数类型 参数) {
   	方法体;
   	return 返回参数 ;
   }
   //如：返回一个学生信息
   public static String getInfo() {
       return "【学生信息】：\n" + "学生姓名：" + getName() + "、学生年龄：" + getAge() + "、学生性别：" + getSex();
   }
   

3. 方法都有哪几种方法

   根据返回值类型的不同和是否有参数可以分为

   返回值	有无参
   void(无返回值)	有参数/无参数
   引用数据类型（类）	有参数/无参数
   基本数据类型	有参数/无参数

   代码如下：

   //无返回值无参数
       public static void main(String[] args) {
           //调用打印功能语句
           //无参数无返回值的方法
           printInfo();
       }
       /**
        * 无参数无返回值的打印方法
        * 打印功能
        * @author hgw
        * @date 2022/1/17 9:43
        */
       public static void printInfo(){
           System.out.println("这是一个打印功能，调用此功能可以打印一些东西");
           System.out.println("一些东西");
       }
   
   //无返回值有参数
   	public static void main(String[] args) {
           //调用打印功能语句
           printInfo("星期一");
       }
   
       /**
        * 无返回值有参数
        * @author hgw
        * @date 2022/1/17 9:47
        * @param week 星期
        */
       public static void printInfo(String week){
           System.out.println("***************");
           System.out.println("今天是：" + week);
           System.out.println("***************");
       }
   
   
   	public static void main(String[] args) {
           //调用打印功能语句
           //有返回值无参数
           String str = getInfo();
         	System.out.println(str);
         	//或者直接
         	System.out.println(getInfo());
       }
   	//有返回值无参
   	//如：返回一个String类型的字符串信息
   	public static String getInfo() {
       	return "【学生信息】：\n" + "学生姓名：" + getName() + "、学生年龄：" + getAge() + "、学生性别：" + getSex();
   	}
   
   //有返回值有参数类型
   	public static void main(String[] args) {
           //调用打印功能语句
           //有返回值无参数
           double sum = sum(1,2);
         	System.out.println(sum);
         	//或者直接
         	System.out.println(sum(1,2));
       }
   
       /**
        * 通过有参数有返回值的方法求两数之和
        * @author hgw
        * @date 2022/1/17 10:04
        * @param num1
        * @param num2
        * @return double
        */
       public static double sum(double num1,double num2) {
           return num1 + num2;
       }
   

4. 方法的重载（Overload）

   方法重载是方法重用的一种表现形式。

   特点：

   ​ 方法名称相同，而参数列表（参数的类型、个数）不同。

   ​ 返回类型可以相同也可以不同。

   通过求和案例实现方法重载：

   /**
    * @author hgw
    * @date 2022年01月17日10:27
    **/
   public class Test2 {
       public static void main(String[] args) {
           int result1 = sum(1,2);
           int result2 = sum(1,2,6);
           double result3 = sum(1,5.5);
         //下面这三个print语句也可以理解为一种方法重载
           System.out.println(result1);
           System.out.println(result2);
           System.out.println(result3);
       }
       /**
        * 求两数之和
        * @author hgw
        * @date 2022/1/17 10:28
        * @param num1  数1
        * @param num2  数2
        * @return int  返回值为int类型
        */
       public static int sum(int num1, int num2){
           return num1 + num2;
       }
       /**
        * 求三数之和   与上面相比：方法名称相同，返回值类型也相同，参数类型相同，参数个数不相同
        * @author hgw
        * @date 2022/1/17 10:31
        * @param num1  数1
        * @param num2  数2
        * @param num3  数3
        * @return int 返回值为int类型
        */
       public static int sum(int num1, int num2, int num3){
           return num1 + num2 + num3;
       }
       /**
        * 求两数之和，与第一种方法，只有方法名称和参数个数相同，其他都不相同
        * @author hgw
        * @date 2022/1/17 10:36
        * @param num1
        * @param num2 
        * @return double
        */
       public static double sum(double num1, double num2){
           return num1 + num2;
       }
   }
   

5. 方法递归

   ​ 方法递归指的是方法自己调用自己

   使用递归需要注意：

   ​ 使用递归的时候需要注意要提供出口（结束条件）！ 这个最最最重要，否则会造成死循环，产生内存溢出。

   ​ 每次递归都会根据递归需求，改变传递的参数内容

   递归代码1：

   /**
    * @author hgw
    * @date 2022年01月17日10:57
    **/
   public class Test3 {
       public static void main(String[] args) {
           //打印到1 + .. + 100的结果
           System.out.println(sum(100));
       }
       /**
        * 求1 + .... + num
        * 以递归的形式实现1+ 2 +3 + ... + 100
        * @author hgw
        * @date 2022/1/17 11:14
        * @param num 数
        * @return int 返回类型
        */
       public static int sum(int num){
           //设置出口
           if (num == 1){
               return 1;
           }
           return num + sum(num - 1);
       }
   }
   

   递归代码2：

   /**
    * 递归
    * @author hgw
    * @date 2022年01月17日11:17
    **/
   public class Test4 {
       public static void main(String[] args) {
           //打印3的阶乘     结果为6
           System.out.println(factorial(3));
           //1！ + 2！ + 3！ +... + 10！
           System.out.println(sum(10));
       }
       /**
        * 使用递归求 1！ + 2！ + 3！ + ... + n！
        * @author hgw
        * @date 2022/1/17 11:27
        * @param n 
        * @return int
        */
       public static int sum(int n){
           //设置出口
           if (n == 1) {               //如果n = 1，则直接返回factorial(1)
               return factorial(1);
           }
           return factorial(n) +  factorial(n-1);
       }
   
       /**
        * 通过递归定义，求n的阶乘的方法
        * @author hgw
        * @date 2022/1/17 11:23
        * @param num num的阶乘
        * @return int  返回阶乘数
        */
       public static int factorial(int num){
           //设置出口
           if (num == 1){          //如果num为1，则直接返回1
               return 1;
           }
           return num * factorial(num - 1);        //递归调用
       }
   }
   

   ​

   ​