一、数组：装一组数据
1.1 什么是数组？
假设你要存5个学生的成绩：
-
不用数组：score1、score2、score3、score4、score5 → 变量太多管不过来
-
用数组：一个数组score，存5个成绩
**数组的特点： **
-
长度固定（创建时确定）
-
索引从0开始
-
存取速度快
1.2 数组的声明和创建
方式1：先声明后创建
int[] scores; // 声明数组
scores = new int[5]; // 创建数组，长度为5
方式2：声明和创建一起
int[] scores = new int[5];
方式3：直接初始化
int[] scores = {90, 85, 78, 92, 88};
1.3 数组的使用
public class ArrayDemo {
public static void main(String[] args) {
int[] scores = {90, 85, 78, 92, 88};
// 访问数组元素（索引从0开始）
System.out.println("第一个成绩：" + scores[0]); // 90
System.out.println("第三个成绩：" + scores[2]); // 78
// 修改数组元素
scores[0] = 95;
System.out.println("修改后第一个成绩：" + scores[0]); // 95
// 获取数组长度
System.out.println("数组长度：" + scores.length); // 5
}
}
1.4 遍历数组（重点）
方式1：普通for循环
int[] scores = {90, 85, 78, 92, 88};
for (int i = 0; i < scores.length; i++) {
System.out.println("第" + (i + 1) + "个成绩：" + scores[i]);
}
**方式2：增强for循环（推荐） **
int[] scores = {90, 85, 78, 92, 88};
for (int score : scores) {
System.out.println("成绩：" + score);
}
**解释： ** for (int score : scores) 的意思是：依次取出scores里的每个元素，存到score变量里。
1.5 数组的默认值
创建数组但没赋值时，会有默认值：
| 类型 | 默认值 |
|------|--------|
| 整数（int、long） | 0 |
| 浮点数（float、double） | 0.0 |
| 布尔（boolean） | false |
| 引用类型（String等） | null（空引用） |
int[] arr = new int[3];
System.out.println(arr[0]); // 0
System.out.println(arr[1]); // 0
1.6 数组的常见操作
**求平均分： **
int[] scores = {90, 85, 78, 92, 88};
int sum = 0;
for (int score : scores) {
sum += score;
}
double average = (double) sum / scores.length;
System.out.println("平均分：" + average); // 86.6
**找最大值： **
int[] scores = {90, 85, 78, 92, 88};
int max = scores[0]; // 假设第一个是最大
for (int i = 1; i < scores.length; i++) {
if (scores[i] > max) {
max = scores[i];
}
}
System.out.println("最高分：" + max); // 92
二、方法：代码的复用
2.1 什么是方法？
方法（Method）就是一段可以反复调用的代码。
打个比方：
-
变量是盒子，装数据
-
方法是工具箱，装功能
**方法的好处： **
-
减少代码重复
-
代码结构更清晰
-
方便维护和修改
2.2 方法的定义
**语法： **
访问修饰符 返回类型 方法名(参数列表) {
// 方法体
return 结果;
}
例子：无参无返回值
public void sayHello() {
System.out.println("Hello!");
}
例子：有参有返回值
public int add(int a, int b) {
return a + b;
}
2.3 方法的调用
public class MethodDemo {
public static void main(String[] args) {
MethodDemo demo = new MethodDemo();
// 调用无返回值方法
demo.sayHello();
// 调用有返回值方法
int result = demo.add(10, 20);
System.out.println("10 + 20 = " + result);
}
public void sayHello() {
System.out.println("Hello!");
}
public int add(int a, int b) {
return a + b;
}
}
**注意： ** 在同一个类里，static方法可以直接调用，非static方法需要先创建对象。
2.4 方法的参数
**无参方法： **
public void printLine() {
System.out.println("============");
}
**有参方法： **
public void printName(String name) {
System.out.println("姓名：" + name);
}
// 调用
printName("张三"); // 输出：姓名：张三
**多个参数： **
public int max(int a, int b) {
return a > b ? a : b;
}
// 调用
int m = max(10, 20); // m = 20
2.5 方法的返回值
-
void：不返回任何值 -
其他类型：返回对应类型的值
// 返回int
public int getSum(int a, int b) {
return a + b;
}
// 返回String
public String getGreeting(String name) {
return "你好，" + name + "！";
}
// 返回boolean
public boolean isAdult(int age) {
return age >= 18;
}
2.6 方法重载
**同一个类里，方法名可以相同，但参数列表必须不同。 **
public class OverloadDemo {
// 两个int参数
public int add(int a, int b) {
return a + b;
}
// 三个int参数（重载）
public int add(int a, int b, int c) {
return a + b + c;
}
// 两个double参数（重载）
public double add(double a, double b) {
return a + b;
}
public static void main(String[] args) {
OverloadDemo demo = new OverloadDemo();
System.out.println(demo.add(1, 2)); // 3
System.out.println(demo.add(1, 2, 3)); // 6
System.out.println(demo.add(1.5, 2.5)); // 4.0
}
}
**编译器根据参数类型和数量判断调用哪个。 **
三、面向对象入门：类和方法的关系
3.1 什么是类？
**类（Class） ** 是对象的模板。
打个比方：
-
类是图纸，定义了对象长什么样
-
对象是实物，根据图纸造出来的
**类包含： **
-
属性（也叫字段）：对象的特征
-
方法：对象的行为
3.2 类的定义
例子：定义一个学生类
public class Student {
// 属性
String name;
int age;
int score;
// 方法：自我介绍
public void introduce() {
System.out.println("大家好，我叫" + name + "，今年" + age + "岁");
}
// 方法：考试
public void exam(int score) {
this.score = score;
System.out.println(name + "这次考试得了" + score + "分");
}
}
**解释： **
-
this.name指的是当前对象的name属性 -
this可以省略，但如果参数名和属性名相同，就必须用this区分
3.3 对象的创建和使用
public class Main {
public static void main(String[] args) {
// 创建对象（new关键字）
Student s1 = new Student();
Student s2 = new Student();
// 给属性赋值
s1.name = "张三";
s1.age = 18;
s2.name = "李四";
s2.age = 19;
// 调用方法
s1.introduce(); // 输出：大家好，我叫张三，今年18岁
s2.introduce(); // 输出：大家好，我叫李四，今年19岁
s1.exam(95);
s2.exam(88);
}
}
3.4 构造方法（重点）
**构造方法是创建对象时自动调用的方法。 **
public class Student {
String name;
int age;
// 无参构造方法
public Student() {
System.out.println("无参构造被调用");
}
// 有参构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println("有参构造被调用");
}
public void introduce() {
System.out.println("大家好，我叫" + name + "，今年" + age + "岁");
}
}
**使用： **
Student s1 = new Student(); // 调用无参构造
Student s2 = new Student("张三", 18); // 调用有参构造
**注意： **
-
如果不写构造方法，Java会自动提供一个无参构造
-
如果写了有参构造，Java就不再提供无参构造
四、综合练习：学生成绩管理系统
4.1 需求
用数组和方法，实现一个简单的成绩管理系统：
-
存储5个学生的成绩
-
计算平均分
-
找最高分和最低分
4.2 代码
public class ScoreManager {
// 存储成绩的数组
private int[] scores;
// 构造方法，初始化数组
public ScoreManager(int size) {
scores = new int[size];
}
// 添加成绩
public void addScore(int index, int score) {
if (index >= 0 && index < scores.length) {
scores[index] = score;
}
}
// 计算平均分
public double getAverage() {
int sum = 0;
for (int score : scores) {
sum += score;
}
return (double) sum / scores.length;
}
// 获取最高分
public int getMax() {
int max = scores[0];
for (int i = 1; i < scores.length; i++) {
if (scores[i] > max) {
max = scores[i];
}
}
return max;
}
// 获取最低分
public int getMin() {
int min = scores[0];
for (int i = 1; i < scores.length; i++) {
if (scores[i] < min) {
min = scores[i];
}
}
return min;
}
// 打印所有成绩
public void printAll() {
System.out.print("成绩列表：");
for (int score : scores) {
System.out.print(score + " ");
}
System.out.println();
}
// 主方法
public static void main(String[] args) {
ScoreManager manager = new ScoreManager(5);
// 添加成绩
manager.addScore(0, 90);
manager.addScore(1, 85);
manager.addScore(2, 78);
manager.addScore(3, 92);
manager.addScore(4, 88);
// 输出结果
manager.printAll();
System.out.println("平均分：" + manager.getAverage());
System.out.println("最高分：" + manager.getMax());
System.out.println("最低分：" + manager.getMin());
}
}
4.3 运行结果
成绩列表：90 85 78 92 88
平均分：86.6
最高分：92
最低分：78
五、常见错误
❌ 错误1：数组越界
int[] arr = {1, 2, 3};
// 错误！索引3越界（数组长度是3，索引0-2）
System.out.println(arr[3]);
// 正确
System.out.println(arr[2]); // 输出3
❌ 错误2：空指针异常
int[] arr; // 只是声明，没有创建数组
// 错误！arr是null，访问null会报NullPointerException
System.out.println(arr.length);
// 正确
arr = new int[3];
System.out.println(arr.length); // 3
❌ 错误3：方法忘记返回值
// 错误！声明了返回int，但没return
public int getMax() {
int a = 10;
int b = 20;
// 缺少 return
}
// 正确
public int getMax() {
int a = 10;
int b = 20;
return a > b ? a : b;
}
六、本课总结
-
数组：装一组数据，长度固定，索引从0开始
-
方法：代码复用，把功能打包成方法
-
面向对象：类是大图纸，对象是根据图纸造的实物
-
构造方法：创建对象时自动调用的特殊方法
**记住： **
-
数组索引从0开始，别越界
-
访问数组前要确保它已经创建（不是null）
-
方法重载看参数列表，不是看返回值
-
this关键字指向当前对象
七、下节课预告
第4课：面向对象三大特性
-
封装：把数据藏起来
-
继承：子承父业
-
多态：同一个方法，不同的表现
这是面向对象的核心，理解了这三特性，才算真正入门Java。
**关注我，跟着老兵学Java，少走弯路。 **
💬 **评论区聊聊：学完这课，数组和方法的哪个用法最容易搞混？ **
