05_java基础

一、课程目标

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

二、方法概述

2.1 什么是方法

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

2.2 方法基本使用

将资料中给大家提供的打怪物发射炮弹重复的代码，抽取到方法中并使用

抽取代码

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("...血牙野猪被打倒...");
}

调用格式
```
方法名();
```
注意
- 方法必须先创建才可以使用，该过程成为方法定义
- 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

2.3 方法调用过程图解

在这里插入图片描述

2.4 定义方法格式

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

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

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

三、方法案例

3.1 定义方法的两个明确

明确参数列表

该方法在完成一个功能时，需要的参数有几个，参数的类型是什么，需要在我们明确给出的。
明确返回值类型

方法的功能完成之后，是否有结果返回，如果有，使用return 将结果返回给调用者。

3.2 案例一

需求

在控制台打印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");
        }
    }
}

3.3 案例二

需求

实现不定次数打印HelloWorld
分析
- 明确参数列表
  
  方法中打印出 HelloWorld 即可，没有计算结果，返回值类型 void
- 明确返回值
  
  打印几次不清楚，参数定义一个整型参数

代码实现

public class MethodDemo02 {
      
      
    public static void main(String[] args) {
      
      
        //调用方法printHelloWorld，传递整数
        printHelloWorld();
    }

 	/*
        定义打印HelloWorld方法
        返回值类型，计算没有结果 void
        参数：不确定打印几次
    */
    public static void printHelloWorld(int n) {
      
              
        for (int i = 0; i < n; i++) {
      
      
            System.out.println("HelloWorld");
        }
    }
}

3.4 案例三

需求

定义方法实现两个整数的求和计算
分析
- 明确参数列表
  
  计算哪两个整数的和，并不清楚，但可以确定是整数，参数列表可以定义两个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;
    }
}

流程图解

在这里插入图片描述

3.5 案例四

需求

定义方法实现比较两个整数是否相同
分析
- 明确参数列表
  
  比较的两个整数不确定，所以默认定义两个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;
        }
    }
}

3.6 案例五

需求

定义方法实现:计算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;
    }
}

四、方法小结

4.1 定义方法注意事项

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

4.2 调用方法三种形式

`直接调用`：直接写方法名调用

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");
    }

五、方法重载

5.1 方法重载概述

指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返

回值类型无关。

参数列表：个数不同，数据类型不同，顺序不同。

重载方法调用：JVM通过方法的参数列表，调用不同的方法。

注意事项

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

5.2 方法重载案例

5.2.1 案例一

需求

使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（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;
    }

}

5.2.2 案例二

判断哪些方法是重载关系

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){
    
    }

5.2.3 案例三

需求

模拟输出语句中的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);
    }
}

六、方法的参数传递

6.1 方法参数传递基本类型

测试代码：

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;
    }
}

结论：

基本数据类型的参数，形式参数的改变，不影响实际参数
结论依据：

每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

在这里插入图片描述

6.2 方法参数传递引用类型

测试代码

public class ArgsDemo02 {
      
      
    public static void main(String[] args) {
      
      
        int[] arr = {
      
      10, 20, 30};
        System.out.println("调用change方法前：" + arr[1]);
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);
    }

    public static void change(int[] arr) {
      
      
        arr[1] = 200;
    }
}

结论

对于引用类型的参数，形式参数的改变，影响实际参数的值
结论依据

引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果

在这里插入图片描述

6.3 数组遍历

需求

设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[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("]");
    }
}

6.4 数组最大值

需求

设计一个方法用于获取数组中元素的最大值
思路

① 定义一个数组，用静态初始化完成数组元素初始化

② 定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了

③ 调用获取最大值方法，用变量接收返回结果

④ 把结果输出在控制台
代码实现

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;
    }
}

05_java基础

05_java基础

一、课程目标

二、方法概述

2.1 什么是方法

2.2 方法基本使用

抽取代码

在main方法中使用

调用格式

注意

方法必须先创建才可以使用，该过程成为方法定义

方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

2.3 方法调用过程图解

2.4 定义方法格式

修饰符： public static固定写法

返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者

参数列表： 方法在运算过程中的未知数据，调用者调用方法时传递

return： 将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束

三、方法案例

3.1 定义方法的两个明确

明确参数列表

明确返回值类型

3.2 案例一

需求

分析

明确参数列表

明确返回值

代码实现

3.3 案例二

需求

分析

明确参数列表

明确返回值

代码实现

3.4 案例三

需求

分析

明确参数列表

明确返回值

代码实现

流程图解

3.5 案例四

需求

分析

明确参数列表

明确返回值

代码实现

3.6 案例五

需求

分析

明确参数列表

明确返回值

代码实现

四、方法小结

4.1 定义方法注意事项

定义位置：类中方法外，不能嵌套定义

方法必须先定义，再使用

void表示无返回值,可以省略return,也可以单独的书写return

不能在return后面写代码，return意味着方法结束，所有后面的代码记永远都不会执行，属于无效代码

定义方法时()中的参数，我们称之为：形式参数，在调用该方法时传递的参数，我们称之为：实际参数

4.2 调用方法三种形式

直接调用：直接写方法名调用

赋值调用：调用方法，在方法前面定义变量，接收方法返回值

输出语句调用：在输出语句中调用方法

注意事项

五、方法重载

5.1 方法重载概述

注意事项

5.2 方法重载案例

5.2.1 案例一

需求

思路

代码实现

5.2.2 案例二

5.2.3 案例三

需求

代码实现

六、方法的参数传递

6.1 方法参数传递基本类型

测试代码：

`修饰符`： public static固定写法

`返回值类型`：表示方法运行的结果的数据类型，方法执行后将结果返回到调用者

`参数列表`：方法在运算过程中的未知数据，调用者调用方法时传递

`return`：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束

`直接调用`：直接写方法名调用

`赋值调用`：调用方法，在方法前面定义变量，接收方法返回值

`输出语句调用`：在输出语句中调用方法