Java进阶一

教务管理系统（以数组为核心）

大纲:

​ 分类分包思想 【重点】

​ 教务管理系统（以学生管理系统为例） 【重点】

​ static 【重点】

​

分类分包思想

1.作用

• 提高代码的复用性
• 提高代码的可读性
• 提高代码的维护性

2.什么是分类思想

2.1形象定义

分工协作，专人干专事

2.2什么是分类

对类进行拆分，不要把所有功能往一个类中进行编写

将类拆分成很多类共同来完成原来的类的功能

2.3为什么要分类

 提高代码的可读性
 提高代码的复用性
 提高代码的可维护性
 提高代码的拓展性

2.4如何分类

Controller（主要） :和用户打交道（键盘录入，用户交互）
Servicer（主要）   ：处理业务逻辑
Dao（主要）		   ：和数据打交道（目前增删查改主要都放在这）
util工具类（辅助）	 ：工具类	Arrays/Math 数组/数学
ddomain标准类（辅助）：用来封装数据，也叫描述；类，javabean封装数据
    

黑马信息管理系统分类

• Student 类 标准学生类，封装键盘录入的学生信息（id , name , age , birthday）

• StudentDao 类 Dao: (Data Access Object 缩写) 用于访问存储数据的数组或集合

• StudentService 类 用来进行业务逻辑的处理（例如：判断录入的id是否存在）

• StudentController 和用户打交道（接收用户需求，采集用户信息，打印数据到控制台）

3.什么是分包思想

3.1包的定义

package，本质上是一个文件夹
定义的时候可以单级也可以多级，多级用“.”隔开，一般包命令都是小写，是公司域名倒着写

3.2包的作用

用于分类管理类

3.2包的注意事项

3.3类与类之间的访问

同一个包下的类可以相互访问，直接访问

不同包下的相互访问
    1.先导包后访问(import)	---推荐
    2.通过全类名(包名+类名)

全类名使用场景：在同一个大类中，测试类使用两个包（都在大类中）下相同的类名

使用方法：

如果是java.long包下的类，也可以直接访问的，不需要通过以上方式访问

需求说明

系统介绍

需求说明

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

环境搭建

包	存储的类	作用
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方法

访问顺序

controller -> service -> dao
    调用从前往后，调用的时候会通过方法参数传递数据
    调用完毕之后，如果有数据返回，则从后往前返回

额外重点

1.退出：

​ continue：退出当前循环，不影响下次循环

​ break：结束当前最近的循环，跳出循环

​ return：结束方法，跳出方法

​ System.exit(0) 结束JVM虚拟机，跳出程序（实际开发基本不用，测试用）

详情步骤

1.编写Student标准类

包的位置：

详情代码：

package com.itheima.edu.info.manager.domain;

public class Student {
    private String  id;
    private String name;
    private String  age;
    private  String birthday;

    public Student() {
    }

    public Student(String id, String name, String age, String birthday) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}

2.编写主方法类（测试类）

（也叫菜单搭建）

包的位置：

运行结果:

运行代码：

package com.itheima.edu.info.manager.entry;

import com.itheima.edu.info.manager.controller.StudentController;

import java.util.Scanner;

public class ImfoManagerEntry {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //主菜单搭建
        while (true) {      //无限循环
        System.out.println("--------欢迎来到黑马信息管理系统--------");
        System.out.println("请输入您的选择:1.学生管理 2.老师管理 3.退出");
        String choice = sc.nextLine();

            switch (choice) {
            case "1":
//                System.out.println("学生管理");
//                开启学生管理系统
                StudentController studentController = new StudentController();
                studentController.start();
                break;
            case "2": System.out.println("老师管理");
                break;
            case "3": System.out.println("感谢您的使用");
                 //退出当前正在运行的JVM虚拟机
                 System.exit(0);
                break;
            default:
                System.out.println("您的输入有误，请重新输入!");
            }
        }
    }
}

3.编写客服接待类

包的位置：

运行结果：

详情代码：

package com.itheima.edu.info.manager.controller;

import com.itheima.edu.info.manager.domain.Student;
import com.itheima.edu.info.manager.service.StudentService;

import java.util.Scanner;

public class StudentController {

    private StudentService studentService = new StudentService();
    Scanner sc = new Scanner(System.in);

    //开启学生管理系统，并展示学生关系系统菜单
    public void start() {
//        Scanner sc = new Scanner(System.in);
        studentLoop:
        while (true) {
            System.out.println("--------欢迎来到 <学生> 管理系统--------");
            System.out.println("请输入您的选择:1.添加学生 2.删除学生 3.修改学生 4.查看学生 5.退出");
            String choice = sc.nextLine();

            switch (choice) {
            case "1":
//                System.out.println("添加学生");
                addStudent();
                break;
            case "2":
//                System.out.println("删除学生");
                deleteStudentById();
                break;
            case "3":
//                System.out.println("修改学生");
                updateStudent();
                break;
            case "4":
//                System.out.println("查看学生");
                findAllStudent();
                break;
            case "5": System.out.println("感谢您使用学生管理系统，再见!");
                break studentLoop;
            default:
                System.out.println("您的输入有误，请重新输入!");
            }
        }
    }

    //添加学生
    public void addStudent() {
//        StudentService studentService = new StudentService();
//            1.键盘接受学生信息
//        Scanner sc = new Scanner(System.in);
        String sid;
        while (true) {
            System.out.println("请输入学生的ID:");
            sid = sc.nextLine();
            boolean flag = studentService.isExists(sid);
            if (flag) {
                System.out.println("学生已被占用，请重新输入!");
            } else {
                break;
            }
        }
//        String sid = inputStudentId();
//        System.out.println("请输入学生的姓名:");
//        String sname = sc.nextLine();
//        System.out.println("请输入学生的年龄:");
//        String sage = sc.nextLine();
//        System.out.println("请输入学生的生日:");
//        String sbirthday = sc.nextLine();
            2.将学生信息封装为学生对象
//        Student stu = new Student(sid, sname, sage, sbirthday);

//            3.将学生对象，传递给StudentService(业务员)中的addStduent方法
        Student stu = inputStudentInfo(sid);
        boolean result = studentService.addStudent(stu);
//            4.根据返回的boolaean类型结果，在控制台打印成功\失败
        if (result) {
            System.out.println("添加成功!");
        } else {
            System.out.println("添加失败");
        }
    }

    //删除学生
    public void deleteStudentById() {
        //        额外.调用业务员中的获取方法，得到学生的对象数组
        Student[] stus = studentService.findAllStudent();
//        额外.判断数组的内存地址是否为null
        if (stus == null) {
            System.out.println("查无信息,请添加后重试");
            return;
        }
//        1.键盘录入要删除的学生id
//        Scanner sc = new Scanner(System.in);
//        String delId;
//        while (true) {
//            System.out.println("请输入要删除的学生ID:");
//            //        2.判断id在容器中是否存在，如果不存在，则需要一直录入
//            delId = sc.nextLine();
//            boolean exists = studentService.isExists(delId);
//            if (!exists) {
//                System.out.println("您输入的id不存在，请重新输入");
//            } else {
//                break;
//            }
//        }
        String delId = inputStudentId();
//        3.调用业务员中的deleteStudentById根据id删除学生
        studentService.deleteStudentById(delId);
//        4.提示删除成功
        System.out.println("删除成功！");
    }

    //查找学生
    public void findAllStudent() {
//        1.调用业务员中的获取方法，得到学生的对象数组
        Student[] stus = studentService.findAllStudent();
//        2.判断数组的内存地址是否为null
        if (stus == null) {
            System.out.println("查无信息,请添加后重试");
            return;
        } else {
//        3.遍历数组，获取学生信息并打印在控制台
            System.out.println("学号\t\t姓名\t\t年龄\t\t生日\t\t");
            for (int i = 0; i < stus.length; i++) {
                Student stu = stus[i];
                if (stu != null) {
                    System.out.println(stu.getId() + "\t\t" + stu.getName() + "\t" + stu.getAge() + "\t" + stu.getBirthday());
                }
            }
        }
    }

    //修改学生
    public void updateStudent() {
        //        额外.调用业务员中的获取方法，得到学生的对象数组
        Student[] stus = studentService.findAllStudent();
//        额外.判断数组的内存地址是否为null
        if (stus == null) {
            System.out.println("查无信息,请添加后重试");
            return;
        }

//        String updateId;
//        while (true) {
//            //1.键盘录入要删除的学生id
//            System.out.println("请输入您要修改的学生id:");
//            updateId = sc.nextLine();
//            //2.判断id在容器中是否存在，如果不存在，则需要一直录入
//            boolean exists = studentService.isExists(updateId);
//            if (!exists) {
//                System.out.println("您输入的id不存在，请重新输入:");
//            } else {
//                break;
//            }
//
//        }
        String sid = inputStudentId();
//        System.out.println("请输入学生姓名:");
//        String sName = sc.nextLine();
//        System.out.println("请输入学生年龄:");
//        String sAge = sc.nextLine();
//        System.out.println("请输入学生生日:");
//        String sBirthday = sc.nextLine();
//        Student stu = new Student(sid, sName, sAge, sBirthday);

        Student stu = inputStudentInfo(sid);
        studentService.updateStudent(sid, stu);
        System.out.println("修改成功！");
    }





    //代码优化
    public String inputStudentId() {
        String id;
        while (true) {
            //1.键盘录入学生id
            System.out.println("请输入学生id:");
            id = sc.nextLine();
            //2.判断id在容器中是否存在，如果不存在，则需要一直录入
            boolean exists = studentService.isExists(id);
            if (!exists) {
                System.out.println("您输入的id不存在，请重新输入:");
            } else {
                break;
            }

        }
        return  id;
    }

    //键盘录入学生信息
    public Student inputStudentInfo(String sid){
        System.out.println("请输入学生的姓名:");
        String sname = sc.nextLine();
        System.out.println("请输入学生的年龄:");
        String sage = sc.nextLine();
        System.out.println("请输入学生的生日:");
        String sbirthday = sc.nextLine();
//            2.将学生信息封装为学生对象
        Student stu = new Student(sid, sname, sage, sbirthday);
        return  stu;
    }
}

4.编写业务逻辑类

包的位置：

详情代码：

package com.itheima.edu.info.manager.service;

import com.itheima.edu.info.manager.dao.StudentDao;
import com.itheima.edu.info.manager.domain.Student;

public class StudentService {
     private StudentDao studentDao = new StudentDao();
    public boolean addStudent(Student stu) {
        //1.创建StudentDao(库管)
        //2.将学生对象,传递给StudentDao库管中的addStudent方法

//        studentDao.addStudent(stu);
        //3.将返回的boolean类型结果，返回给StudentController

        return  studentDao.addStudent(stu);
    }

    public boolean isExists(String sid) {

         Student[] stus = studentDao.fandAllStudent();
         //假设id在数组中不存在
         boolean exists = false;
        for (int i = 0; i < stus.length; i++) {
            Student student = stus[i];
            if (student != null && student.getId().equals(sid)){
                    exists = true;
                    break;
            }
        }
        return  exists;
    }

    public Student[] findAllStudent() {
        //1.调用库存对象的findAllStudent获取学生对象数组
        Student[] allStudent = studentDao.fandAllStudent();
        //2.判断数组中是否有学生信息(有：返回地址，没有：返回null)
//      思路: 数组中只要存在一个不是null的元素，那就代表有学生信息
         boolean flag = false;
        for (int i = 0; i < allStudent.length; i++) {
            Student stu = allStudent[i];
            if (stu != null){
                flag =true;
                 break;
            }
        }


        if (flag){
            //有信息
            return  allStudent;
        }else {
            //没有信息
            return null;
        }
    }

    public void deleteStudentById(String delId) {
        studentDao.deleteStudentById(delId);
    }


    public void updateStudent(String updateId, Student newStu) {
        studentDao.updateStudent(updateId,newStu);
    }
}

5.编写库管类

包的位置：

代码详情：

package com.itheima.edu.info.manager.dao;

import com.itheima.edu.info.manager.domain.Student;

public class StudentDao {
    private  static Student[] stus = new Student[5];

    public boolean addStudent(Student stu) {

        //1.创建Student学生对象数组
        //2.添加学生到数组
        //2.1 定义变量index为-1,假设数组已经全部存满，没有null的元素
        int index = -1;
        //2.2 遍历数组取出每一个元素，判断是否为null
        for (int i = 0; i < stus.length; i++) {
            Student student = stus[i];
            if (student == null) {
                index = i;
                //2.3如果为null，让index变量记录当前索引位置，并使用break结束循环
                break;
            }
        }

        //3.返回是否添加成功的Boolean类型状态
        if (index == -1) {
            //装满了
            return false;
        } else {
            stus[index] = stu;
            return true;
        }
    }


    public Student[] fandAllStudent() {
        return stus;
    }

    public void deleteStudentById(String delId) {
//        查找id在容器找给你所在的索引位置
        int index = getIndex(delId);
//        将该索引位置，使用null元素进行覆盖
        stus[index] = null;
    }
//   查找索引位置
    public  int getIndex(String id){
        int index = -1;
        for (int i = 0; i < stus.length; i++) {
            Student stu = StudentDao.stus[i];
            if (stu != null && stu.getId().equals(id)){
                index = i;
            }
        }
        return index;
    }

    public void updateStudent(String updateId, Student newStu) {
        //1，查找updateId，在容器中的索引位置
        int index = getIndex(updateId);
        //2.将索引位置，使用新的学生对象替换
        stus[index] = newStu;
    }
}

static关键字

1.定义

static 关键字是静态的意思，是Java中的一个修饰符，可以修饰成员方法，成员变量和代码块
被static修饰的成员变量，一般叫做静态变量
被static修饰的成员方法，一般叫做静态方法

2.特点

1，属于类的，被这个类的所有对象所共享，而不是属于这个类的某一个对象
2，随着类的加载而执行，出现的时机是很早的
3，多了一种调用方式，通过   类名.进行调用

3.修饰成员变量

理解static修饰成员变量后的特点？

被static修饰的成员变量，被所在类的所有对象共享（这个类的这个成员变量的值都是相同的）

4.注意事项

静态方法中，只能访问静态成员(成员变量，成员方法)，也可以访问非静态成员，静态方法里面没有关键字
    
什么时候使用static修饰成员变量？
    一般不使用static修饰成员变量，只要满足以下两个条件才会修饰：
    1，如果一个类的这个成员变量的值，对于所有的对象来说都是相同的值，那么这个变量就可以使用static修饰
    2，如果想在一个静态的方法中直接使用某个成员变量，那么这个成员变量也可以使用static修饰
    
 什么情况下使用static修饰成员方法？
    一般不使用static修饰成员方法，只有满足以下两个条件才会修饰：
    1，在工具类中，所有的方法都应该使用static修饰，方便调用
    2，如果想在一个静态的方法中直接调用某个方法，那么这个方法也可以使用static修饰

1.定义

static 关键字是静态的意思，是Java中的一个修饰符，可以修饰成员方法，成员变量和代码块
被static修饰的成员变量，一般叫做静态变量
被static修饰的成员方法，一般叫做静态方法

2.特点

1，属于类的，被这个类的所有对象所共享，而不是属于这个类的某一个对象
2，随着类的加载而执行，出现的时机是很早的
3，多了一种调用方式，通过   类名.进行调用

3.修饰成员变量

理解static修饰成员变量后的特点？

被static修饰的成员变量，被所在类的所有对象共享（这个类的这个成员变量的值都是相同的）

4.注意事项

静态方法中，只能访问静态成员(成员变量，成员方法)，也可以访问非静态成员，静态方法里面没有关键字
    
什么时候使用static修饰成员变量？
    一般不使用static修饰成员变量，只要满足以下两个条件才会修饰：
    1，如果一个类的这个成员变量的值，对于所有的对象来说都是相同的值，那么这个变量就可以使用static修饰
    2，如果想在一个静态的方法中直接使用某个成员变量，那么这个成员变量也可以使用static修饰
    
 什么情况下使用static修饰成员方法？
    一般不使用static修饰成员方法，只有满足以下两个条件才会修饰：
    1，在工具类中，所有的方法都应该使用static修饰，方便调用
    2，如果想在一个静态的方法中直接调用某个方法，那么这个方法也可以使用static修饰