Day 14：Java类与对象 · 属性 · 行为 · 创建对象 · 对象调用

目录

第一部分：Day 13 练习答案

练习1：给 ATM 增加“修改密码”功能（菜单第6项）

练习2：取款时增加限制：单次最多取 5000

练习3：用数组记录最近 5 笔操作金额（存款正、取款负），并提供“打印流水”

练习4：登录成功后显示隐藏账号（1001→1**1），并统计登录失败总次数

第二部分：Day 14 详细教程

今日目标

一、先建立概念（一看就懂）

二、为什么要从数组升级到对象？

三、最小例子：定义类 → 创建对象 → 调用

学习路径

四、逐项精讲

1）属性写在哪？

2）行为怎么写？

3）new 做了什么？

4）调用固定姿势

五、static 方法 vs 对象方法

六、综合案例：Account 账户类（承接 ATM）

七、对象数组（为管理系统打基础）

八、建议你这样练

九、还有没有别的写法？

十、固定写法

今日必会

第三部分：Day 14 课后练习

第一部分：Day 13 练习答案

练习1：给 ATM 增加“修改密码”功能（菜单第6项）

import java.util.Scanner; // 导入键盘输入工具

public class Day13Ex1 { // 公共类，文件名必须是Day13Ex1.java
static String[] ids = {"1001", "1002"}; // 账号数组
static String[] pwds = {"123456", "234567"}; // 密码数组
static Scanner sc = new Scanner(System.in); // 创建Scanner
static int currentIndex = 0; // 演示：假设已登录第0个用户

public static void main(String[] args) { // 程序入口
System.out.println("当前可把本方法接到菜单 case 6"); // 使用提示
changePassword(); // 调用修改密码
System.out.println("修改后密码：" + pwds[currentIndex]); // 验证结果
}

public static void changePassword() { // 修改当前用户密码
System.out.print("请输入原密码："); // 提示输入原密码
String oldPwd = sc.next(); // 读取原密码
if (!pwds[currentIndex].equals(oldPwd)) { // 原密码不对
System.out.println("原密码错误"); // 提示错误
return; // 结束，不修改
}
System.out.print("请输入新密码："); // 提示新密码
String newPwd = sc.next(); // 读取新密码
System.out.print("请确认新密码："); // 提示确认
String confirm = sc.next(); // 读取确认密码
if (!newPwd.equals(confirm)) { // 两次不一致
System.out.println("两次新密码不一致"); // 提示
return; // 结束，不修改
}
pwds[currentIndex] = newPwd; // 写回当前用户密码
System.out.println("密码修改成功"); // 成功提示
}
}

/*
预期输出（原密码123456，新密码111111并确认）：
当前可把本方法接到菜单 case 6
请输入原密码：123456
请输入新密码：111111
请确认新密码：111111
密码修改成功
修改后密码：111111
*/

练习2：取款时增加限制：单次最多取 5000

import java.util.Scanner; // 导入Scanner

public class Day13Ex2 { // 公共类
static double balance = 8000.0; // 演示余额
static Scanner sc = new Scanner(System.in); // 键盘输入

public static void main(String[] args) { // 入口
withdraw(); // 调用取款
System.out.println("余额：" + balance); // 打印余额
}

public static void withdraw() { // 带单笔限额的取款
System.out.print("请输入取款金额："); // 提示
double amount = sc.nextDouble(); // 读取金额
if (amount <= 0) { // 金额必须为正
System.out.println("金额必须大于0"); // 提示
return; // 结束
}
if (amount > 5000) { // 单次最多5000
System.out.println("单次最多取款5000"); // 超限提示
return; // 结束，不扣款
}
if (amount > balance) { // 余额不足
System.out.println("余额不足"); // 提示
return; // 结束
}
balance -= amount; // 扣减余额
System.out.println("取款成功"); // 成功提示
}
}

/*
预期输出（输入6000）：
请输入取款金额：6000
单次最多取款5000
余额：8000.0

预期输出（输入3000）：
请输入取款金额：3000
取款成功
余额：5000.0
*/

练习3：用数组记录最近 5 笔操作金额（存款正、取款负），并提供“打印流水”

public class Day13Ex3 { // 公共类
static double[] records = new double[5]; // 最近5笔流水
static int count = 0; // 已记录笔数

public static void main(String[] args) { // 入口：模拟几笔后打印
addRecord(200); // 存款记+200
addRecord(-100); // 取款记-100
addRecord(50); // 存款记+50
printRecords(); // 打印流水
}

public static void addRecord(double amount) { // 追加一笔流水
if (count < records.length) { // 还没满5笔
records[count] = amount; // 放到下一个空位
count++; // 笔数加1
} else { // 已满：丢掉最旧，整体左移
for (int i = 0; i < records.length – 1; i++) { // 从左往右挪
records[i] = records[i + 1]; // 后一个覆盖前一个
}
records[records.length – 1] = amount; // 最新一笔放最后
}
}

public static void printRecords() { // 打印流水菜单功能
System.out.println("—– 最近流水 —–"); // 标题
for (int i = 0; i < count && i < records.length; i++) { // 只打印有效笔数
System.out.println("第" + (i + 1) + "笔：" + records[i]); // 打印每笔
}
}
}

/*
预期输出：
—– 最近流水 —–
第1笔：200.0
第2笔：-100.0
第3笔：50.0
*/

练习4：登录成功后显示隐藏账号（1001→1**1），并统计登录失败总次数

public class Day13Ex4 { // 公共类
static String[] ids = {"1001", "1002"}; // 账号
static String[] pwds = {"123456", "234567"}; // 密码
static int failCount = 0; // 登录失败总次数

public static void main(String[] args) { // 入口
boolean ok1 = login("1001", "000000"); // 故意输错
System.out.println("第1次登录结果：" + ok1); // 打印结果
boolean ok2 = login("1001", "123456"); // 输对
System.out.println("第2次登录结果：" + ok2); // 打印结果
System.out.println("失败总次数：" + failCount); // 打印失败统计
}

public static boolean login(String id, String pwd) { // 登录校验
for (int i = 0; i < ids.length; i++) { // 遍历用户
if (ids[i].equals(id) && pwds[i].equals(pwd)) { // 账号密码都对
System.out.println("登录成功，账号：" + hideId(ids[i])); // 显示隐藏账号
return true; // 返回成功
}
}
failCount++; // 失败次数+1
System.out.println("登录失败"); // 提示失败
return false; // 返回失败
}

public static String hideId(String id) { // 隐藏中间字符
if (id == null || id.length() <= 2) { // 太短不处理
return id; // 原样返回
}
char first = id.charAt(0); // 首字符
char last = id.charAt(id.length() – 1); // 尾字符
String mid = ""; // 中间星号
for (int i = 0; i < id.length() – 2; i++) { // 中间有几位就加几个*
mid += "*"; // 追加*
}
return first + mid + last; // 拼成1**1形式
}
}

/*
预期输出：
登录失败
第1次登录结果：false
登录成功，账号：1**1
第2次登录结果：true
失败总次数：1
*/

第二部分：Day 14 详细教程

今日目标

一、先建立概念（一看就懂）

类 = 图纸 / 模具

对象 = 按图纸做出来的具体东西

类：手机图纸（都有品牌、价格；都能开机、打电话）

对象：你的红色小米、我的黑色华为 —— 彼此数据独立

二、为什么要从数组升级到对象？

昨天 ATM：

ids[i] / pwds[i] / moneys[i] —— 靠同一个 i 绑在一起，容易对错行

今天希望：

一个 Account 对象自己带着：id、pwd、money

好处：一个对象就是一个完整账户，数据不散落。

三、最小例子：定义类 → 创建对象 → 调用

学习路径

public class StudentDemo { // 演示主类（建议 Student 单独一个文件；这里为方便放一起）
public static void main(String[] args) { // 程序入口
Student s1 = new Student(); // 按Student模板创建对象s1
s1.name = "张三"; // 给s1的姓名赋值
s1.age = 18; // 给s1的年龄赋值
s1.study(); // 调用s1的学习方法
s1.show(); // 调用s1的展示方法

Student s2 = new Student(); // 再创建另一个独立对象s2
s2.name = "李四"; // s2有自己的数据，不影响s1
s2.age = 19; // 给s2赋值年龄
s2.show(); // 展示s2
}
}

class Student { // 学生类：模板
String name; // 属性：姓名（每个对象各有一份）
int age; // 属性：年龄

public void study() { // 行为：学习（对象方法，先不写static）
System.out.println(name + " 正在学习Java"); // 使用本对象的name
}

public void show() { // 行为：展示信息
System.out.println("姓名：" + name + "，年龄：" + age); // 打印本对象属性
}
}

/*
预期输出：
张三 正在学习Java
姓名：张三，年龄：18
姓名：李四，年龄：19
*/

四、逐项精讲

1）属性写在哪？

写在类里、方法外 → 属于对象。

class Student { // 学生类
String name; // 成员变量/属性
int age; // 成员变量/属性
}

默认值记住：

2）行为怎么写？

和以前方法很像，但对象方法通常先不写 static。

public void study() { // 对象方法
System.out.println(name + " 正在学习"); // 直接用自己的属性
}

3）new 做了什么？

Student s1 = new Student();

1. 在堆里创建出一个Student对象
2. 属性先是默认值
3. 把对象地址交给引用变量s1
Student s1 = new Student(); // s1是“遥控器”，指向真正的学生对象

4）调用固定姿势

对象名.属性 = 值; // 访问属性
对象名.方法(参数); // 调用方法

五、static 方法 vs 对象方法

public class CallCompare { // 对比调用方式
public static void main(String[] args) { // static入口
sayHello(); // static方法可直接调用
Student s = new Student(); // 先创建对象
s.name = "王五"; // 再设属性
s.study(); // 再调对象方法
}

public static void sayHello() { // static工具方法
System.out.println("hello"); // 打印
}
}

class Student { // 学生类
String name; // 属性
public void study() { // 对象方法
System.out.println(name + " 学习中"); // 用对象自己的name
}
}

/*
预期输出：
hello
王五 学习中
*/

六、综合案例：Account 账户类（承接 ATM）

public class AccountDemo { // 演示主类
public static void main(String[] args) { // 入口
Account a1 = new Account(); // 创建账户1
a1.id = "1001"; // 设置账号
a1.pwd = "123456"; // 设置密码
a1.money = 1000.0; // 设置余额

Account a2 = new Account(); // 创建账户2（与a1数据独立）
a2.id = "1002"; // 账号
a2.pwd = "234567"; // 密码
a2.money = 2000.0; // 余额

a1.show(); // 查看a1
a1.deposit(300); // a1存款300
a1.withdraw(100); // a1取款100
a1.show(); // 再查看a1

boolean ok = a1.login("1001", "123456"); // 用a1校验登录
System.out.println("登录结果：" + ok); // 打印结果
a2.show(); // a2余额仍是2000，证明对象互相独立
}
}

class Account { // 账户类：属性+行为打包
String id; // 属性：账号
String pwd; // 属性：密码
double money; // 属性：余额

public void show() { // 显示账户信息
System.out.println("账号：" + id + "，余额：" + money); // 打印本对象数据
}

public void deposit(double amount) { // 存款
if (amount <= 0) { // 校验金额
System.out.println("金额必须大于0"); // 提示
return; // 结束
}
money += amount; // 本对象余额增加
System.out.println(id + " 存款成功，余额：" + money); // 成功提示
}

public void withdraw(double amount) { // 取款
if (amount <= 0) { // 金额校验
System.out.println("金额必须大于0"); // 提示
return; // 结束
}
if (amount > money) { // 余额校验
System.out.println("余额不足"); // 提示
return; // 结束
}
money -= amount; // 本对象余额减少
System.out.println(id + " 取款成功，余额：" + money); // 成功提示
}

public boolean login(String inputId, String inputPwd) { // 登录校验
return id.equals(inputId) && pwd.equals(inputPwd); // 内容相等返回true
}
}

/*
预期输出：
账号：1001，余额：1000.0
1001 存款成功，余额：1300.0
1001 取款成功，余额：1200.0
账号：1001，余额：1200.0
登录结果：true
账号：1002，余额：2000.0
*/

七、对象数组（为管理系统打基础）

注意：new Account[3] 只是创建了 3 个“格子”，格子里先是 null，还要再 new Account() 放进去。

public class AccountArrayDemo { // 对象数组演示
public static void main(String[] args) { // 入口
Account[] arr = new Account[3]; // 长度为3的账户数组，元素默认null

arr[0] = new Account(); // 第0格放入账户对象
arr[0].id = "1001"; // 设置账号
arr[0].pwd = "123456"; // 设置密码
arr[0].money = 1000; // 设置余额

arr[1] = new Account(); // 第1格再放一个账户
arr[1].id = "1002"; // 账号
arr[1].pwd = "234567"; // 密码
arr[1].money = 2000; // 余额

for (int i = 0; i < arr.length; i++) { // 遍历数组
if (arr[i] != null) { // 空格子不能调用，否则空指针
arr[i].show(); // 调用每个对象自己的show
}
}
}
}

class Account { // 账户类
String id; // 账号
String pwd; // 密码
double money; // 余额

public void show() { // 显示
System.out.println("账号：" + id + "，余额：" + money); // 打印
}
}

/*
预期输出：
账号：1001，余额：1000.0
账号：1002，余额：2000.0
*/

八、建议你这样练

九、还有没有别的写法？

写法 A：创建后集中初始化

Student s = new Student(); // 先new对象
s.name = "张三"; // 再赋姓名
s.age = 18; // 再赋年龄
s.show(); // 最后调用方法

写法 B：展示信息写详细一点

public void show() { // 展示方法
System.out.println("—– 学生信息 —–"); // 标题
System.out.println("姓名：" + name); // 姓名
System.out.println("年龄：" + age); // 年龄
}

写法 C：预告封装（Day15）：属性先 private，用方法读写

class Student { // 学生类
private String name; // private：外部不能直接s.name乱改

public void setName(String n) { // 间接赋值
name = n; // 把参数赋给属性
}

public String getName() { // 间接取值
return name; // 返回属性
}
}

十、固定写法

class 类名 {
// 属性
// 方法
}
// 类是模板：先描述“有什么、能做什么”

类型 对象名 = new 类型();
// new：在堆中创建对象
// 对象名：保存对象地址的引用

对象名.属性 = 值;
// 通过引用访问并设置属性

对象名.方法(参数);
// 通过引用调用对象方法

public void 方法名() { … }
// 对象方法通常先不写static
// 调用前必须先有对象

String name; int age;
// 属性写在类中、方法外
// 每个对象各有一份独立数据

Account[] arr = new Account[3];
arr[0] = new Account();
// 对象数组要两步：先开格子，再往每个格子new对象

if (arr[i] != null) { arr[i].show(); }
// 调用前判断非null，避免空指针异常

今日必会

•  能说出类和对象的区别
•  会定义属性和成员方法
•  会 new 创建对象并赋值
•  会 对象.方法() 调用
•  能写简单 Account（show/deposit/withdraw）
•  知道对象数组要给每个元素再 new

第三部分：Day 14 课后练习

练习1：定义 Phone 类，属性 brand、price；方法 call()、show()；在 main 里创建两个手机对象并调用

练习2：定义 Book 类（书名、作者、价格），创建对象数组存放 3 本书并遍历打印

练习3：把 ATM 的“当前用户”改成 Account 对象：至少实现 query/deposit/withdraw

练习4（挑战）：写 Account[] 支持登录：输入账号密码，找到对应对象后对其操作