2022-10-07T17:45:06
69
原创
重拾java路-对象篇
对象
对象内存图
对象内存分析：
对象的加载方式：
1.加载类信息，属性 和 方法 到方法区 （只会加载一次）
2.在堆中分配空间，进行默认初始化，都为初始（0/null/0.0）如果有 引用类型 会在方法区的常量池进行分配空间地址 从堆指向常量池.
3.然后把地址给 p（定义的对象名），p 指向堆的地址内存
4.p 进行 指定的初始化 例如： p.name = 'jack';
对象方法内存分析
调用方法时，临时开出一个栈空间，使用完之后销毁
对象的方法注意事项
注意成员方法传递：形参的任何改变不会影响实参（值传递）
注意 引用为 p = null 的情况，断开堆地址,互不影响
注意： 堆地址引用 如果 引用的方法 p=null 断开与被引用的堆地址 ，不会改变堆地址；
递归调用
调用开栈，调用的方法值为 从上到下 调用方法为返回值
递归规则
demo老鼠出迷宫
汉诺塔dmeo
方法重载
注意事项：
可变参数
例如：
注意事项：
demo例子：
作用域
变量作用域
作用域的注意方式：
对象创建的面试题demo
this
内存分析图：
this的注意细节
注意事项：
this在构造方法中调用构造方法注意（这种方法只能用在构造）
石头剪刀布小游戏demo
注意集合
方法使用注意：1. 可返回封装，设null，2.如果成员方法无局部变量，可以不写this.
对象注意：匿名对象只能使用一次，用完堆内存销毁 例如：new uer().init();
构造器之间的调用：（注意只有在开始的一条）不能有多条！
idea 工具
快捷键：自定义的：ctrl+alt+/ 代码规整化 ctrl+h 类的关系图 ...
包的命名规则
不能数字开头（二级名也一样）不能有关键字，保留字
java 四大包：lang（基本包），util（工具包），net（网络包），awt（gui界面开发包）
访问修饰符
public-> protected-> 没有修饰符-> private
注意事项：
对于4种类型来说，在同一个包下只能访问：public,protected,默认修饰符 而private不能被访问，它只能在同类中访问！
不同的包只能相互访问 public修饰
封装
继承
继承的注意事项：
1.子类继承了所有的属性和方法，非私有的属性和方法可以在子类中直接调用，但是私有的属性和方法不能在子类访问，要通过父类提供公共的方法去访问！
2.子类必须调用父类的构造器，完成父类的初始化，没有默认的，必须指定父类的构造器 通过 super（xxx，xxx）；
3.当创建子类，子类不管使用什么构造器都会调用 父类构造器，默认是无参构造器super()，没有默认的，必须指定父类的构造器 通过 super（xxx，xxx）；不然会编译失败！！
4.如果要调用父类的不是无参的构造器，显式去调用 通过 super（xxx，xxx）；
5.super在使用时 必须放在构造器第一行
6.super（）和this（）都只能放在构造器第一行，所以这两个方法不能共存！
7.java所有类都是object的子类
8.父类构造器的调用不限于直接父类! 将一直往上追溯直到Object类(顶级父类)
9.子类最多只能继承一个父类，java是单继承机制.
10.不能随便乱用继承，必须保证逻辑性，is a 的关系 例如：猫 是 动物 cat extend animal
继承的jvm内存分析
注意：
1.就进原则找，如果可以访问有权限，则返回，一直往上找，如果没有则报错！ 低 ->高 找！
super关键字（构造使用，属性使用，方法使用）
this.n ,super.n ,n的区别
这三者 其中this.n和n 相同，从子类查找，没有找到往上找，如果找到没有权限报错，如果一直没有找到也报错，spuer直接跳到子类最近的父类去查找，
this和n 的范围大于spuer
super和this的区别
一个是上一级，一个当前级，都是往上找
方法重写
重载和重写的区别，重载是方法名相同，但参数不同，返回值也可以不同，
重写是
1.方法名，返回类型，参数 必须和父类相同
2.满足条件1之后，父类的返回值可以是子类的父类 也可以 例如：object - String 是可以的
3.满足条件1之后，父类的方法 修饰符权限 不能被子类的 修饰符权限减小， 但是子类可以扩大权限
public - protected -默认 -private
多态
1.方法的多态（重写和重载就体现）
2.对象的多态
(Aniaml(这是编译类型) a = new cat9(这是运行类型))
1.一个对象的编译类型和运行类型可以不一致
2.编译类型在定义时就已经确定了不能改变，一次
3.运行类型是可以变化的
4.编译类型看 = 的左边 ，定义类型看 = 的右边
3.多态是建立在封装和继承之上的
对象的多态
对象的多态：至少两个对象是继承关系
多态的向上转型
1.父类引用指向子类（Animal a = new Cat);
2.语法：父类类型 引用名 = new 子类类型（）；
3.特点：
编译看左，运行看右
可以调用父类的所有成员（需遵守访问权限） 不能调用子类的特有方法和成员 依靠编译类型决定的
运行效果是 子类查重写方法 往上查， 最终按子类运行效果开始
多态的向下转型
注意： （父类的引用）
1.语法：子类类型 引用名 = （子类类型）父类引用
2.只能强转父类的引用的类型，不能强转父类的对象
3.父类的引用必须指向当前目标类型的对象 （先向上转型-父类指向子类目标类）
4.可以调用子类类型中的所有成员
多态的注意事项：
对象：（编译看左，运行看右）
1.向上转型 ：可以调用父类的所有方法（有权限）子类只能调用重写方法！
2.向下转型 ：只能强转父类的 引用类型 一一对应才行
调用子类类型中的所有成员
3.属性的值没有重写，看编译类型！
4.instanceOf ：操作符，用于判断 对象的运行类型 是否为 instanceOf xx 的xx的类型或者是子类型！
具体体现
多态的对象绑定机制（import）
注意：（多态）
1.当调用对象方法的时候，改方法会和对象的 内存地址/运行类型进行绑定，（会出现都有法，但调用的是运行类型）
2.属性没有此机制，哪里调用哪里使用！
多态数组demo（instanceof 进行 判断 向下转型 调方法）
通过 instanceof 进行 判断 向下转型
object类详解
1.==方法：
1.可以判断基本类型，也可以判断引用类型
2.如果判断基本类型，判断的值是否相等
3.如果判断引用类型，判断的地址是否相等
2.equals方法：
1.只能判断引用类型
2.默认判断的是地址是否相等，子类往往重写该方法，用于判断内容是否相等！
String的equals源码（都是继承与object的equals）重写
public boolean equals(Object anObject) {
if (this == anObject) { //判断是否同一个堆地址
return true;
}
//如果是string或者是string子类
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
//如果长度相等
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
//每个值进行遍历比较
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
重写equals方法练习
package com.jie.equalsAndDengHao.RewriteSourceCode;
/**
-
Created with IntelliJ IDEA.
-
@Author: 曾豪杰
-
@Date: 2022/10/04/17:38
-
@Description: 重写equals方法 */ public class Test {
public static void main(String[] args) { Person person = new Person("jack", 18, '男'); Person person1 = new Person("jack", 18, '男'); System.out.println(person.equals(person1)); } }
class Person {
private String name;
private int age;
private char gender;
private char[] value;
public Person(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
this.value = name.toCharArray();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
//重写
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (object instanceof Person) {
Person p = (Person) object;
return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender; //非引用用 ===
}
return false;
}
}
hashCode方法
生成独立的哈希值（根据地址号生成）
toString方法
原生tosTring 的地址就是 hashcode的十进制转为十六进制的数 一般重写，直接输出属性
finalize方法
默认 回收，释放资源的方法，gc算法，可以重写（释放资源等..）
断点调试
断点调试快捷键：
零钱通demo练习
代码：
package com.jie.project;
import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanner; /**
-
Created with IntelliJ IDEA.
-
@Author: 曾豪杰
-
@Date: 2022/10/05/11:11
-
@Description: 零钱通demo */ public class smail {
public static void main(String[] args) { Menu menu = new Menu(); menu.menus();//调用零钱通 }
//零钱通静态类 static class Menu { int n = 0;//数组计数 double profit = 0;//总钱 String[] infos = new String[300];//收益，消费信息数组 Scanner scanner = new Scanner(System.in); /** * @Description: 菜单 * @Param: [] * @return: void * @Author: 曾豪杰 * @Date: 2022/10/5 */ public void menus() { System.out.println("=====================零钱通===================="); System.out.println("\t\t\t\t1 零钱通明细"); System.out.println("\t\t\t\t2 收益入账"); System.out.println("\t\t\t\t3 消费"); System.out.println("\t\t\t\t4 退 出"); System.out.print("请输入编号(1-4)："); int i = scanner.nextInt();
switch (i) { case 1: detail();//调用零钱通明细方法 break; case 2: income();//调用零钱通收入方法 menus();//递归调用 break; case 3: pay();//调用零钱通消费方法 menus(); break; case 4: exit();//退出方法 break; default: System.out.println("你的编号不对！！"); menus(); break; } } //时间方法 public String time(Date date) { SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 设置日期格式 return simpleDateFormat.format(date); } //零钱通明细 public void detail(){ System.out.println("====================零钱通明细====================="); if (infos[0] == null) { System.out.println("占无零钱通明细！！"); menus(); } else { for (int j = 0; j < n; j++) {//遍历 输出信息 System.out.println(infos[j]); } menus(); } } //收入 public void income(){ System.out.println("====================收益入账====================="); System.out.print("请输入收益："); double v = scanner.nextDouble(); if(v<=0){ System.out.println("钱要大于0！！"); menus(); return; } profit += v;//加钱 String info = "收益入账 +" + v + " " + time(new Date()) + "\t" + "余额：" + profit; infos[n] = info;//信息放入数组 n++; System.out.println(info); } //消费 public void pay(){ System.out.println("====================消费====================="); System.out.print("消费内容:"); String next = scanner.next(); System.out.print("请输入消费："); double vs = scanner.nextDouble(); if(vs<=0){ System.out.println("钱要大于0！！"); menus(); return; } profit -= vs;//减钱 if (profit < 0) { System.out.println("余额不足，你的钱不够消费了!!!"); profit +=vs; menus(); return; } String infoss = "内容：" + next + " " + "消费 -" + vs + " " + time(new Date()) + "\t" + "余额：" + profit; infos[n] = infoss;//信息放入数组 n++; System.out.println(infoss); } //退出 public void exit(){ System.out.println("====================退出====================="); while (true) { System.out.println("你确定要退出？（y/n）"); char c = scanner.next().charAt(0); if (c == 'y') { System.out.println("退出成功！"); break; } } }}
什么是多态？
多态的对象绑定机制
代码总结
继续前行，寻找状态，积极调整
代码：
`package com.jie.practice;
/**
* Created with IntelliJ IDEA.
*
* @Author: 曾豪杰
* @Date: 2022/10/06/10:22
* @Description:
*/
public class Demo1 {
public static void main(String[] args) {
//demo1(对象里面的值冒泡排序)
Object[] person = new Object[3];
person[0] = new Person("小泽", "程序员", 188);
person[1] = new Person("小泽1", "程序员", 190);
person[2] = new Person("小泽2", "程序员", 20);
Object max;
for (int i = 0; i < person.length - i; i++) {
for (int j = 0; j < person.length - 1 - i; j++) {
if (((Person) person[j]).age < ((Person) person[j + 1]).age) { //向下转型
max = person[j];
person[j] = person[j + 1];
person[j + 1] = max;
}
}
}
System.out.println("从大到小进行排序：");
for (Object o : person) {
if (o instanceof Person) { //是否是该类 和子类
// System.out.print(((Person) o).age+" ");
((Person) o).show();
}
}
System.out.println();
//demo2(访问修饰符)
/* 同包 同类 子类 不同包
* 1.public 公共权限 可以 可以 可以 可以
* 2.protected 保护权限 可以 可以 可以
* 3.默认 默认权限 可以 可以
* 4.private 私有权限 可以 可以
* */
//demo3（老师类 3个子类 重写方法）
Teacher teacher = new Teacher("老师1", 26, "老师", 12000);
associateProfessor associateProfessor = new associateProfessor("副教授1", 25, "副教授", 15000);
lecturer lecturer = new lecturer("讲师1", 36, "讲师1", 39);
System.out.println(teacher.info());
System.out.println(associateProfessor.info());
System.out.println(lecturer.info());
//demo4(员工类 2个子类 重写方法)
divisionManager divisionManager = new divisionManager("部门经理1", 30);
OrdinaryEmployees ordinaryEmployees = new OrdinaryEmployees("普通员工1", 30);
System.out.println(divisionManager.showSalary(500));
System.out.println(ordinaryEmployees.showSalary(200));
//demo5(简单和上面类似)
//demo6(1.super可以访问g1 ，name，age，this可以访问id，score) （2.super可以访问g1 ，name，age .this可以访问bb g1）
//demo7(阅读题 简单)
//demo8()
System.out.println("---------------------------");
// Checking checking = new Checking(1000);
// checking.deposit(100);
// System.out.println(checking.getBalance());
SavingAccount savingAccount = new SavingAccount(1000);
savingAccount.deposit(1000);
savingAccount.deposit(200);
savingAccount.withdraw(200);
System.out.println(savingAccount.getBalance());
savingAccount.deposit(100);
System.out.println(savingAccount.getBalance());//2099
savingAccount.earn();
System.out.println(savingAccount.getBalance());
savingAccount.deposit(500);
savingAccount.deposit(500);
savingAccount.deposit(500);
System.out.println(savingAccount.getBalance());
savingAccount.deposit(80.01);
System.out.println(savingAccount.getBalance());
savingAccount.withdraw(1);
System.out.println(savingAccount.getBalance());
//demo9()
new LabeledPoint("Black Thurday", 1929, 256.6);
//demo10()
Doctor doctor = new Doctor("医生1", 18, "医生", "大夫", 1500);
Doctor doctor1 = new Doctor("医生11", 18, "医生", "大夫", 1500);
System.out.println(doctor.equals(doctor1));
//demo11
// Person person = new Student() //向上转型 只能调用子类被继承的方法，不能调用特有方法，子类到父类找 ，
// （（Student）student）//向下转型 能调用特有方法，子类到父类找
//demo 12
/*
* == 运算符 可以判断 基本类型 和引用类型 基本类型就比较值 引用类型就比较地址
* equals 方法 只能比较引用类型 ，重写的object的equals方法，源码是先比较地址，如果一样t，否则
* 就是 判断内容是否相同
* */
//demo 13
Object[] user = new Object[4]; //多态数组
user[0] = new Students("学生1", "男", 20, 199000546);
user[1] = new Students("学生2", "男", 18, 199000666);
user[2] = new Teachers("老师1", "女", 50, "500天");
user[3] = new Teachers("老师2", "女", 25, "300天");
int flag = 0;
Object Max;
for (Object value : user) {
if (value instanceof Persons) {
flag++;
}
}
if (flag == user.length) { //判断符合实际对象个数 是否与数组相同
for (int i = 0; i < user.length - 1; i++) {
for (int j = 0; j < user.length - 1 - i; j++) {
if (((Persons) user[j]).age < ((Persons) user[j + 1]).age) {//向下转型 通过对象的年龄进行冒泡排序
Max = user[j];
user[j] = user[j + 1];
user[j + 1] = Max;
}
}
}
}
System.out.println("从大到小进行排序：");
for (Object o : user) {
System.out.print(((Persons) o).age + " ");
}
System.out.println();
for (Object o : user) {
((Persons) o).show(((Persons) o));
}
System.out.println();
//demo14(阅读题)
//demo15
/*
* 多态是封装和继承基础之上的，多态体现在方法，对象，方法有重写，重载，对象有向上转型，向下转型，对象的动态绑定机制
* */
//demo16
/*
* 动态绑定机制是 当对象调用方法时，优先看运行类型的方法，例如 A有show方法，B有show方法，B继承A，在A里面new B，调用Show方法，调用的是B的show，没有则往上找！
* */
//demo17
}
static class Person {
private String name;
private String job;
private int age;
public Person(String name, String job, int age) {
this.name = name;
this.job = job;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", job='" + job + '\'' +
", age=" + age +
'}';
}
public void show() {
System.out.println("姓名：" + name + "工作：" + job + "年龄：" + age);
}
}
static class Teacher {
private String name;
private int age;
private String post;
private double salary;
public Teacher(String name, int age, String post, double salary) {
this.name = name;
this.age = age;
this.post = post;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getPost() {
return post;
}
public void setPost(String post) {
this.post = post;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String info() {
return "姓名：" + name + "\t年龄:" + age + "\t岗位:" + post + "\t工资:" + salary;
}
}
static class professor extends Teacher {
public professor(String name, int age, String post, double salary) {
super(name, age, post, salary);
}
@Override
public String info() {
return "教授的信息：" + "姓名：" + getName() + "\t年龄:" + getAge() + "\t岗位:" + getPost() + "\t工资:" + getSalary() * 1.3;
}
}
static class associateProfessor extends Teacher {
public associateProfessor(String name, int age, String post, double salary) {
super(name, age, post, salary);
}
@Override
public String info() {
return "副教授的信息：" + "姓名：" + getName() + "\t年龄:" + getAge() + "\t岗位:" + getPost() + "\t工资:" + getSalary() * 1.2;
}
}
static class lecturer extends Teacher {
public lecturer(String name, int age, String post, double salary) {
super(name, age, post, salary);
}
@Override
public String info() {
return "讲师的信息：" + "姓名：" + getName() + "\t年龄:" + getAge() + "\t岗位:" + getPost() + "\t工资:" + getSalary() * 1.1;
}
}
static class staff {
private String name;
private double salary;
private int workDay;
public staff(String name, int workDay) {
this.name = name;
this.workDay = workDay;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public int getWorkDay() {
return workDay;
}
public void setWorkDay(int workDay) {
this.workDay = workDay;
}
public String showSalary(double salary) {
double money = salary * workDay;
return "展示工资：" + money;
}
}
static class OrdinaryEmployees extends staff {
public OrdinaryEmployees(String name, int workDay) {
super(name, workDay);
}
@Override
public String showSalary(double salary) {
return "普通员工工资：" + salary * getWorkDay() * 1.0;
}
}
static class divisionManager extends staff {
public divisionManager(String name, int workDay) {
super(name, workDay);
}
@Override
public String showSalary(double salary) {
return "部门经理工资：" + (1000 + (salary * getWorkDay() * 1.2));
}
}
//demo8
static class BankAccount {
private double balance;
public BankAccount(double balance) {
this.balance = balance;
}
public void deposit(double amount) {
this.balance += amount;
}
public void withdraw(double amount) {
this.balance -= amount;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
static class Checking extends BankAccount {
private double sl;
public Checking(double balance) {
super(balance);
}
@Override
public void deposit(double amount) {
super.deposit(amount - 1);
sl++;
}
@Override
public void withdraw(double amount) {
super.withdraw(amount - 1);
sl++;
}
}
//每月3次免费
static class SavingAccount extends BankAccount {
private int count = 3;
private double rate = 0.01;
public SavingAccount(double balance) {
super(balance);
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public double getRate() {
return rate;
}
public void setRate(double rate) {
this.rate = rate;
}
@Override
public void deposit(double amount) {
if (count > 0) {
super.deposit(amount);
} else {
super.deposit(amount - 1);
}
count--;
}
@Override
public void withdraw(double amount) {
if (count > 0) {
super.withdraw(amount);
} else {
super.withdraw(amount + 1);
}
count--;
}
public void earn() {
count = 3;
super.deposit(getBalance() * rate);
}
}
//demo9
static class Point {
private double x;
private double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
}
static class LabeledPoint extends Point {
private String day;
public LabeledPoint(String day, double x, double y) {
super(x, y);
this.day = day;
}
}
//demo10
static class Doctor {
private String name;
private int age;
private String job;
private String gender;
private double sal;
public Doctor(String name, int age, String job, String gender, double sal) {
this.name = name;
this.age = age;
this.job = job;
this.gender = gender;
this.sal = sal;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
public boolean equals(Object object) {
if (object instanceof Doctor) {//向下转型进行判断
return this.name.equals(((Doctor) object).name) && this.age == ((Doctor) object).age && this.job.equals(((Doctor) object).job)
&& this.gender.equals(((Doctor) object).gender) && this.sal == ((Doctor) object).sal;
}
return false;
}
}
//demo13
static class Persons {
private String name;
private String sex;
private int age;
public Persons(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String play() {
return null;
}
public void show(Persons persons) {
if (persons instanceof Students) {
Students persons1 = (Students) persons;
System.out.println("学生的信息:");
System.out.println("姓名:" + name);
System.out.println("年龄:" + age);
System.out.println("性别:" + sex);
System.out.println("学号:" + persons1.stu_id);
persons1.study();
System.out.println(persons1.play());
}
if (persons instanceof Teachers) {
Teachers persons1 = (Teachers) persons;//向下转型
System.out.println("老师的信息:");
System.out.println("姓名:" + name);
System.out.println("年龄:" + age);
System.out.println("性别:" + sex);
System.out.println("工龄:" + persons1.work_age);
persons1.teacher();
System.out.println(persons1.play());
}
System.out.println("------------------------");
}
}
static class Students extends Persons {
private int stu_id;
public Students(String name, String sex, int age, int stu_id) {
super(name, sex, age);
this.stu_id = stu_id;
}
public int getStu_id() {
return stu_id;
}
public void setStu_id(int stu_id) {
this.stu_id = stu_id;
}
public void study() {
System.out.println("我会好好学习！");
}
@Override
public String play() {
return getName() + "爱玩篮球";
}
}
static class Teachers extends Persons {
private String work_age;
public Teachers(String name, String sex, int age, String work_age) {
super(name, sex, age);
this.work_age = work_age;
}
public String getWork_age() {
return work_age;
}
public void setWork_age(String work_age) {
this.work_age = work_age;
}
public void teacher() {
System.out.println("我会认真教学!");
}
@Override
public String play() {
return getName() + "爱下象棋!";
}
}
}
`
[](https://note.youdao.com/yws/api/personal/file/WEBd92afdd77a5481b5aec4cc4441422314?method=download&shareKey=5f486091569378dac99dc4c81968b6ef "1")
很喜欢老韩的一句话：“ber~ ，休息一下，我们再扬帆起航！”！
学校
生活
总结
经验
评论