✨ 目录
- ▷ 静态初始化数组
- ▷ 静态初始化数组定义的三种方式
- ▷ 数组的访问
- ▷ 数组的长度
- ▷ 数组存储原理
- ▷ 数组的遍历
- ▷ 动态初始化数组
- ▷ 数组求最值
- ▷ 数组反转
- ▷ 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;
}
}
文章出处登录后可见！
已经登录？立即刷新
