java学习笔记day10-分类及分包思想-static关键字-三层架构案例师生信息管理系统

最新推荐文章于 2023-10-24 16:34:25 发布

猫薄荷>3<

最新推荐文章于 2023-10-24 16:34:25 发布

阅读量497

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_41615150/article/details/111303579

版权

笔记专栏收录该内容

27 篇文章 2 订阅

订阅专栏

Day10

分类思想

分工协作，专人干专事；

例如学生信息管理系统的分类：

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

分包思想

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

包的概述

包：本质上就是文件夹
创建包：(单级包、多级包)多级包间使用.进行分割；
- 多级包的定义规范：公司的网站地址反转(去掉www)，比如：百度的网址为www.baidu.com,则包的结构就是com.baidu.其他的包名
包的命名规则：字母都是小写

包的定义

使用package关键字定义包名
格式：package包名；若是多级包，中间用.进行分割
注意：一般情况下，我们不会手动给某一个类定义包，使用idea开发工具创建即可

包的注意事项

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

不同包下的相互访问

先导包后访问(import)
通过全类名访问(包名+类名)访问

应用场景：多个包下，出现了相同的类名称，就可以使用这种访问进行区分

类与类之间的访问

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

案例：师生信息管理系统

环境搭建

创建模块：ahua-edu-info-manager
创建包、创建类

包	存储的类	作用
com.ahua.edu.info.manager.domain	Student.java	封装学生信息
com.ahua.edu.info.manager.dao	StudentDao.java	访问存储数据的数组，进行增删改查
com.ahua.edu.info.manager.service	Student.service.java	业务逻辑处理
com.ahua.edu.info.manager.controller	StudentController.java	和用户打交道
com.ahua.edu.info.manager.entry	InfoManagerEntry.java	程序的入口类，提供一个main方法

数据封装类Student：

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

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

    public Student() {
    }

    public Student(String id, String name, int 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 int getAge() {
        return age;
    }

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

    public String getBirthday() {
        return birthday;
    }

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

添加功能实现

在这里插入图片描述

编写addStudent()方法，在cotroller层中，该方法接收用户输入的信息，将学生信息封装为学生对象传递给StudentService；service层将接受到的学生对象，传递给StudentDao；Dao层创建Student学生数组长度为5，然后将接收到的学生对象添加到数组中，返回是否添加成功的boolean类型值；Service层接收方法的Boolean返回值，将结果返还给StudentController；Controller层接收方法的boolean类型返回值，根据结果在控制台打印添加成功\添加失败。

优化-学号判断
在这里插入图片描述

StudentController接收到学生id后，判断该id在数组中是否存在；指派StudentService判断id是否存在，调用其内部isExists方法，该方法返回boolean类型,接收学员id和判断的代码，使用无限循环包裹，直到输入不存在的id，结束循环；在isExists方法里，从StudentDao中获取存储学生对象的数组，调用其内部findAllStudent方法，该方法返回学生数组；遍历数组获取每一个学生对象，判断学号是否存在，返回true或false结果；在StudentDao中使用findAllStudent方法将学生数组返回即可。

static关键字

static关键字是静态的意思，是java中的一个修饰符，可以修饰成员方法，成员变量；被static修饰的成员变量，一般叫做静态变量；被static修饰的成员方法，一般叫做静态方法。

特点

被static修饰的成员，会被该类的所有对象所共享，是我们判断是否使用静态关键字的条件
被static修饰的成员，会随着类的加载而加载，优先于对象存在
多了一种调用方式，可以通过类名.进行调用
静态方法中只能访问静态成员(成员变量，成员方法)
非静态方法中，可以使用静态成员，也可以使用非静态成员
静态方法中，没有this关键字(this需要在创建对象之后，才会存在，静态存在的时候，对象可能还没有被创建)

查询学生功能实现
在这里插入图片描述

在StudentController中编写findAllStudent方法，方法内部创建StudentService业务员对象，调用业务员对象中的findAllStudent方法，得到学生数组，判断数组地址是否为null，是的话，提示查无信息，不为null，遍历数组，打印学生信息；在StudentService中的findAllStudent方法里，从StudentDao中获取存储学生对象的数组，调用内部findAllStudent方法，判断学生数组中是否有数据，有则返回数组地址，无则返回null；在StudentDao中findAllStudent方法将学生数组返回即可；

删除学生功能实现
在这里插入图片描述

在StudentController中编写deleteStudentById方法，接收用户要删除的学生id，调用StudentService业务员对象中的isExists方法，判断学号是否存在，不存在则继续录入，调用StudentService业务员对象中的deleteStudentById方法，根据id删除学生，并提示删除成功；在StudentService中deleteStudentById方法里调用StudentDao中的deleteStudentById方法删除学生；在StudentDao中deleteStudentById方法里查找学生id在数组中所在的索引位置，将该索引位置的学生对象，使用null进行替换。

修改学生功能实现
在这里插入图片描述

在StudentController中编写updateStudent方法，接收用户要修改的学生id，调用StudentService中的isExists方法，判断学号是否存在，不存在则继续录入，存在则录入新的学生信息，封装为学生对象；在StudentService中的updateStudent方法接收两个参数学生id和新的学生对象，调用StudentDao中的updateStudent方法，将参数传入；在StudentDao里的updateStudent方法中，查找学生id在数组中的索引位置。

数据封装类Teacher

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

public class Teacher {
    private String id;
    private String name;
    private int age;
    private String birthday;

    public Teacher() {
    }

    public Teacher(String id, String name, int 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 int getAge() {
        return age;
    }

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

    public String getBirthday() {
        return birthday;
    }

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

视图层StudentController

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

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

import java.util.Scanner;

public class StudentController {
    private StudentService studentService = new StudentService();
    private 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.next();
            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("您的输入有误，请重新输入！");
                    break;
            }
        }
    }

    public void updateStudent() {
        Student[] stus = studentService.findAllStudent();
        if(stus==null){
            System.out.println("您还未添加学生信息！");
            return;
        }
        String updateId;
        while (true){
            //键盘录入要删除的学生的id
            System.out.println("请输入您要修改的学生的id：");
            updateId = sc.next();
            //判断id在容器中是否存在，如果不存在则需要一直录入
            boolean exists = studentService.isExists(updateId);
            if(!exists){
                System.out.println("你输入的id不存在，请重新输入：");
            }else{
                break;
            }
        }
        System.out.println("请输入新的学生姓名：");
        String name = sc.next();
        System.out.println("请输入新的年龄：");
        int age = sc.nextInt();
        System.out.println("请输入新的生日：");
        String birthday = sc.next();
        Student newStu = new Student(updateId,name,age,birthday);
        studentService.updateStudent(updateId,newStu);
        System.out.println("修改成功");
    }

    public void deleteStudentById() {
        Student[] stus = studentService.findAllStudent();
        if(stus==null){
            System.out.println("您还未添加学生信息！");
            return;
        }
        String delId;
        while (true){
            //键盘录入要删除的学生的id
            System.out.println("请输入您要删除的学生的id：");
            delId = sc.next();
            //判断id在容器中是否存在，如果不存在则需要一直录入
            boolean exists = studentService.isExists(delId);
            if(!exists){
                System.out.println("你输入的id不存在，请重新输入：");
            }else{
                break;
            }
        }
        //调用业务员中的deleteStudentById方法根据id删除学生
        studentService.deleteStudentById(delId);
        //提示删除成功
        System.out.println("删除成功！");
    }

    private void findAllStudent() {
        //调用业务员中的获取方法，得到学生的对象数组
        Student[] stus = studentService.findAllStudent();
        //判断数组的内存的地址是否为null
        if(stus!=null){
            System.out.println("学号\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"+stu.getName()+"\t"+stu.getAge()+"\t\t"+stu.getBirthday());
                }
            }
        }else{
            System.out.println("还未添加学生信息！");
            return;
        }
        //遍历数组获取学生信息并打印在控制台
    }

    public void addStudent() {
        //键盘接收学生信息
        //Scanner sc = new Scanner(System.in);
        String id;
        while (true){
            System.out.println("请输入学生id：");
            id = sc.next();
            boolean flag = studentService.isExists(id);
            if(flag){
                System.out.println("学号已经被占用，请重新输入");
            }else{
                break;
            }
        }
        System.out.println("请输入学生姓名：");
        String name = sc.next();
        System.out.println("请输入学生年龄：");
        int age = sc.nextInt();
        System.out.println("请输入学生生日：");
        String birthday = sc.next();
        //将学生信息封装为学生对象
        Student stu = new Student();
        stu.setId(id);
        stu.setName(name);
        stu.setAge(age);
        stu.setBirthday(birthday);
        //将学生对象传递给StudentService中的addStudent方法
        boolean result = studentService.addStudent(stu);
        //根据返回的boolean结果，打印添加成功\失败
        if(result){
            System.out.println("添加成功");
        }else{
            System.out.println("添加失败");
        }
    }
}

视图层TeacherController

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

import com.ahua.edu.info.manager.domain.Teacher;
import com.ahua.edu.info.manager.service.TeacherService;

import java.util.ArrayList;
import java.util.Scanner;

public class TeacherController {
    private TeacherService teacherService = new TeacherService();
    private Scanner sc = new Scanner(System.in);
    public void start() {
        TeacherLoop:while (true){
            System.out.println("------欢迎来到老师管理系统------");
            System.out.println("请输入您的选择：1.添加老师 2.删除老师 3.修改老师 4.查询老师 5.退出");
            String choice = sc.next();
            switch (choice){
                case "1":
                    //System.out.println("添加");
                    addTeacher();
                    break;
                case "2":
                    //System.out.println("delete");
                    deleteTeacherById();
                    break;
                case "3":
                    //System.out.println("update");
                    updateTeacher();
                    break;
                case "4":
                    //System.out.println("query");
                    findAllTeacher();
                    break;
                case "5":
                    System.out.println("感谢您使用老师管理系统，再见！");
                    break TeacherLoop;
                default:
                    System.out.println("您的输入有误，请重新输入！");
                    break;
            }
        }
    }

    private void updateTeacher() {
        int index = isExists();
        if(index==-1){
            return;
        }
        System.out.println("请输入新的姓名：");
        String name = sc.next();
        System.out.println("请输入新的年龄：");
        int age = sc.nextInt();
        System.out.println("请输入新的生日：");
        String birthday = sc.next();
        Teacher teacher = new Teacher();
        //teacher.setId();
        teacher.setName(name);
        teacher.setAge(age);
        teacher.setBirthday(birthday);
        teacherService.updateTeacher(index,teacher);
        System.out.println("修改成功");
    }

    public void deleteTeacherById() {
        int index;
        index = isExists();
        if(index==-1){
            return;
        }
        teacherService.deleteTeacherById(index);
        System.out.println("删除成功");
    }

    public int isExists(){
        int index;
        ArrayList<Teacher> list = teacherService.findAllTeacher();
        if(list.size()==0){
            System.out.println("你还未添加老师信息！");
            return -1;
        }else{
            while (true){
                System.out.println("请输入要操作老师的id：");
                String id = sc.next();
                //判断该id是否存在
                index= teacherService.getIndexById(id);
                if(index==-1){
                    System.out.println("您要操作的老师信息不存在，请重新输入！");
                }else{
                    break;
                }
            }
        }
        return index;
    }

    public void findAllTeacher() {
        ArrayList<Teacher> list = teacherService.findAllTeacher();
        if(list.size()==0){
            System.out.println("你还未添加老师信息！");
        }else{
            System.out.println("学号\t\t姓名\t年龄\t生日");
            for (int i = 0; i < list.size(); i++) {
                Teacher teacher = list.get(i);
                String id = teacher.getId();
                String name = teacher.getName();
                int age = teacher.getAge();
                String birthday = teacher.getBirthday();
                System.out.println(teacher.getId()+"\t"+teacher.getName()+"\t"+teacher.getAge()+"\t\t"+teacher.getBirthday());
            }
        }
    }

    public void addTeacher() {
        String id;
        while (true){
            System.out.println("请输入老师id：");
             id = sc.next();
            int index = teacherService.getIndexById(id);
            if(index==-1){
                break;
            }else{
                System.out.println("你输入的id已被占用，请重新输入！");
            }
        }
        System.out.println("请输入老师姓名：");
        String name = sc.next();
        System.out.println("请输入老师年龄：");
        int age = sc.nextInt();
        System.out.println("请输入老师的生日：");
        String birthday = sc.next();
        Teacher teacher = new Teacher(id,name,age,birthday);

        boolean result = teacherService.addTeacher(teacher);
        if(result){
            System.out.println("添加成功");
        }else{
            System.out.println("添加失败");
        }
    }
}

业务层StudentService

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

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

public class StudentService {
    //创建StudentDao
    private StudentDao studentDao = new StudentDao();
    public boolean addStudent(Student stu) {
        //将学生对象传递给StudentDao的addStudent方法
        //将返回的boolean结果返回给StudentController
        return studentDao.addStudent(stu);
    }

    public boolean isExists(String id) {
        Student[] stus = studentDao.findAllStudent();
        //假设id在数组中不存在
        boolean exists = false;
        //遍历数组，获取每一个学生对象，准备进行判断
        for (int i = 0; i < stus.length; i++) {
            Student student = stus[i];
            if(student!=null&&student.getId().equals(id)){
                exists = true;
                break;
            }
        }
        return exists;
    }

    public Student[] findAllStudent() {
        //调用库管对象的findAllStudent方法获取学生对象数组
        Student[] allStudent = studentDao.findAllStudent();
        //判断数组中是否有学生信息(有则返回地址，无则返回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);
    }
}

业务层TeacherService

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

import com.ahua.edu.info.manager.dao.TeacherDao;
import com.ahua.edu.info.manager.domain.Teacher;

import java.util.ArrayList;

public class TeacherService {
    private TeacherDao teacherDao = new TeacherDao();
    public boolean addTeacher(Teacher teacher) {

        return teacherDao.addTeacher(teacher);
    }

    public ArrayList<Teacher> findAllTeacher() {
        return teacherDao.findAllTeacher();
    }

    public int getIndexById(String id) {
        ArrayList<Teacher> list = teacherDao.findAllTeacher();
        int index = -1;
        for (int i = 0; i < list.size(); i++) {
            Teacher teacher = list.get(i);
            if(teacher.getId().equals(id)){
                index=i;
            }
        }
        return index;
    }

    public void deleteTeacherById(int index) {
        teacherDao.deleteTeacherById(index);
    }

    public void updateTeacher(int index, Teacher teacher) {
        teacherDao.updateTeacher(index,teacher);
    }
}

持久层StudentDao

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

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

public class StudentDao {
    //创建学生对象数组
    private static Student[] stus = new Student[5];
    public boolean addStudent(Student stu) {

        //添加学生到数组
        //定义变量index为-1，假设数组已经全部存满没有null元素
        int index = -1;
        //遍历数组取出每一个元素，判断是否为null
        for (int i = 0; i < stus.length; i++) {
            Student student = stus[i];
            if(student==null){
                //如果为null，让index记录当前索引位置，并使用break结束循环
                index = i;
                break;
            }
        }
        //返回是否添加成功的boolean类型状态
        if(index==-1){
            //装满了
            return false;
        }else{
            //没有装满，正常添加，返回true
            stus[index] = stu;
            return true;
        }
    }

    public Student[] findAllStudent() {
        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 = stus[i];
            if(stu!=null&&stu.getId().equals(id)){
                index=i;
                break;
            }
        }
        return index;
    }

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

持久层TeacherDao

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

import com.ahua.edu.info.manager.domain.Teacher;

import java.util.ArrayList;

public class TeacherDao {
    private ArrayList<Teacher> list = new ArrayList<>();
    public boolean addTeacher(Teacher teacher) {
        list.add(teacher);
        return true;
    }

    public ArrayList<Teacher> findAllTeacher() {
        return list;
    }

    public void deleteTeacherById(int index) {
        list.remove(index);
    }

    public void updateTeacher(int index, Teacher teacher) {
        //list.set(index,teacher);
        list.get(index).setName(teacher.getName());
        list.get(index).setAge(teacher.getAge());
        list.get(index).setBirthday(teacher.getBirthday());
    }
}

入口InfoManagerEntry

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

import com.ahua.edu.info.manager.controller.StudentController;
import com.ahua.edu.info.manager.controller.TeacherController;
import com.ahua.edu.info.manager.domain.Student;

import java.util.Scanner;

public class InfoManagerEntry {
    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.next();
            switch (choice){
                case "1":
                    //System.out.println("学生管理");
                    //开启学生管理系统
                    StudentController studentController = new StudentController();
                    studentController.start();
                    break;
                case "2":
                    //System.out.println("老师管理");
                    //开启老师管理系统
                    TeacherController teacherController = new TeacherController();
                    teacherController.start();
                    break;
                case "3":
                    System.out.println("感谢您的使用");
                    //退出当前正在运行的JVM虚拟机
                    System.exit(0);
                    break;
                default:
                    System.out.println("您的输入有误，请重新输入！");
                    break;
            }
        }
    }
}

猫薄荷>3<

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
1
评论
java学习笔记day10-分类及分包思想-static关键字-三层架构案例师生信息管理系统

Day10分类思想分工协作，专人干专事；例如学生信息管理系统的分类：Student类标准学生类，封装键盘录入的学生信息（id，name，age，birthday）StudentDao类 Dao：(Data Access Object缩写)用于访问存储数据的数组或集合StudentService类用来进行业务逻辑的处理(例如：判断录入的id是否存在)StudentController类和用户打交道(接收用户需求，
复制链接

扫一扫