Java零基础小白入门教程第五次课_方法

怼烎@ 2023-09-29 18:07 9阅读 0赞

## day05\_java基础 ##

## 课程目标 ##

1. 【理解】什么是方法
    2. 【掌握】方法的格式
    3. 【理解】方法的执行流程
    4. 【掌握】方法的案例
    5. 【理解】方法的重载
    6. 【理解】方法参数的传递

## 一.方法概述 ##

### 什么是方法 ###

> 方法（method）完成某一个特定功能的代码块

### 方法基本使用 ###

> 将资料中给大家提供的打怪物发射炮弹重复的代码，把一些重复代码进行抽取（封闭）思想.

*  #### 抽取代码 ####
    
        public static void fire() {
              
            System.out.println("准备发射5发炮弹");
            System.out.println("发射第1发炮弹* * * *");
            System.out.println("发射第2发炮弹* * * *");
            System.out.println("发射第3发炮弹* * * *");
            System.out.println("发射第4发炮弹* * * *");
            System.out.println("发射第5发炮弹* * * *");
            System.out.println("发射5发炮弹结束");
        }
 *  #### 在main方法中使用 ####
    
        public static void main(String[] args) {
              
            System.out.println("游戏开始...");
            System.out.println("看到了一个怪物...血牙野猪...");
            //调用方法,发射炮弹
            fire();
            System.out.println("...血牙野猪被打倒...");
        }
 *  ##### 调用格式 #####
    
        方法名();
 *  ##### 注意 #####
    
     *  ###### 方法必须先创建才可以使用，该过程成为方法定义 ######
     *  ###### 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用 ######

### 方法调用过程图解 ###

![在这里插入图片描述][babf1404473642bcbc1aaa24f9000d74.png_pic_center]

### 定义方法格式 ###

修饰符 返回值类型 方法名(参数列表){
        
        //代码省略... 
        return 结果; 
    }

*  ###### `修饰符`： public static 目前固定写法 ######
 *  ###### `返回值类型`： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者 ######
 *  ###### `参数列表`： 方法在运算过程中的未知数据，调用者调用方法时传递 ######
 *  ###### `return`： 将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束 ######

> 小贴士：return 结束; 这里的结束在开发中，我们正确的叫法成为**方法的返回值**

## 二.方法类型 ##

### 定义方法的两个明确 ###

*  ##### 明确参数列表 #####
    
    > 该方法在完成一个功能时，需要的参数有几个，参数的类型是什么，需要在我们明确给出的。
 *  ##### 明确返回值类型 #####
    
    > 方法的功能完成之后，是否有结果返回，如果有，使用return 将结果返回给调用者。没有返回值void
    > 
    > 什么情况下，我们用return, 除了void以外的都要有return

### 案例一 ###

*  #### 需求 ####
    
    > 在控制台打印10次HelloWorld
 *  #### 分析 ####
    
     *  ##### 明确参数列表 #####
        
        > 方法中打印出 HelloWorld 即可，没有计算结果，返回值类型 void
     *  ##### 明确返回值 #####
        
        > 打印几次已经明确规定10次，参数不需要定义
 *  #### 代码实现 ####
    
        public class MethodDemo01 {
              
            public static void main(String[] args) {
              
                //调用方法printHelloWorld打印10次HelloWorld
                printHelloWorld();
            }
        
            public static void printHelloWorld() {
                     
                for (int i = 0; i < 10; i++) {
              
                    System.out.println("HelloWorld");
                }
            }
        }

### 案例二 ###

*  #### 需求 ####
    
    > 实现不定次数打印HelloWorld
 *  #### 分析 ####
    
     *  ##### 明确参数列表 #####
        
        > 方法中打印出 HelloWorld 即可，没有计算结果，返回值类型 void
     *  ##### 明确返回值 #####
        
        > 打印几次不清楚，参数定义一个整型参数
 *  #### 代码实现 ####
    
        public class MethodDemo02 {
              
            public static void main(String[] args) {
              
                //调用方法printHelloWorld，传递整数
                printHelloWorld(10);
            }
        
         	/*
                定义打印HelloWorld方法
                返回值类型，计算没有结果 void
                参数：不确定打印几次
            */
            public static void printHelloWorld(int n) {
                      
                for (int i = 0; i < n; i++) {
              
                    System.out.println("HelloWorld");
                }
            }
        }

### 案例三 ###

*  #### 需求 ####
    
    > 定义方法实现两个整数的求和计算
 *  #### 分析 ####
    
     *  ##### 明确参数列表 #####
        
        > 计算哪两个整数的和，并不清楚，但可以确定是整数，参数列表可以定义两个int类型的
        > 
        > 变量，由调用者调用方法时传递
     *  ##### 明确返回值 #####
        
        > 方法计算的是整数的求和，结果也必然是个整数，返回值类型定义为int类型。
 *  #### 代码实现 ####
    
        public class MethodDemo03 {
              
            public static void main(String[] args) {
              
                // 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数        
                // 并接收方法计算后的结果，返回值     
                int sum = getSum(5, 6);
                System.out.println(sum);
            }
         
            /*
                定义计算两个整数和的方法
                返回值类型，计算结果是int
                参数：不确定数据求和，定义int参数.参数又称为形式参数
            */
            public static int getSum(int a, int b) {
              
                return a + b;
            }
        }
 *  #### 流程图解 ####

![在这里插入图片描述][0cd0598eb9804920892fdefce839a4bb.png_pic_center]

### 案例四 ###

*  ##### 需求 #####
    
    > **定义方法实现比较两个整数是否相同**
 *  ##### 分析 #####
    
     *  ###### 明确参数列表 ######
        
        > 比较的两个整数不确定，所以默认定义两个int类型的参数。
     *  ###### 明确返回值 ######
        
        > 比较整数，比较的结果只有两种可能，相同或不同，因此结果是布尔类型，比较的结果相
        > 
        > 同为true。
 *  ##### 代码实现 #####
    
        public class MethodDemo04 {
              
            public static void main(String[] args) {
              
                //调用方法compare，传递两个整数
                //并接收方法计算后的结果，布尔值
                boolean bool = compare(3, 8);
                System.out.println(bool);
            }
         
            /*
                定义比较两个整数是否相同的方法
                返回值类型，比较的结果布尔类型
                参数：不确定参与比较的两个整数
            */
            public static boolean compare(int a, int b) {
                     
                if (a == b) {
              
                    return true;
                } else {
              
                    return false;
                }
            }
        }

### 案例五 ###

*  ##### 需求 #####
    
    > 定义方法实现:计算1+2+3…+100的和
 *  ##### 分析 #####
    
     *  ###### 明确参数列表 ######
        
        > 需求中已知到计算的数据，没有未知的数据，不定义参数
     *  ###### 明确返回值 ######
        
        > 1~100的求和，计算后必然还是整数，返回值类型是int
 *  ##### 代码实现 #####
    
        public class MethodDemo05 {
              
            public static void main(String[] args) {
                      
                //调用方法getSum
                //并接收方法计算后的结果，整数
                int sum = getSum();
                System.out.println(sum);
            }
        
            /*
                定义计算1~100的求和方法
                返回值类型，计算结果整数int
                参数：没有不确定数据
            */
            public static int getSum() {
              
                //定义变量保存求和
                int sum = 0;
                //从1开始循环，到100结束
                for (int i = 1; i <= 100; i++) {
                         
                    sum = sum + i;
                }
                return sum;
            }
        }

TODO: 无参无返回值的方法 无参有返回值的方法

有参无返回值的方法 有参有返回值的方法

试着去写返回值类型各种情况， 试着去写参数列表的各种数据类型

## 三.方法小结 ##

### 定义方法注意事项 ###

*  ###### 定义位置：类中方法外，不能嵌套定义 ######
 *  ###### 方法必须先定义，再使用 ######
 *  ###### void表示无返回值,可以省略return,也可以单独的书写return ######
 *  ###### 不能在return后面写代码，return意味着方法结束，所有后面的代码记永远都不会执行，属于无效代码 ######
 *  ###### 定义方法时()中的参数，我们称之为：形式参数，在调用该方法时传递的参数，我们称之为：实际参数 ######
 *  你可以不接收返回的值，但你必须给出参数

### 调用方法三种形式 ###

*  ###### `直接调用`：直接写方法名调用 ######
    
        public static void main(String[] args) {
                  
            print();
        }
        public static void print() {
              
            System.out.println("方法被调用");
        }
 *  ###### `赋值调用`：调用方法，在方法前面定义变量，接收方法返回值 ######
    
        public static void main(String[] args) {
                  
            int sum = getSum(5,6);
            System.out.println(sum);
        }
        public static int getSum(int a,int b) {
              
            return a + b;
        }
 *  ###### `输出语句调用`：在输出语句中调用方法 ######
    
        public static void main(String[] args) {
                  
            System.out.println(getSum(5,6));
        }
        public static int getSum(int a,int b) {
              
            return a + b;
        }
    
     *  ##### 注意事项 #####
        
        > 不能用输出语句调用void无返回值类型的方法。因为方法执行后没有结果，也就打印不出任何内容
        
            public static void main(String[] args) {
                    
                // 错误，不能输出语句调用void类型方法
                System.out.println(printHello());
            }
            public static void printHello() {
                    
                System.out.println("Hello");
            }

## 四.重载 ##

### 4.1方法重载概述 ###

> 在同一个类中，具有相同的方法名， 参数列表不同（参数的个数及类型不同），与返回值无关
> 
> 参数列表：个数不同，数据类型不同，顺序不同。
> 
> 重载方法调用：JVM通过方法的参数列表，调用不同的方法。

*  ###### 注意事项 ######
    
        * 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
        * 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

### 4.2重载案例 ###

#### 案例一 ####

*  ##### 需求 #####
    
    > 使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
 *  ##### 思路 #####
    
    > ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
    > 
    > ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
    > 
    > ③定义所有的重载方法，两个byte类型与两个short类型参数
    > 
    > ④完成方法的调用，测试运行结果
 *  ##### 代码实现 #####
    
        public class MethodTest1 {
              
            public static void main(String[] args) {
              
                //调用方法
                System.out.println(compare(10, 20));
                System.out.println(compare((byte) 10, (byte) 20));
                System.out.println(compare((short) 10, (short) 20));
                System.out.println(compare(10L, 20L));
            }
        
            //int
            public static boolean compare(int a, int b) {
              
                System.out.println("int");
                return a == b;
            }
        
            //byte
            public static boolean compare(byte a, byte b) {
              
                System.out.println("byte");
                return a == b;
            }
        
            //short
            public static boolean compare(short a, short b) {
              
                System.out.println("short");
                return a == b;
            }
        
            //long
            public static boolean compare(long a, long b) {
              
                System.out.println("long");
                return a == b;
            }
        
        }

#### 案例二 ####

> 判断哪些方法是重载关系

public static void open(){
        }
    public static void open(int a){
        }
    public static void open(int a,int b){
        }
    public static void open(double a,int b){
        }
    public static void open(int a,double b){
        }
    public void open(int i,double d){
        }
    public static void OPEN(){
        }
    public static void open(int i,int j){
        }

#### 案例三 ####

*  #### 需求 ####
    
    > 模拟输出语句中的println方法的效果，传递什么类型的数据就输出什么类型的数据，只允许定义一个方法名println
 *  #### 代码实现 ####
    
        public class MethodTest2 {
              
            public static void println(byte a) {
              
                System.out.println(a);
            }
         
            public static void println(short a) {
              
                System.out.println(a);
            }
         
            public static void println(int a) {
              
                System.out.println(a);
            }
         
            public static void println(long a) {
              
                System.out.println(a);
            }
         
            public static void println(float a) {
              
                System.out.println(a);
            }
         
            public static void println(double a) {
                      
                System.out.println(a);
            }
         
            public static void println(char a) {
              
                System.out.println(a);
            }
         
            public static void println(boolean a) {
                     
                System.out.println(a);
            }
         
            public static void println(String a) {
                      
                System.out.println(a);
            }
        }

## 五.参数传递 ##

### 方法参数传递基本类型 ###

*  ##### 测试代码： #####
    
        public class ArgsDemo01 {
              
            public static void main(String[] args) {
              
                //实际参数
                int number = 100;
                System.out.println("调用change方法前：" + number);
                //调用方法
                change(number);
                System.out.println("调用change方法后：" + number);
            }
        
            //形式参数
            public static void change(int number) {
              
                number = 200;
            }
        }
 *  ##### 结论： #####
    
    > 基本数据类型的参数，形式参数的改变，不影响实际参数
 *  ##### 结论依据： #####
    
    > 每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

![在这里插入图片描述][327603c723244481ac041266435bfbb5.png_pic_center]

### 方法参数传递引用类型 ###

*  ##### 测试代码 #####
    
        public class ArgsDemo02 {
              
            public static void main(String[] args) {
              
                int[] arr = {
              10, 20, 30};
                System.out.println("调用change方法前：" + arr[1]);//20
                
                change(arr);
                System.out.println("调用change方法后：" + arr[1]);//200
            }
        
            public static void change(int[] arr) {
              
                arr[1] = 200;
            }
        }
 *  ##### 结论 #####
    
    > 对于引用类型的参数，形式参数的改变，影响实际参数的值
 *  ##### 结论依据 #####
    
    > 引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果

![在这里插入图片描述][e6e4e5720db84e3bab690ad7afe4cc03.png_pic_center]

### 数组遍历 ###

*  ##### 需求 #####
    
    > 设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：\[11, 22, 33, 44, 55\]
 *  ##### 思路 #####
    
    > 1.  因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);  
    >     System.out.println(“内容”); 输出内容并换行  
    >     System.out.print(“内容”); 输出内容不换行  
    >     System.out.println(); 起到换行的作用
    > 2.  定义一个数组，用静态初始化完成数组元素初始化
    > 3.  定义一个方法，用数组遍历通用格式对数组进行遍历
    > 4.  用新的输出语句修改遍历操作
    > 5.  调用遍历方法
 *  ##### 代码实现 #####
    
        public class MethodTest3 {
              
            public static void main(String[] args) {
              
                //定义一个数组，用静态初始化完成数组元素初始化
                int[] arr = {
              11, 22, 33, 44, 55};
        
                //调用方法
                printArray(arr);
            }
        
            // 定义一个方法，用数组遍历通用格式对数组进行遍历
            /*
                两个明确：
                    返回值类型：void
                    参数：int[] arr
             */
            public static void printArray(int[] arr) {
              
                System.out.print("[");
                for(int x=0; x<arr.length; x++) {
              
                    if(x == arr.length-1) {
              
                        System.out.print(arr[x]);
                    } else {
              
                        System.out.print(arr[x]+", ");
                    }
                }
                System.out.println("]");
            }
        }

### 数组最大值 ###

*  ##### 需求 #####
    
    > 设计一个方法用于获取数组中元素的最大值
 *  ##### 思路 #####
    
    > ① 定义一个数组，用静态初始化完成数组元素初始化
    > 
    > ② 定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了
    > 
    > ③ 调用获取最大值方法，用变量接收返回结果
    > 
    > ④ 把结果输出在控制台
 *  ##### 代码实现 #####
    
        public class MethodTest02 {
              
            public static void main(String[] args) {
              
                //定义一个数组，用静态初始化完成数组元素初始化
                int[] arr = {
              12, 45, 98, 73, 60};
        
                //调用获取最大值方法，用变量接收返回结果
                int number = getMax(arr);
        
                //把结果输出在控制台
                System.out.println("number:" + number);
            }
        
            //定义一个方法，用来获取数组中的最大值
            /*
                两个明确：
                    返回值类型：int
                    参数：int[] arr
             */
            public static int getMax(int[] arr) {
              
                int max = arr[0];
        
                for(int x=1; x<arr.length; x++) {
              
                    if(arr[x] > max) {
              
                        max = arr[x];
                    }
                }
                return max;
            }
        }

## 六.递归 ##

### 什么是递归 ###

> 指在当前方法内调用自己的这种现象。
> 
> 从前有座山，山里有座庙，庙里有一个老和尚和一个小和尚。。。。。。
> 
> 你为什么要放羊，为了娶媳妇，娶媳妇干什么，为了生娃娃。。。。。。

### 递归的分类 ###

> 递归分为两种，直接递归 和 间接递归。

*  ###### 直接递归：称为方法自身调用自己。A方法调用B方法B方法调用A方法… ######
 *  ###### 间接递归：可以A方法调用B方法，B方法调用C方法，C方法调用A方法。 ######

### 递归的注意事项 ###

*  ###### 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。 ######
 *  ###### 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。 ######
 *  ###### 构造方法,禁止递归 ######
    
        package cn.yanqi_02;
        
        public class Demo01DiGui {
              
        
            /*
             * 3.构造方法,禁止递归
             * 编译报错:构造方法是创建对象使用的,不能让对象一直创建下去
             */
            public Demo01DiGui() {
              
                //Demo01DiGui();
            }
        
            public static void main(String[] args) {
              
                show1();
                // show2(1);
            }
        
            /*
             * 2.在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
             * 4993
             * 	Exception in thread "main" java.lang.StackOverflowError
             */
            private static void show2(int i) {
              
                System.out.println(i);
                //添加一个递归结束的条件,i==5000的时候结束
                if(i==5000){
              
                    return;//结束方法
                }
                show2(++i);
            }
        
            /*
             * 1.递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。 Exception in thread "main"
             * java.lang.StackOverflowError
             */
            private static void show1() {
              
                System.out.println("a方法");
                show1();
            }
        }

### 递归累加求和 ###

*  ###### 需求 ######
    
    > 计算1 ~ n的和
 *  ###### 分析 ######
    
    > num的累和 = num + (num-1)的累和，所以可以把累和的操作定义成一个方法，递归调用。
 *  ###### 代码实现 ######
    
        public class DiGuiDemo {
              
        	public static void main(String[] args) {
              
        		//计算1~num的和，使用递归完成
        		int num = 5;
              	// 调用求和的方法
        		int sum = getSum(num);
              	// 输出结果
        		System.out.println(sum);		
        	}
          	/*
          	  通过递归算法实现.
          	  参数列表:int 
          	  返回值类型: int 
          	*/
        	public static int getSum(int num) {
              
              	/* 
              	   num为1时,方法返回1,
              	   相当于是方法的出口,num总有是1的情况
              	*/
        		if(num == 1){
              
        			return 1;
        		}
              	/*
                  num不为1时,方法返回 num +(num-1)的累和
                  递归调用getSum方法
                */
        		int gs = getSum(num-1);
                return num + gs;
        	}
        }

![在这里插入图片描述][9434a329992f4092b753ffa021b512e3.png_pic_center]

### 递归求阶乘 ###

*  ###### 什么是阶乘 ######
    
    > 所有小于及等于该数的正整数的积。
    > 
    > 使用递归求5的阶乘
    > 
    >     5！ = 5 * 4 * 3 * 2 * 1
    >         5! = 5 * 4!
    >             4! = 4 * 3!
    >                 3! = 3 * 2!
    >                     2! = 2 * 1!
    >                         1! = 1
    >     
    >     求n的阶乘
    >         n * (n - 1)!
 *  ###### 求N阶乘公式 ######
    
    > n! = n \* (n-1) *…* 3 \* 2 \* 1
 *  ###### 分析 ######
    
    > 这与累和类似,只不过换成了乘法运算，学员可以自己练习，需要注意阶乘值符合int类型的范围。
    > 
    > 推理得出：n! = n \* (n-1)!
 *  ###### 代码实现 ######
    
        public class DiGuiDemo {
              
          	//计算n的阶乘，使用递归完成
            public static void main(String[] args) {
              
                int n = 3;
              	// 调用求阶乘的方法
                int value = getValue(n);
              	// 输出结果
                System.out.println("阶乘为:"+ value);
            }
        	/*
          	  通过递归算法实现.
          	  参数列表:int 
          	  返回值类型: int 
          	*/
            public static int getValue(int n) {
              
              	// 1的阶乘为1
                if (n == 1) {
              
                    return 1;
                }
              	/*
              	  n不为1时,方法返回 n! = n*(n-1)!
                  递归调用getValue方法
              	*/
                return n * getValue(n - 1);
            }
        }

>     1! = 1
> 
> 求n的阶乘  
> n \* (n - 1)!

*  ###### 求N阶乘公式 ######
    
    > n! = n \* (n-1) *…* 3 \* 2 \* 1
 *  ###### 分析 ######
    
    > 这与累和类似,只不过换成了乘法运算，学员可以自己练习，需要注意阶乘值符合int类型的范围。
    > 
    > 推理得出：n! = n \* (n-1)!
 *  ###### 代码实现 ######
    
        public class DiGuiDemo {
              
          	//计算n的阶乘，使用递归完成
            public static void main(String[] args) {
              
                int n = 3;
              	// 调用求阶乘的方法
                int value = getValue(n);
              	// 输出结果
                System.out.println("阶乘为:"+ value);
            }
        	/*
          	  通过递归算法实现.
          	  参数列表:int 
          	  返回值类型: int 
          	*/
            public static int getValue(int n) {
              
              	// 1的阶乘为1
                if (n == 1) {
              
                    return 1;
                }
              	/*
              	  n不为1时,方法返回 n! = n*(n-1)!
                  递归调用getValue方法
              	*/
                return n * getValue(n - 1);
            }
        }

![在这里插入图片描述][3a5ad927211e44358c8eed5e114e4fb2.png_pic_center]

[babf1404473642bcbc1aaa24f9000d74.png_pic_center]: https://img-blog.csdnimg.cn/babf1404473642bcbc1aaa24f9000d74.png#pic_center
[0cd0598eb9804920892fdefce839a4bb.png_pic_center]: https://img-blog.csdnimg.cn/0cd0598eb9804920892fdefce839a4bb.png#pic_center
[327603c723244481ac041266435bfbb5.png_pic_center]: https://img-blog.csdnimg.cn/327603c723244481ac041266435bfbb5.png#pic_center
[e6e4e5720db84e3bab690ad7afe4cc03.png_pic_center]: https://img-blog.csdnimg.cn/e6e4e5720db84e3bab690ad7afe4cc03.png#pic_center
[9434a329992f4092b753ffa021b512e3.png_pic_center]: https://img-blog.csdnimg.cn/9434a329992f4092b753ffa021b512e3.png#pic_center
[3a5ad927211e44358c8eed5e114e4fb2.png_pic_center]: https://img-blog.csdnimg.cn/3a5ad927211e44358c8eed5e114e4fb2.png#pic_center