演示下方法的使用-重要

把程序分成两个文件，一个只管 “喊人干活”（主程序），一个只管 “实际干活”（方法类），主程序通过创建对象去调用方法类里的功能。

下面这个是主程序+方法是2个类文件组成的

【目标】主程序 + 副方法（两个类）

- 主程序：负责输入内容、调用方法

- 方法类：根据输入内容，执行不同的输出

输入 *或者 # → 打印对应的三角形图案
*                       #
**                     ##
***                   ###

输入 SYE → 输出问候语“你好吗SYE!”

主程序
package dey9;
import dey9.TestMethod;
import java.util.Scanner;
// 主程序类
public class TestMain {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入：");
        String content = scanner.next();
        // 1. 创建工具类对象
        TestMethod method = new TestMethod();
//TestMethod → 找到你另建的那个类文件
//method → 给这个工具起个名字
//new TestMethod() → 造出真实可用的对象


//有了对象，才能用里面的 run () 方法

method.run("*");

        // 2. 主程序 调用 另一个类的方法
        method.run(content);
//content 输入什么内容，method 这个员工对象，就会依照 run 方法的规则，执行对应操作
    }
}

调用方法
package dey9;
public class TestMethod {
    // 这是被调用的方法
    public void run(String str) {
        if (str.equals("*") || str.equals("#")) {
//.equals() → String 专属自带方法  用来比对是否属于一样的东西
            for (int i = 1; i <= 3; i++) {
                for (int j = 1; j <= i; j++) {
                    System.out.print(str);
                }
                System.out.println();
            }
        } else if (str.equals("SYE")) {
            System.out.println("你好吗SYE!");
        }
    }
}

小标题：三类方法参数区别总结

1. 无参方法：括号为空，无需传入任何数据
2. 单参方法：仅传入自定义内容，控制输出文字
3. 双参方法：同时传入内容 + 行数，双重自定义控制

{主程序-交互版}

package dey10;
import java.util.Scanner; // 键盘输入必须写这个
public class testFang {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); // 创建输入工具
        testFa fa = new testFa(); // 创建对象
        // 1. 调用无参方法
        System.out.println("=== 1. 调用无参方法 ===");
        fa.show();
        System.out.println("------------------------");

        // 2. 让你自己输入内容
        System.out.println("=== 2. 请输入要打印的内容 ===");
        String content = sc.nextLine(); // 键盘输入
        fa.printContent(content);
        System.out.println("------------------------");

        // 3. 输入内容 + 输入行数
        System.out.println("=== 3. 请输入内容 + 打印行数 ===");
        System.out.print("请输入内容：");
        String c = sc.nextLine();
        System.out.print("请输入行数：");
        int line = sc.nextInt();

        fa.printLine(c, line);
    }
}

{副程序-方法}

package dey10;
// 这个类专门放：你自己写的3个方法
public class testFa {
    // 1. 无参方法（什么都不用传，直接运行）
    public void show() {
        System.out.println("我是无参方法！");
        System.out.println("直接调用就能运行");
    }
    // 2. 控制内容的方法（传什么，打印什么）
    public void printContent(String content) {
        System.out.println("你传入的内容是：" + content);
    }
    // 3. 既控制内容、又控制行数的方法
    public void printLine(String content, int line) {
        // 循环 line 次，打印 content
        for (int i = 1; i <= line; i++) {
            System.out.println("第" + i + "行：" + content);
        }
    }
}

[输出结果]

=== 1. 调用无参方法 ===
我是无参方法！
直接调用就能运行
------------------------
=== 2. 请输入要打印的内容 ===
6
你传入的内容是：6
------------------------
=== 3. 请输入内容 + 打印行数 ===
请输入内容：8
请输入行数：9
第1行：8
第2行：8
第3行：8
第4行：8
第5行：8
第6行：8
第7行：8
第8行：8
第9行：8

进程已结束，退出代码为 0

小标题：方法重载

{主程序-重载}

package dey10;
import java.util.Scanner;

// 主程序 交互版
public class testFangC {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 创建对象
        testFaZ faZ = new testFaZ();
//testFaZ → 找到你另建的那个类文件
//faZ → 给这个工具起个名字
//new testFaZ() → 造出真实可用的对象
我输入testFaZ是为了找到我要调取testFaZ这个类在哪里，因为里面我写了很多方法，我先整体给把这么多方法取名叫faZ 的对象。然后=赋值的意思，new这个就是新造的意思，然后我又输入testFaZ这个类的名字后面跟一给（）意思就是“现在我把新建的new testFaZ（）这个类中所有的方法交给faZ来管理。
        // 1.调用 无参重载方法（不用输入）
        faZ.print();
        
        // 2.调用 单参重载方法 【交互输入内容】
        System.out.print("\n请输入要打印的内容：");
        String msg = sc.nextLine();
        faZ.print(msg);

        // 3.调用 双参重载方法 【输入内容+行数】
        System.out.print("\n请再次输入自定义内容：");
        String word = sc.nextLine();
        System.out.print("请输入打印行数：");
        int num = sc.nextInt();
        faZ.print(word, num);

主程序你String了 word这个变量

副程序中接收也必须是 String

接收的也必须是String接收

副程序你String了content这个变量

int同理

你传几个参数、是什么类型，Java 自动匹配、自动调用 对应那一个重载方法。

{副程序-方法重载}

package dey10;
// 方法类：全部同名 print 实现【方法重载】
public class testFaZ {
    // 重载1：无参方法
    public void print() {
        System.out.println("==== 无参默认输出 ====");
        System.out.println("好好学习Java");
    }
    // 重载2：单个参数 → 只控制内容
    public void print(String content) {
        System.out.println("==== 自定义内容输出 ====");
        System.out.println(content);
    }
    // 重载3：两个参数 → 控制内容 + 控制行数
    public void print(String content, int row) {
        System.out.println("==== 内容+行数自定义 ====");
        for (int i = 1; i <= row; i++) {
            System.out.println("第" + i + "行：" + content);
        }
    }
}

1. 先记住核心

变量名字 不需要一样！只看：顺序、类型 必须对上，名字随便起

---

2. 一对一精准对应

主程序（传出去的）

String word = "你输入的文字";
int num = 3;

faZ.print(word , num);

• 第 1 个实参：word 👉 类型：String 字符串
• 第 2 个实参：num 👉 类型：int 整数

方法类（接收进来的）

public void print(String content , int row){

• 第 1 个形参：content 👉 类型：String
• 第 2 个形参：row 👉 类型：int

---

3. 箭头精准绑定（只看顺序）

faZ.print(   word   ,   num   );
               ↓          ↓
print(     content  ,    row   );

• word 里面的文字，赋值传给 content
• num 里面的数字，赋值传给 row

---

4. 举个生活例子秒懂

你：递过去【一袋苹果】（word）我：用【水果盒】（content）接住苹果

你传几个参数、是什么类型，Java 自动匹配、自动调用 对应那一个重载方法。

1. 你不传任何参数

faZ.print();

👉 自动找：空参那个

public void print()

2. 你只传 一个 String 参数

faZ.print(word); // word 是 String

👉 自动找：刚好一个 String 参数的那个

public void print(String content)

3. 你传 一个 String + 一个 int 两个参数

faZ.print(word, num); // String + int

👉 自动找：String + int 两个参数的那个

public void print(String content, int row)

 数组排序

排序算法
    冒泡排序，选择排序，希尔排序，快速排序
    
冒泡排序
    一个数组5个元素
    第一轮，4次两两比较
        if(a[0]>a[1]){交换}
        if(a[1]>a[2]){交换}
        if(a[2]>a[3]){交换}
        if(a[3]>a[4]){交换}
    第二轮，3次两两比较
        if(a[0]>a[1]){交换}
        if(a[1]>a[2]){交换}
        if(a[2]>a[3]){交换}
    第三轮，2次两两比较
        if(a[0]>a[1]){交换}
        if(a[1]>a[2]){交换}
    第四轮，1次两两比较
        if(a[0]>a[1]){交换}
        
    for(int i=0;i<a.length-1;i++){
        for(int j=0;j<a.length-1-i;j++){
            if(a[j]>a[j+1]){
                //交换
            }
        }
    }   

二维数组

一维数组 vs 二维数组（大白话 + 超好记）

一、概念区别

1. 一维数组只有一排数据，一条直线。格式：int[] arr

2. 比喻：一行排队、一排柜子

3. 二维数组有多行多列，是数组里面装数组，像表格。格式：int[][] arr

4. 比喻：教室座位、Excel 表格、多排柜子

二、写法对比

一维

int[] a = {10,20,30};

二维

int[][] b = {{1,2},{3,4},{5,6}};

---

三、取值格式

1. 一维：数组名[下标]
2. 二维：数组名[行下标][列下标]
3. 一维：单层 for 循环
4. 二维：双层 for 循环外层循环控制「行」，内层循环控制「列」
5. 维度不同：一维是线，二维是面
6. 结构不同：一维存普通数据，二维存多个一维数组
7. 用法不同：
   • 一维：存简单一组数据（成绩、名字）
   • 二维：存表格型数据（班级学生成绩、地图、座位表）
8. 长度获取：
   • 一维：arr.length
   • 二维：总行数arr.length，当前行长度arr[i].length

四、方法

System.out.println();
scanner.nextInt();
Math.random();
Arrays.toString();
Arrays.sort();
​
将一段完整功能的逻辑代码定义成一个方法。
以后需要使用相同的功能，不需要重复些这段代码，只需要调用方法
​
方法就是一个功能，一个操作，一个行为。就是一段逻辑代码
    定义方法
    调用方法
    
定义方法的语法
    访问修饰符 返回值类型 方法名(参数列表){
        //方法体
    }
    
    访问修饰符:
        Java中有四种，今天就用pulbic 
    返回值类型:
        方法执行结束以后，可以返回给用户一个数据
        也可以没有返回值void,返回值最多一个
    方法名:
        就是给方法起个名字
        语法规则和变量命名规则相同
        命名规范:
            见名知意
            小驼峰
    参数：
        参与操作的数据
        任意：可以没有，可以1个，可以多个
    方法体：    
        方法实现特定功能的逻辑代码 

没有参数也没有返回值的方法

public void 方法名(){
    //方法体
}

参数

参数就是参与操作的数据

形式参数：定义方法的参数
实际参数：调用方法的参数
​
调用方法时，如果有参数，实参给形参赋值
单向传递：实参给形参赋值，方法调用结束，形参不会给实参赋值

断点调试

添加断点
启用调试
step over   单步跳过
step into   单步进入
resume      如果后面没有断点，执行所有的代码；如果后面有断点，执行到下一个断点出
step out    单步跳出

作业

1、数组删除元素
2、实现冒泡排序