〔004〕Java 基础之数组、方法

✨ 目录

• • ▷ 静态初始化数组
  • ▷ 静态初始化数组定义的三种方式
  • ▷ 数组的访问
  • ▷ 数组的长度
  • ▷ 数组存储原理
  • ▷ 数组的遍历
  • ▷ 动态初始化数组
  • ▷ 数组求最值
  • ▷ 数组反转
  • ▷ debug工具
  • ▷ 方法
  • ▷ 返回值
  • ▷ 求和
  • ▷ 奇偶性
  • ▷ 参数传递
  • ▷ 方法重载
  • ▷ 案例：创建验证码

▷ 静态初始化数组

• 数组： 就是一个容器，用来存储一批 同种类型 的数据
• 静态化数组： 就是预先填入数组的元素，知道数组有哪些值
• 格式： 定义 数据类型[] 数组名 也可以写成 数据类型 数组名[]
• 注意： 什么类型的数组只能存放什么类型的数据

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        // 定义整数类型的数组
        int[] arr = {1, 20, 32, 41, 54};

        // 定义字符串类型的数组
        String[] names = {"飞兔小哥", "博客专家", "天猫精灵测评官"};
    }
}

▷ 静态初始化数组定义的三种方式

• 方式一： 数组类型[] 数组名 = new 数组类型{元素一, 元素二, 元素三}
• 方式二： 数组类型[] 数组名 = {元素一, 元素二, 元素三}
• 方式三： 数组类型 数组名[] = {元素一, 元素二, 元素三}

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        // 定义数组的方式一
        String[] names = new String[]{"飞兔小哥", "博客专家", "天猫精灵测评官"};

        // 定义数组的方式二
        int[] age = {20, 25, 32};

        // 定义数组的方式三
        double height[] = new double[]{172.4, 168.9, 184.9};
    }
}

▷ 数组的访问

• 格式： 数组名[索引]，其中索引是从 0 开始的

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        String[] names = new String[]{"飞兔小哥", "博客专家", "天猫精灵测评官"};
        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
    }
}

▷ 数组的长度

• 格式： 数组名.length，通过该程序可以获取数组中的元素个数

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        String[] names = new String[]{"飞兔小哥", "博客专家", "天猫精灵测评官"};
        System.out.println(names.length);
    }
}

▷ 数组存储原理

• 数组变量中存储的是数组在 内存中的地址，而数组是一种引用类型的数据，变量的地址指向了最终的数据
• 就好像数组名是门牌号，只有通过门牌号才能找到家一样

▷ 数组的遍历

• 遍历： 一个一个的访问数组的元素，可以通过 for 循环进行遍历
• 比如在不知道数组中有多少元素的情况下，并且想计算元素加起来的和是多少

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        int ages[] = {10, 20, 30, 40};
        int count = 0;

        for (int i = 0; i < ages.length; i++) {
            count += ages[i];
        }

        System.out.println(count);
    }
}

▷ 动态初始化数组

• 动态化数组： 就是定义数组时不存入元素的具体值，只确定数组存储的数据类型和数组的长度
• 适合开始不确定具体元素值，只知道元素个数的业务场景
• 格式： 数据类型[] 数组名 = new 数据类型[长度]

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        String[] names = new String[3];

        names[0] = "飞兔小哥";
        names[1] = "博客专家";
        names[2] = "天猫精灵测评官";

        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
    }
}

▷ 数组求最值

• 比如给一个整型数组，求其中的最大值
• 就是遍历数组，判断每个值如果比前一个值大，就把大的值赋值给变量

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        int age[] = {10, 20, 40, 30};
        int max = age[0]; // 定义最开始的值

        for (int i = 0; i < age.length; i++) {
            if (age[i] > max) max = age[i];
        }

        System.out.println("最大值为：" + max);
    }
}

▷ 数组反转

• 比如给一个整型数组 {10, 20, 40, 30} 将其反转变成 {30, 40, 20, 10}
• 原理就是先将第一个元素和最后一个元素调换位置后，然后将第二个元素和倒数第二个元素进行交换，然后一直下去即可
• 可以定义两个变量 i和j，其中 i 默认值从第一个元素向右移动，j 默认最后一个元素向左移动，每处理一次将其中两个元素位置进行互换即可

▷ debug工具

• 在写程序的时候，可以看到编辑器已经很直观的给你进行错误提示了
• 但是如果想查看运行过程中，数值的变化情况，就需要用到编辑器的 debug 工具了
• 首先，需要在 行号 上面打个断点，然后右键选择 debug 运行，点击运行按钮，即可在编辑器中看到数组的变化了，非常的清晰

▷ 方法

• 方法： 是一种语法结构，把一段代码封装成一个功能，以便重复调用
• 方法 可以提高代码的重复性，提高开发效率，也可以让程序的逻辑更加的清晰
• 方法的定义格式： 修饰词 返回值类型 方法名(形参列表) { 代码; return 返回值; }
• 注意： 方法如果申明了具体的返回值类型，那么内部 return 必须返回对应的数据类型

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        int count = sum(1, 2);
        System.out.println(count);
    }

    public static int sum(int a, int b) {
        return a + b;
    }
}

▷ 返回值

• 如果定义的方法没有返回值，那么返回值的类型就需要定义成 void
• 如果定义的方法有返回值，那么内部 return 必须返回对应的数据类型
• 形参列表可以有多个，甚至没有；如果有多个形参，需要用逗号隔开，且不能给初始化值

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
    	// 有返回值的方法
        int count = sum(1, 2);
        System.out.println(count);
        
        // 直接调用无返回值的方法
        say();
    }

    public static void say() {
        System.out.println("我是飞兔小哥");
    }

    public static int sum(int a, int b) {
        return a + b;
    }
}

▷ 求和

• 求 1到n的和 是有返回值的，也就是需要打印最终的和
• 由小学求和公式可知，求1到n的和的公式为：(1+n)*n/2
• 因为最终的和是整数，所以需要定义返回类型为 int

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        int count = sum(100);
        System.out.println(count);
    }

    public static int sum(int n) {
        return (1 + n) * n / 2;
    }
}

▷ 奇偶性

• 判断一个数的奇偶性，只需要打印结果即可，不需要返回值的
• 这个时候就可以将返回值的类型定义为 void

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        judge(51);
        judge(60);
    }

    public static void judge(int number) {
        if (number % 2 == 0) {
            System.out.println(number + "是一个偶数");
        } else {
            System.out.println(number + "是一个奇数");
        }
    }
}

▷ 参数传递

• 值传递： 指的是在传输实参给方法中的形参的时候，传输的是实参变量中存储的值的副本，修改副本中参数的值，并不会改变实参的值
• 引用值传递： 传输给形参的时候，传的是实参的地址，修改值之后，会改变实参中的值，比如数组就是引用传递

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        // 值传递
        int a = 20;
        change(a);
        System.out.println(a);
    }

    public static void change(int a) {
        System.out.println(a);
        a = 520; // 修改值
        System.out.println(a);
    }
}

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        // 引用值传递
        int a[] = {10, 20, 30};
        change(a);
        System.out.println(a[1]);
    }

    public static void change(int[] a) {
        System.out.println(a[1]);
        a[1] = 520; // 修改值
        System.out.println(a[1]);
    }
}

▷ 方法重载

• 方法重载： 是在一个类中，多个方法的 名称相同，但是它们的 形参列表不同，其他的不用管，比如修饰符、返回值类型等。
• 形参列表的不同： 指的是形参的个数、类型、顺序不同，不关心形参的名称
• 比如游戏中创建 NPC，并且给 NPC 设置血量

package tiny.geeker;

public class Test {
    public static void main(String[] args) {
        System.out.println(create("飞兔小哥"));
        System.out.println(create("飞兔小哥", 10000));
    }

    public static String create(String name) {
        return "创建了NPC：" + name;
    }

    public static String create(String name, int blood) {
        return "创建了NPC：" + name + "，血量为：" + blood;
    }
}

▷ 案例：创建验证码

• 指定程序生成 n 位数的验证码，然后程序会随机返回 n 位数的字符串

package tiny.geeker;

import java.util.Random;

public class Test {
    public static void main(String[] args) {
        String code = qrcode(5);
        System.out.println(code);
    }

    public static String qrcode(int n) {
        String code = "";
        Random r = new Random();

        for (int i = 0; i < n; i++) {
            int type = r.nextInt(3);
            switch (type) {
                case 0:
                    // 生成小数
                    code += r.nextInt(10);
                    break;
                case 1:
                    // 生成小写字母
                    char ch1 = (char) (r.nextInt(26) + 97);
                    code += ch1;
                    break;
                case 2:
                    // 生成大写字母
                    char ch2 = (char) (r.nextInt(26) + 65);
                    code += ch2;
                    break;
            }
        }
        return code;
    }
}

代码007普通

打赏 收藏 海报 链接