day07_方法_数组

今日内容

零、 复习昨日
一、作业讲解
二、方法[重点]
三、数组（一）

零、 复习昨日

while和dowhile的区别

• while先判断
• do-while先执行

for循环的执行流程,画图加叙述

break在循环中的作用

• 打断当前这一层循环,循环不再执行

单独return什么作用

• 在方法中使用,让当前方法返回,方法内return后的代码不再执行

英译汉
code 代码
count 计数
total 总计/共计/总共
statement 声明,语句
variable 变量,var
loop 循环
init 初始化

一、作业讲解

作业:1) 至少完成重复2遍 (60%) 2)txt文档(90%)  3)pdf再次加深,提升(150%)
package com.qf.homework;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @date 2024/1/23
 * @desc 作业
 */
public class Homework {

    public static void main(String[] args) {
        // 情况1: abcd单独拆开成每一个数
        // 编程找出四位整数abcd 中满足下述关系的数。
        // (ab+cd)(ab+cd)=abcd
        // 1234 = (1*2+3*4)(1*2+3*4) //得到每一位数字
        // for (int i = 1000; i < 10000; i++) { // 四位数
        //     int a = i / 1000;
        //     int b = i / 100 % 10;
        //     int c = i / 10 % 10;
        //     int d = i % 10;
        //     if ((a*b+c*d)*(a*b+c*d) == i) {
        //         System.out.println(i );
        //     }
        // }

        // System.out.println("------------" );

        // 情况2: abcd从中间拆开
        for (int abcd = 1000; abcd < 10000; abcd++) {
            // 1234
            int ab = abcd / 100;
            int cd = abcd % 100;
            // System.out.println("abcd = " + abcd  );
            // System.out.println("ab = " + ab  );
            // System.out.println("cd = " + cd  );
            if ((ab+cd)*(ab+cd) == abcd) {
                System.out.println(abcd );
            }
        }
    }
}

二、方法

2.1 介绍

什么是方法?

• 方法(method) 也叫做函数(function),是执行某个功能的一段代码.相对来说独立的代码片段.

为什么有方法?

• 以前写代码,写那些作业题,练习题,如果都写在一个类中,显得很多,此时大家就会注释一部分代码,… 这样就比较麻烦
• 总结没有方法时弊端: 1代码写一起太多太乱 2变量定义太多,又不能重复 3代码会重复

有方法的好处:

• 每个功能的代码 单独设计方法,独立出去
• 代码清晰明了,方便阅读
• 变量独立,互不影响
• 抽取成方法后,代码可以复用

方法写哪里?

方法怎么写?

方法如何执行?

2.2 方法写哪里?

• 方法要定义在类中
• 方法不能嵌套定义,方法和方法是平级的

2.3 方法怎么写?

其实我们一直用的main方法就是个方法,研究main如何编写

 public static void main(String[] args) {}
/*
1) public ,修饰符,意思是公共的,目前不要管,固定写法
2) static ,静态,目前不要管,固定写法
3) void ,意思是空, 这个位置(第三个位置)代表的方法返回值数据类型,
         void,空,即说明方法执行完不需要返回数据
         此处还可以其他数据类型,int,double,String等等
         但是如果不写void,写成别的类型,方法内需要加return+值;
4) main , 此处(第四位置),定义的方法名,名字是见名知意,驼峰原则
5) () , 参数列表, 参数就是方法 执行需要的数据
6) 括号内是定义的参数,即变量,可以定义多个,也可以不定义
7) {} 方法体,里面写方法具体内容
*/

public class Demo1 {

    public static void test(){
        System.out.println("演示方法" );
    }
}

2.4 方法如何执行

java代码有且只有一个入口,即代码只能通过main主方法执行,所有自己定义的方法,需要在main方法中调用

• 通过方法名+()调用

  public class Demo1 {
      // main方法是唯一入口
      public static void main(String[] args) {
          test();// 调用方法
      }
      // 定义方法(定义顺序没要求)
      public static void test(){
          System.out.println("演示方法" );
      }
    
  }
  

2.5 演示

2.5.1 无参无返回值方法

无参无返回值是指,方法的参数列表是空的(),返回值是空的写void,代码里面不能写return+值

ps: 经验,写题发现没有任何要求就可以定义无参无返回值的方法

package com.qf.method;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @date 2024/1/23
 * @desc
 */
public class Demo2 {

    public static void main(String[] args) {
        System.out.println("昔人已乘黄鹤去" );
        printLine();
        System.out.println("此地空余黄鹤楼" );
        printLine();
        System.out.println("黄鹤一去不复返" );
        printLine();
        System.out.println("白云千载空悠悠" );
        printLine();
        printSanjiaoxing();
    }

    /**
     * 什么时候需单独定义一个方法?
     * 1) 当你想要单独完成独立事情
     * 2) 当想要代码重复使用时
     */
    public static void printLine(){ // 空参空返回值 
        System.out.println("-----------" );
    }

    public static void printSanjiaoxing(){// 空参空返回值 
        for (int i = 1; i < 6; i++) {
            for (int j = 4; j >= i; j--) {
                System.out.print(" " );
            }
            for (int j = 1; j <= 2*i-1; j++) {
                System.out.print("*" );
            }
            System.out.println( );
        }
    }
}

2.5.2 有参无返回值方法

有参是指方法有参数

参数: 其实就是数据,需要使用变量来承载,所有参数写法就是声明变量,写在方法()内,例如(int a),这个a就称为参数a,可以写多个

作用: 参数是装数据的,是为了在方法 内用

好处: 方法有了参数,这个方法就会变得灵活多变,适应性强

public class Demo3 {
    public static void main(String[] args) {
        // 通过方法名+(值);
        // 方法有参数,调用时必须传参数(给方法参数变量赋值)
        printSjx(15);
    }
    // 定义方法,设计参数,实现打印 指定行 正三角形
    // 参数设计在()内,即定义变量
    public static void printSjx(int n){
        for (int i = 1; i <= n; i++) {
            for (int j = (n-1); j >= i; j--) {
                System.out.print(" " );
            }
            for (int j = 1; j <= 2*i-1; j++) {
                System.out.print("*" );
            }
            System.out.println( );
        }
    }
}

// 参数列表内可以写多个参数的,中间用逗号,隔开
    // 设计方法,模拟乘法运算,接收2个参数,输出结果
    public static void mult(int a,int b){
        System.out.println(a * b);
    }
    public static void main(String[] args) {

        // 调用的方法有多个参数,要按顺序依次传入(不能多,不能少)
        mult(3,2);
    }

   // 演示参数的类型和顺序
    public static void eat(int num, String food) {
        System.out.println("吃" + num + "份" + food);
    }

    public static void main(String[] args) {
        // 通过方法名+(值);
        // 方法有参数,调用时必须传参数(给方法参数变量赋值)
        // printSjx(15);

        // 调用的方法有多个参数,要按顺序依次传入(不能多,不能少)
        // mult(3, 2);
        eat(4,"醋");
    }

练习: 写一个函数，接受一个整数n，输出1+2+3+…+n 的和

// 写一个函数，接受一个整数n，输出1+2+3+...+n 的和
    public static void printSum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        System.out.println("1~"+n+"的和是"+sum );
    }
    // 打印效果如:"1+2+3+4+...+n = 结果 "
    public static void printSumPlus(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
            if (i < n) {
                System.out.print(i+" + " );
            } else {
                System.out.print(i);
            }
        }
        System.out.println(" = "+ sum );
    }

    // 打印效果如:"1+2+3+4+...+n = 结果 "
    public static void printSumPro(int n) {
        int sum = 0;
        String result = "";
        for (int i = 1; i <= n; i++) {
            sum += i;
            if (i < n) {
                result = result + i + " + ";
            } else {
                result = result + i;
            }
        }
        System.out.println(result+" = "+ sum );
    }

    public static void main(String[] args) {
        printSum(10);
        printSumPlus(10);
        printSumPro(10);
    }

2.5.3 有参有返回值方法

返回值: 是指方法执行完,返回的数据.返回给调用者

怎么写?

• 在方法内,写return + 值
• 方法就不能写void,而是要根据返回值定义对应的数据类型

怎么调用?怎么接收返回值?

• 通过方法名调用,在前面使用变量接收返回值

public class Demo4 {

    // 返回值
    public static int mult(int a, int b) {
        return a * b;
    }
    public static void main(String[] args) {
        int r = mult(2,3);
        // int r就是接收方法的返回值
        System.out.println("方法的返回值:" + r );
    }
}

// 写一个函数，接受一个整数n，返回1+2+3+...+n 的和
    public static int getSum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }

    // 设计方法,给输入的书名,加上书名号《》返回
    public static String getBook(String book){
         return  "《"+book+"》";
    }

    public static void main(String[] args) {
        int sum = getSum(10);
        System.out.println("1-10的和"+sum );

        String book = getBook("从入门到精通");
        System.out.println(book);
    }

2.6 方法调用

1. 所有自定义方法需要在main方法中调用才能执行

2. main方法不能被其他方法调用

3. 方法之间是可以互相调用,注意执行顺序 (方法调用时"压栈")

   public class Demo5 {
       public static void main(String[] args) {
           /**
            * 执行结果是:   mC mB mA main
            */
           mA();
           System.out.println("main" );
       }
       public static void mA(){
           mB();
           System.out.println("mA" );
       }
       public static void mB(){
           mC();
           System.out.println("mB" );
       }
   
       public static void mC(){
           System.out.println("mC" );
       }
   }
   

   

4. 如果方法之间相互调用,返回值,返回给调用者

5. 方法之间相互调,但是注意合理的递归

class Demo5_3{

    // 求,任意给定的一个 整数n的阶乘
    // 5! = 5 * 4 * 3 * 2 * 1
    // 方法1: 使用循环实现
    public static void jc2(int n){
        int r = 1;
        for (int i = n; i > 0; i--) {
            r *= i;
        }
        System.out.println(n+"的阶乘 = "  + r );
    }
    // 方式2: 使用方法自己调用自己实现(递归)(重点)
    public static int jc(int n){
        if (n == 1){
            return 1;
        }
        return n*jc(n-1);
    }
    public static void main(String[] args) {
        int jc = jc(4);
        System.out.println(jc );
    }
}

三、数组(array)

3.1 介绍

是什么?

• 之前的变量,装一个数据

• 数组就是一个容器,装多个数据的

怎么写?

• 数据类型[] 数组名; // 声明数组
• 数组名 = new 数据类型[长度]; // 创建数组

数组的特点:

• 数组只能存储同一种数据
• 数组长度固定，不能改变

3.2 演示声明/创建

public class Demo6 {
    public static void main(String[] args) {
        int[] arr; // 声明一个整型数组,存储整数
        double[] arr2; // 声明一个浮点型数组,存储小数
        String[] arr3; // 声明一个字符串数组,存储字符串
        // 特殊写法,一般不用
        // byte  arr4[]; 不推荐


        // 3是指数组的长度,即容量,能存储数据的个数
        arr = new int[3]; // 创建数组,声明创建前后类型要一致
        arr2 = new double[4];
        arr3 = new String[5];

        // 但是一般情况下,常用是连着写
        int[] arr4 = new int[3];
        /**
         * [I@4554617c
         * [ 是指这是一维数组
         * I 是指Integer
         * @ 是地址分隔符
         * 4554617c  是数组在内存的地址
         */
        System.out.println(arr4 );
    }
}

3.3 内存问题

• 方法执行进栈
• java凡是new都会在堆中开辟空间,分配内存地址
• 数组内会根据长度,自动分配连续空间,且定义下标(索引)从0开始
• 新创建的数组,里面是默认值
  • 整型默认值 0
  • 浮点型默认值 0.0
  • 布尔值默认值 false
  • 字符串默认值 ’ ’
  • 引用类型(类,数组,接口)默认值null , 即String是类类型的String数组默认值是null
• 将数组的地址赋值给变量名(数组名)

3.4 演示数组存取

    public static void main(String[] args) {
        // 但是一般情况下,常用是连着写
        int[] arr4 = new int[3];
        System.out.println(arr4 );

        // --------------------------
        /**
         * 数组存取都通过数组+下标来完成
         */
        // --------------------------
        /**
         * 演示数组取值
         * 数组名[下标]
         */
        int a1 = arr4[0];
        int a2 = arr4[1];
        int a3 = arr4[2];
        System.out.println("---- 数组第一次取值 ----" );
        System.out.println(a1 );
        System.out.println(a2 );
        System.out.println(a3 );

        /**
         * 演示数组存值(赋值)
         * 数组名[下标] = 值;
         */
        arr4[0] = 10;
        arr4[1] = 20;
        arr4[2] = 30;
        System.out.println("---- 数组第二次取值 ----" );
        System.out.println(arr4[0] );
        System.out.println(arr4[1] );
        System.out.println(arr4[2] );
    }

练习

  public static void main(String[] args) {
        // 创建一个double型数组,存储3个成绩
        // 并取出展现
        double[] arr1 = new double[3];
        // System.out.println(arr1[0] );// 默认值0.0
        arr1[0] = 84.2;
        arr1[1] = 66.6;
        arr1[2] = 75.8;
        System.out.println(arr1[0] );
        System.out.println(arr1[1] );
        System.out.println(arr1[2] );


        // 创建一个String数组,存储3个人名
        // 并取出展现
        String[] arr2 = new String[3];
        System.out.println(arr2[0] );// 默认值null
        arr2[0] = "安其拉";
        arr2[1] = "李白";
        arr2[2] = "高渐离";
        System.out.println(arr2[0] );
        System.out.println(arr2[1] );
        System.out.println(arr2[2] );
    }

3.5 另一种创建方式

int[] arr = new int[3]; 这样创建出的数组,其中是默认值,还需要后续再单独存值.
java提供另外一种方式,可以在创建数组的同时,直接指定元素,即创建出数组其中就有值.

语法:

• 数据类型[] 数组名 = new 数据类型[]{值1,值2,…};
• 与之前的区别在于,不指定长度而是指定元素

 public static void main(String[] args) {
        /**
         * 如此创建,一样会在内存开辟空间,分配地址
         * 根据元素划分连续空间,分配下标
         */
        int[] arr = new int[]{11,22,33,44};
        System.out.println(arr );// 地址值
        System.out.println(arr[0] );// 取值
        /**
         * 数组有属性 length,可以直接获得长度
         */
        int length = arr.length;
        System.out.println(length );

        /**
         * 也可以再次改变数组值
         */
        arr[0] = 111;
        System.out.println(arr[0] );
    }

**[重点]**这种方式用的很多,所有java提供它的简化写法,更简单, (省略了new的写法,直接写{})

• 数据类型[] 数组名 = {值1,值2,…};

        /**
         * 简化写法
         * 只是写法简化,其他功能一模一样
         */
        double[] arr2 = {1.1,2.2,3.3};
        String[] arr3 = {"Java","Python","鸿蒙"};
        System.out.println(arr3[2] );
        arr3[2] = "HarmonyOS";
        System.out.println(arr3[2] );

3.6 数组的遍历【重点】

遍历: 一个一个将数组的元素取出.

如何实现: 使用for循环即可

 public static void main(String[] args) {
        // 遍历输出
        int[] arr = {11,22,33,44,55};
        // 下标从0开始,最大长度-1
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

四、数组练习

1、从键盘录入五个名字到数组中，遍历数组输出这五个名字

    public static void printName(){
        Scanner scanner = new Scanner(System.in);
        String[] nameArr = new String[5];
        for(int i = 0;i < nameArr.length;i++) {
            System.out.print("请输入第"+(i+1)+"个人名:");
            nameArr[i] = scanner.next();
        }

        System.out.println("输入完毕,开始遍历..." );
        for(int i = 0;i < nameArr.length;i++) {
            System.out.println("第"+(i+1)+"个名字: "+nameArr[i]);
        }
    }

2、给定一个数组，求数组的最大值

  public static int getMax(){
        int[] arr = {5,3,2,7,1,4,6};
        int max = arr[0];// 假设第一个最大
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }
// ps: 想象比武招亲场景

3、给定一个数组，求数组的平均值

  public static int getAvg(){
        int[] arr = {5,3,2,7,1,4,6};
        
        return 0;
    }

五、总结

方法

• public static 固定
• 返回值void 是否改变要看题目 要求,如果需要返回数据,方法内还需要加return
• 方法名任意,见名知意
• 参数列表(可以空参,可以多参数)

方法调用

• 最终要在main方法调用执行
• **[重点]**方法相互调用时,执行顺序问题(2.6章节)
• **[重点|难点]**递归

数组

• 声明
• 两种创建方式
  • new 数据类型[长度];
  • new 数据类型[]{值1,…}
• 取值,赋值动作
• 注意下标问题,不要越界 (0~长度-1)
• **[重点]**数组会遍历
• **[重点]**数组的内存
  • 什么时候创建 ,哪里创建 , 内存是否连续?下标如何分配?初始值 又如何?

附录

method 方法

function 函数

expected 期望

argument 参数

arguments 参数,简写args

value 值

miss 消失/不见

ArrayIndexOutOfBoundsException 数组 下标越界异常