1.案例驱动模式

1.1案例驱动模式概述 (理解)

通过我们已掌握的知识点,先实现一个案例,然后找出这个案例中,存在的一些问题,在通过新知识点解决问题

1.2案例驱动模式的好处 (理解)

  • 解决重复代码过多的冗余,提高代码的复用性
  • 解决业务逻辑聚集紧密导致的可读性差,提高代码的可读性
  • 解决代码可维护性差,提高代码的维护性

2.分类思想

2.1分类思想概述 (理解)

分工协作,专人干专事

2.2黑马信息管理系统 (理解)

  • Student类 标准学生类,封装键盘录入的学生信息(id , name , age , birthday)
  • StudentDao类 Dao : (Data Access Object 缩写) 用于访问存储数据的数组或集合
  • StudentService类 用来进行业务逻辑的处理(例如: 判断录入的id是否存在)
  • StudentController类 和用户打交道(接收用户需求,采集用户信息,打印数据到控制台)
    image.png

3.分包思想

3.1分包思想概述 (理解)

如果将所有的类文件都放在同一个包下,不利于管理和后期维护,所以,对于不同功能的类文件,可以放在不同的包下进行管理

3.2包的概述 (记忆)

  • 包
    本质上就是文件夹
  • 创建包
    多级包之间使用 “ . “ 进行分割
    多级包的定义规范：公司的网站地址翻转(去掉www)
    比如：黑马程序员的网站址为www.itheima.com
    后期我们所定义的包的结构就是：com.itheima.其他的包名
  • 包的命名规则
    字母都是小写

3.3包的注意事项 (理解)

  • package语句必须是程序的第一条可执行的代码
  • package语句在一个java文件中只能有一个
  • 如果没有package,默认表示无包名

3.4类与类之间的访问 (理解)

  • 同一个包下的访问
    不需要导包，直接使用即可
  • 不同包下的访问
    1.import 导包后访问
    2.通过全类名（包名 + 类名）访问
  • 注意：import 、package 、class 三个关键字的摆放位置存在顺序关系
    package 必须是程序的第一条可执行的代码
    import 需要写在 package 下面
    class 需要在 import 下面

4.黑马信息管理系统

4.1系统介绍 (理解)

image.png

4.2学生管理系统 (应用)

4.2.1需求说明

  • 添加学生: 键盘录入学生信息(id，name，age，birthday)
    使用数组存储学生信息,要求学生的id不能重复
  • 删除学生: 键盘录入要删除学生的id值,将该学生从数组中移除,如果录入的id在数组中不存在,需要重新录入
  • 修改学生: 键盘录入要修改学生的id值和修改后的学生信息
    将数组中该学生的信息修改,如果录入的id在数组中不存在,需要重新录入
  • 查询学生: 将数组中存储的所有学生的信息输出到控制台

4.2.2实现步骤

  • 环境搭建实现步骤
    | 包 | 存储的类 | 作用 | | —- | —- | —- | | com.itheima.edu.info.manager.domain | Student.java | 封装学生信息 | | com.itheima.edu.info.manager.dao | StudentDao.java | 访问存储数据的数组，进行赠删改查（库管） | | com.itheima.edu.info.manager.service | StudentService.java | 业务的逻辑处理（业务员） | | com.itheima.edu.info.manager.controller | StudentController.java | 和用户打交道（客服接待） | | com.itheima.edu.info.manager.entry | InfoManagerEntry.java | 程序的入口类，提供一个main方法 |

  • 菜单搭建实现步骤

    • 需求
      • 黑马管理系统菜单搭建
      • 学生管理系统菜单搭建
    • 实现步骤
      1. 展示欢迎页面,用输出语句完成主界面的编写
      2. 获取用户的选择,用Scanner实现键盘录入数据
      3. 根据用户的选择执行对应的操作,用switch语句完成操作的选择
  • 添加功能实现步骤
    image.png
  • 添加功能优化:判断id是否存在
    image.png
  • 查询功能实现步骤
    image.png
  • 删除功能实现步骤
    image.png
  • 修改功能实现步骤
    image.png
  • 系统优化
    • 把updateStudent和deleteStudentById中录入学生id代码抽取到一个方法(inputStudentId)中
      该方法的主要作用就是录入学生的id，方法的返回值为String类型
    • 把addStudent和updateStudent中录入学生信息的代码抽取到一个方法(inputStudentInfo)中
      该方法的主要作用就是录入学生的信息，并封装为学生对象，方法的返回值为Student类型

4.2.3代码实现

学生类

  1. public class Student {
  2.     private String id;
  3.     private String name;
  4.     private String age;
  5.     private String birthday;
  6.     String address;
  8.     public Student() {
  9.     }
  11.     public Student(String id, String name, String age, String birthday) {
  12.         this.id = id;
  13.         this.name = name;
  14.         this.age = age;
  15.         this.birthday = birthday;
  16.     }
  18.     public String getId() {
  19.         return id;
  20.     }
  22.     public void setId(String id) {
  23.         this.id = id;
  24.     }
  26.     public String getName() {
  27.         return name;
  28.     }
  30.     public void setName(String name) {
  31.         this.name = name;
  32.     }
  34.     public String getAge() {
  35.         return age;
  36.     }
  38.     public void setAge(String age) {
  39.         this.age = age;
  40.     }
  42.     public String getBirthday() {
  43.         return birthday;
  44.     }
  46.     public void setBirthday(String birthday) {
  47.         this.birthday = birthday;
  48.     }
  50. }

程序入口InfoManagerEntry类

  1. public class InfoManagerEntry {
  2.     public static void main(String[] args) {
  3.         Scanner sc = new Scanner(System.in);
  4.         while (true) {
  5.             // 主菜单搭建
  6.             System.out.println("--------欢迎来到黑马信息管理系统--------");
  7.             System.out.println("请输入您的选择: 1.学生管理  2.老师管理  3.退出");
  8.             String choice = sc.next();
  9.             switch (choice) {
  10.                 case "1":
  11.                     // System.out.println("学生管理");
  12.                     // 开启学生管理系统
  13.                     StudentController studentController = new StudentController();
  14.                     studentController.start();
  15.                     break;
  16.                 case "2":
  17.                     System.out.println("老师管理");
  18.                     TeacherController teacherController = new TeacherController();
  19.                     teacherController.start();
  20.                     break;
  21.                 case "3":
  22.                     System.out.println("感谢您的使用");
  23.                     // 退出当前正在运行的JVM虚拟机
  24.                     System.exit(0);
  25.                     break;
  26.                 default:
  27.                     System.out.println("您的输入有误, 请重新输入");
  28.                     break;
  29.             }
  30.         }
  31.     }
  32. }

StudentController类

  1. public class StudentController {
  2.     // 业务员对象
  3.     private StudentService studentService = new StudentService();
  5.     private Scanner sc = new Scanner(System.in);
  7.     // 开启学生管理系统, 并展示学生管理系统菜单
  8.     public void start() {
  9.         //Scanner sc = new Scanner(System.in);
  10.         studentLoop:
  11.         while (true) {
  12.             System.out.println("--------欢迎来到 <学生> 管理系统--------");
  13.             System.out.println("请输入您的选择: 1.添加学生  2.删除学生  3.修改学生  4.查看学生  5.退出");
  14.             String choice = sc.next();
  15.             switch (choice) {
  16.                 case "1":
  17.                     // System.out.println("添加");
  18.                     addStudent();
  19.                     break;
  20.                 case "2":
  21.                     // System.out.println("删除");
  22.                     deleteStudentById();
  23.                     break;
  24.                 case "3":
  25.                     // System.out.println("修改");
  26.                     updateStudent();
  27.                     break;
  28.                 case "4":
  29.                     // System.out.println("查询");
  30.                     findAllStudent();
  31.                     break;
  32.                 case "5":
  33.                     System.out.println("感谢您使用学生管理系统, 再见!");
  34.                     break studentLoop;
  35.                 default:
  36.                     System.out.println("您的输入有误, 请重新输入");
  37.                     break;
  38.             }
  39.         }
  40.     }
  42.     // 修改学生方法
  43.     public void updateStudent() {
  44.         String updateId = inputStudentId();
  45.         Student newStu = inputStudentInfo(updateId);
  46.         studentService.updateStudent(updateId, newStu);
  48.         System.out.println("修改成功!");
  49.     }
  51.     // 删除学生方法
  52.     public void deleteStudentById() {
  53.         String delId = inputStudentId();
  54.         // 3. 调用业务员中的deleteStudentById根据id, 删除学生
  55.         studentService.deleteStudentById(delId);
  56.         // 4. 提示删除成功
  57.         System.out.println("删除成功!");
  58.     }
  60.     // 查看学生方法
  61.     public void findAllStudent() {
  62.         // 1. 调用业务员中的获取方法, 得到学生的对象数组
  63.         Student[] stus = studentService.findAllStudent();
  64.         // 2. 判断数组的内存地址, 是否为null
  65.         if (stus == null) {
  66.             System.out.println("查无信息, 请添加后重试");
  67.             return;
  68.         }
  69.         // 3. 遍历数组, 获取学生信息并打印在控制台
  70.         System.out.println("学号\t\t姓名\t年龄\t生日");
  71.         for (int i = 0; i < stus.length; i++) {
  72.             Student stu = stus[i];
  73.             if (stu != null) {
  74.                 System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t\t" + stu.getBirthday());
  75.             }
  76.         }
  77.     }
  79.     // 添加学生方法
  80.     public void addStudent() {
  81.         // StudentService studentService = new StudentService();
  82.         // 1. 键盘接收学生信息
  83.         String id;
  84.         while (true) {
  85.             System.out.println("请输入学生id:");
  86.             id = sc.next();
  87.             boolean flag = studentService.isExists(id);
  88.             if (flag) {
  89.                 System.out.println("学号已被占用, 请重新输入");
  90.             } else {
  91.                 break;
  92.             }
  93.         }
  95.         Student stu = inputStudentInfo(id);
  97.         // 3. 将学生对象,传递给StudentService(业务员)中的addStudent方法
  98.         boolean result = studentService.addStudent(stu);
  99.         // 4. 根据返回的boolean类型结果, 在控制台打印成功\失败
  100.         if (result) {
  101.             System.out.println("添加成功");
  102.         } else {
  103.             System.out.println("添加失败");
  104.         }
  105.     }
  107.     // 键盘录入学生id
  108.     public String inputStudentId() {
  109.         String id;
  110.         while (true) {
  111.             System.out.println("请输入学生id:");
  112.             id = sc.next();
  113.             boolean exists = studentService.isExists(id);
  114.             if (!exists) {
  115.                 System.out.println("您输入的id不存在, 请重新输入:");
  116.             } else {
  117.                 break;
  118.             }
  119.         }
  120.         return id;
  121.     }
  123.     // 键盘录入学生信息
  124.     public Student inputStudentInfo(String id) {
  125.         System.out.println("请输入学生姓名:");
  126.         String name = sc.next();
  127.         System.out.println("请输入学生年龄:");
  128.         String age = sc.next();
  129.         System.out.println("请输入学生生日:");
  130.         String birthday = sc.next();
  131.         Student stu = new Student();
  132.         stu.setId(id);
  133.         stu.setName(name);
  134.         stu.setAge(age);
  135.         stu.setBirthday(birthday);
  136.         return stu;
  137.     }
  138. }

StudentService类

  1. public class StudentService {
  2.     // 创建StudentDao (库管)
  3.     private StudentDao studentDao = new StudentDao();
  4.     // 添加学生方法
  5.     public boolean addStudent(Student stu) {
  6.         // 2. 将学生对象, 传递给StudentDao 库管中的addStudent方法
  7.         // 3. 将返回的boolean类型结果, 返还给StudentController
  8.         return studentDao.addStudent(stu);
  9.     }
  10.     // 判断学号是否存在方法
  11.     public boolean isExists(String id) {
  12.         Student[] stus = studentDao.findAllStudent();
  13.         // 假设id在数组中不存在
  14.         boolean exists = false;
  15.         // 遍历数组, 获取每一个学生对象, 准备进行判断
  16.         for (int i = 0; i < stus.length; i++) {
  17.             Student student = stus[i];
  18.             if(student != null && student.getId().equals(id)){
  19.                 exists = true;
  20.                 break;
  21.             }
  22.         }
  24.         return exists;
  25.     }
  26.     // 查看学生方法
  27.     public Student[] findAllStudent() {
  28.         // 1. 调用库管对象的findAllStudent获取学生对象数组
  29.         Student[] allStudent = studentDao.findAllStudent();
  30.         // 2. 判断数组中是否有学生信息 (有: 返回地址,  没有: 返回null)
  31.         // 思路: 数组中只要存在一个不是null的元素, 那就代表有学生信息
  32.         boolean flag = false;
  33.         for (int i = 0; i < allStudent.length; i++) {
  34.             Student stu = allStudent[i];
  35.             if(stu != null){
  36.                 flag = true;
  37.                 break;
  38.             }
  39.         }
  41.         if(flag){
  42.             // 有信息
  43.             return allStudent;
  44.         }else{
  45.             // 没有信息
  46.             return null;
  47.         }
  49.     }
  51.     public void deleteStudentById(String delId) {
  52.         studentDao.deleteStudentById(delId);
  53.     }
  55.     public void updateStudent(String updateId, Student newStu) {
  56.         studentDao.updateStudent(updateId, newStu);
  57.     }
  58. }

StudentDao类

  1. public class StudentDao {
  2.     // 创建学生对象数组
  3.     private static Student[] stus = new Student[5];
  4.     // 添加学生方法
  5.     public boolean addStudent(Student stu) {
  7.         // 2. 添加学生到数组
  8.         //2.1 定义变量index为-1，假设数组已经全部存满，没有null的元素
  9.         int index = -1;
  10.         //2.2 遍历数组取出每一个元素，判断是否是null
  11.         for (int i = 0; i < stus.length; i++) {
  12.             Student student = stus[i];
  13.             if(student == null){
  14.                 index = i;
  15.                 //2.3 如果为null，让index变量记录当前索引位置，并使用break结束循环遍历
  16.                 break;
  17.             }
  18.         }
  20.         // 3. 返回是否添加成功的boolean类型状态
  21.         if(index == -1){
  22.             // 装满了
  23.             return false;
  24.         }else{
  25.             // 没有装满, 正常添加, 返回true
  26.             stus[index] = stu;
  27.             return true;
  28.         }
  29.     }
  30.     // 查看学生方法
  31.     public Student[] findAllStudent() {
  32.         return stus;
  33.     }
  35.     public void deleteStudentById(String delId) {
  36.         // 1. 查找id在容器中所在的索引位置
  37.         int index = getIndex(delId);
  38.         // 2. 将该索引位置,使用null元素进行覆盖
  39.         stus[index] = null;
  40.     }
  42.     public int getIndex(String id){
  43.         int index = -1;
  44.         for (int i = 0; i < stus.length; i++) {
  45.             Student stu = stus[i];
  46.             if(stu != null && stu.getId().equals(id)){
  47.                 index = i;
  48.                 break;
  49.             }
  50.         }
  51.         return index;
  52.     }
  54.     public void updateStudent(String updateId, Student newStu) {
  55.         // 1. 查找updateId, 在容器中的索引位置
  56.         int index = getIndex(updateId);
  57.         // 2. 将该索引位置, 使用新的学生对象替换
  58.         stus[index] = newStu;
  59.     }
  60. }

4.3老师管理系统 (应用)

4.3.1需求说明

  • 添加老师: 通过键盘录入老师信息(id，name，age，birthday)
    使用数组存储老师信息,要求老师的id不能重复
  • 删除老师: 通过键盘录入要删除老师的id值,将该老师从数组中移除,如果录入的id在数组中不存在,需要重新录入
  • 修改老师: 通过键盘录入要修改老师的id值和修改后的老师信息
    将数组中该老师的信息修改,如果录入的id在数组中不存在,需要重新录入
  • 查询老师: 将数组中存储的所有老师的信息输出到控制台

4.3.2实现步骤

  • 环境搭建实现步骤
    | 包 | 存储的类 | 作用 | | —- | —- | —- | | com.itheima.edu.info.manager.domain | Student.java Teacher.java | 封装学生信息 封装老师信息 | | com.itheima.edu.info.manager.dao | StudentDao.java TeacherDao.java | 访问存储数据的数组,进行赠删改查（库管） | | com.itheima.edu.info.manager.service | StudentService.java TeacherService.java | 业务的逻辑处理（业务员） | | com.itheima.edu.info.manager.controller | StudentController.java TeacherController.java | 和用户打交道（客服接待） | | com.itheima.edu.info.manager.entry | InfoManagerEntry.java | 程序的入口类,提供一个main方法 |

  • 菜单搭建实现步骤

    1. 展示欢迎页面,用输出语句完成主界面的编写
    2. 获取用户的选择,用Scanner实现键盘录入数据
    3. 根据用户的选择执行对应的操作,用switch语句完成操作的选择
  • 添加功能实现步骤
    image.png
  • 查询功能实现步骤
    image.png
  • 删除功能实现步骤
    image.png
  • 修改功能实现步骤
    image.png
  • 系统优化
    • 把updateTeacher和deleteTeacherById中录入老师id代码抽取到一个方法(inputTeacherId)中
      该方法的主要作用就是录入老师的id,方法的返回值为String类型
    • 把addTeacher和updateTeacher中录入老师信息的代码抽取到一个方法(inputTeacherInfo)中
      该方法的主要作用就是录入老师的信息,并封装为老师对象,方法的返回值为Teacher类型

4.3.3代码实现

老师类

  1. public class Teacher extends Person{
  2.     private String id;
  3.     private String name;
  4.     private String age;
  5.     private String birthday;
  6.     String address;
  8.     public Teacher() {
  9.     }
  11.     public Teacher(String id, String name, String age, String birthday) {
  12.         this.id = id;
  13.         this.name = name;
  14.         this.age = age;
  15.         this.birthday = birthday;
  16.     }
  18.     public String getId() {
  19.         return id;
  20.     }
  22.     public void setId(String id) {
  23.         this.id = id;
  24.     }
  26.     public String getName() {
  27.         return name;
  28.     }
  30.     public void setName(String name) {
  31.         this.name = name;
  32.     }
  34.     public String getAge() {
  35.         return age;
  36.     }
  38.     public void setAge(String age) {
  39.         this.age = age;
  40.     }
  42.     public String getBirthday() {
  43.         return birthday;
  44.     }
  46.     public void setBirthday(String birthday) {
  47.         this.birthday = birthday;
  48.     }
  49. }

TeacherController类

  1. public class TeacherController {
  3.     private Scanner sc = new Scanner(System.in);
  4.     private TeacherService teacherService = new TeacherService();
  6.     public void start() {
  8.         teacherLoop:
  9.         while (true) {
  10.             System.out.println("--------欢迎来到 <老师> 管理系统--------");
  11.             System.out.println("请输入您的选择: 1.添加老师  2.删除老师  3.修改老师  4.查看老师  5.退出");
  12.             String choice = sc.next();
  13.             switch (choice) {
  14.                 case "1":
  15.                     // System.out.println("添加老师");
  16.                     addTeacher();
  17.                     break;
  18.                 case "2":
  19.                     // System.out.println("删除老师");
  20.                     deleteTeacherById();
  21.                     break;
  22.                 case "3":
  23.                     // System.out.println("修改老师");
  24.                     updateTeacher();
  25.                     break;
  26.                 case "4":
  27.                     // System.out.println("查看老师");
  28.                     findAllTeacher();
  29.                     break;
  30.                 case "5":
  31.                     System.out.println("感谢您使用老师管理系统, 再见!");
  32.                     break teacherLoop;
  33.                 default:
  34.                     System.out.println("您的输入有误, 请重新输入");
  35.                     break;
  36.             }
  37.         }
  39.     }
  41.     public void updateTeacher() {
  42.         String id = inputTeacherId();
  44.         Teacher newTeacher = inputTeacherInfo(id);
  46.         // 调用业务员的修改方法
  47.         teacherService.updateTeacher(id,newTeacher);
  48.         System.out.println("修改成功");
  49.     }
  51.     public void deleteTeacherById() {
  53.         String id = inputTeacherId();
  55.         // 2. 调用业务员中的删除方法, 根据id, 删除老师
  56.         teacherService.deleteTeacherById(id);
  58.         // 3. 提示删除成功
  59.         System.out.println("删除成功");
  62.     }
  64.     public void findAllTeacher() {
  65.         // 1. 从业务员中, 获取老师对象数组
  66.         Teacher[] teachers = teacherService.findAllTeacher();
  68.         // 2. 判断数组中是否有元素
  69.         if (teachers == null) {
  70.             System.out.println("查无信息, 请添加后重试");
  71.             return;
  72.         }
  74.         // 3. 遍历数组, 取出元素, 并打印在控制台
  75.         System.out.println("学号\t\t姓名\t年龄\t生日");
  76.         for (int i = 0; i < teachers.length; i++) {
  77.             Teacher t = teachers[i];
  78.             if (t != null) {
  79.                 System.out.println(t.getId() + "\t" + t.getName() + "\t" + t.getAge() + "\t\t" + t.getBirthday());
  80.             }
  81.         }
  82.     }
  84.     public void addTeacher() {
  85.         String id;
  86.         while (true) {
  87.             // 1. 接收不存在的老师id
  88.             System.out.println("请输入老师id:");
  89.             id = sc.next();
  90.             // 2. 判断id是否存在
  91.             boolean exists = teacherService.isExists(id);
  93.             if (exists) {
  94.                 System.out.println("id已被占用, 请重新输入:");
  95.             } else {
  96.                 break;
  97.             }
  98.         }
  100.         Teacher t = inputTeacherInfo(id);
  102.         // 5. 将封装好的老师对象, 传递给TeacherService继续完成添加操作
  103.         boolean result = teacherService.addTeacher(t);
  105.         if (result) {
  106.             System.out.println("添加成功");
  107.         } else {
  108.             System.out.println("添加失败");
  109.         }
  110.     }
  112.     // 录入老师id
  113.     public String inputTeacherId(){
  114.         String id;
  115.         while(true){
  116.             System.out.println("请输入id");
  117.             id = sc.next();
  118.             boolean exists = teacherService.isExists(id);
  119.             if(!exists){
  120.                 System.out.println("您输入的id不存在, 请重新输入:");
  121.             }else{
  122.                 break;
  123.             }
  124.         }
  125.         return id;
  126.     }
  128.     // 录入老师信息, 封装为老师对象
  129.     public Teacher inputTeacherInfo(String id){
  130.         System.out.println("请输入老师姓名:");
  131.         String name = sc.next();
  132.         System.out.println("请输入老师年龄:");
  133.         String age = sc.next();
  134.         System.out.println("请输入老师生日:");
  135.         String birthday = sc.next();
  137.         Teacher t = new Teacher();
  138.         t.setId(id);
  139.         t.setName(name);
  140.         t.setAge(age);
  141.         t.setBirthday(birthday);
  143.         return t;
  144.     }
  145. }

TeacherService类

  1. public class TeacherService {
  3.     private TeacherDao teacherDao = new TeacherDao();
  5.     public boolean addTeacher(Teacher t) {
  6.         return teacherDao.addTeacher(t);
  7.     }
  9.     public boolean isExists(String id) {
  10.         // 1. 获取库管对象中的数组
  11.         Teacher[] teachers = teacherDao.findAllTeacher();
  13.         boolean exists = false;
  15.         // 2. 遍历数组, 取出每一个元素, 进行判断
  16.         for (int i = 0; i < teachers.length; i++) {
  17.             Teacher teacher = teachers[i];
  18.             if(teacher != null && teacher.getId().equals(id)){
  19.                 exists = true;
  20.                 break;
  21.             }
  22.         }
  24.         return exists;
  25.     }
  27.     public Teacher[] findAllTeacher() {
  28.         Teacher[] allTeacher = teacherDao.findAllTeacher();
  30.         boolean flag = false;
  32.         for (int i = 0; i < allTeacher.length; i++) {
  33.             Teacher t = allTeacher[i];
  34.             if(t != null){
  35.                 flag = true;
  36.                 break;
  37.             }
  38.         }
  40.         if(flag){
  41.             return allTeacher;
  42.         }else{
  43.             return null;
  44.         }
  46.     }
  48.     public void deleteTeacherById(String id) {
  49.         teacherDao.deleteTeacherById(id);
  50.     }
  52.     public void updateTeacher(String id, Teacher newTeacher) {
  53.         teacherDao.updateTeacher(id,newTeacher);
  54.     }
  55. }

TeacherDao类

  1. public class TeacherDao {
  3.     private static Teacher[] teachers = new Teacher[5];
  5.     public boolean addTeacher(Teacher t) {
  6.         int index = -1;
  7.         for (int i = 0; i < teachers.length; i++) {
  8.             Teacher teacher = teachers[i];
  9.             if(teacher == null){
  10.                 index = i;
  11.                 break;
  12.             }
  13.         }
  15.         if(index == -1){
  16.             return false;
  17.         }else{
  18.             teachers[index] = t;
  19.             return true;
  20.         }
  22.     }
  24.     public Teacher[] findAllTeacher() {
  25.         return teachers;
  26.     }
  28.     public void deleteTeacherById(String id) {
  29.         // 1. 查询id在数组中的索引位置
  30.         int index = getIndex(id);
  31.         // 2. 将该索引位置的元素, 使用null进行替换
  32.         teachers[index] = null;
  33.     }
  35.     public int getIndex(String id){
  36.         int index = -1;
  37.         for (int i = 0; i < teachers.length; i++) {
  38.             Teacher t = teachers[i];
  39.             if(t != null && t.getId().equals(id)){
  40.                 index = i;
  41.                 break;
  42.             }
  43.         }
  45.         return index;
  46.     }
  48.     public void updateTeacher(String id, Teacher newTeacher) {
  49.         int index = getIndex(id);
  50.         teachers[index] = newTeacher;
  51.     }
  52. }

5.static关键字

5.1static关键字概述 (理解)

static 关键字是静态的意思,是Java中的一个修饰符,可以修饰成员方法,成员变量

5.2static修饰的特点 (记忆)

  • 被类的所有对象共享
    是我们判断是否使用静态关键字的条件
  • 随着类的加载而加载，优先于对象存在
    对象需要类被加载后，才能创建
  • 可以通过类名调用
    也可以通过对象名调用

5.3static关键字注意事项 (理解)

  • 静态方法只能访问静态的成员
  • 非静态方法可以访问静态的成员，也可以访问非静态的成员
  • 静态方法中是没有this关键字