Java实现学生管理系统--待续

实现向集合中增加、删除和修改元素
1、集合中存放的Student对象(stuId,stuName,stuAge,stuClass(Clazz类型))
2、有2个实体类(班级Clazz(clazzId,clazzName)和学生Student)
3、班级是固定的,存放在一个单独的集合中
4、增加学生的时候,需要填写学号、姓名、年龄和班级号(要求验证班级是否存在)
5、删除学生要求按照学号或姓名删除,如果不存在要求重新输入,否则要求显示该学生的信息(学号、姓名、年龄和班级名),确认删除
6、修改学生要求按照学号或姓名先查找该学生(修改选项:姓名、年龄和班级号(验证修改之后的班级号是否存在))
7、每次操作之后显示最新的所有学生
解题思路i：
这里有两个实体类，分别是student和clazz
因为student有外键clazz类的属性。所以我们需要先创建一个clazz的实体类，然后对实体的每个属性添加set和get的方法，用于设置属性和获取属性的值，然后还要添加无参构造和有参构造。
java里面的构造器是一个与类同名的特殊的方法，称为构造方法，在创建类的对象时使用，用于对象初始化。
而我们创建一个实体类不仅要添加一个有参的构造而且还要添加一个无参的构造，目的是当我们使用new Clazz(),如果不传参数，那么就会自动调用无参的构造，所以为了防止我们在实例化对象的时候不传参数的时候不报错，所以我们一般都会添加一个无参构造。
同时我们还要重写equal方法和hashcode方法，重写equal的目的是为了定制我们自己的比较规则，在Java的源码里面，如果两个对象相同，但是如果hashcode不同，就不相等，但是实际上我们只需要两个对象的属性相同，那么我们就认为这两个对象是相同的。

Clazz clas1 = new Clazz(102,"开发班");
Clazz clas2 = new Clazz(102,"开发班");
对于clas1和clas2这两个对象，他们的属性字段都相同，那么在我们的规则里面他们就是相同的，但是在Java里面，这两个对象的id是不同的，因为hash code是一个散列的随机值，任何两个对象的id是永远都不会相同的
除非
Clazz clas1 = new Clazz(102,"开发班");
Clazz clas2 = clas1;
那么上面的这两个对象利用equal比较就是相同的

下面我们通过代码验证一下，看这两个对象如果不经过重写的话是否相同

    Clazz clas1 = new Clazz(102,"开发班");
        Clazz clas2 = new Clazz(102,"开发班");
        boolean flg = clas1.equals(clas2);
        System.out.println(flg);
        ---》false
        Clazz clas1 = new Clazz(102,"开发班");
        Clazz clas2 = clas1;
        boolean flg = clas1.equals(clas2);
        System.out.println(flg);
        --》true

那么下面我们对clazz的equal方法进行重写

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + classId;
        result = prime * result
                + ((className == null) ? 0 : className.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Clazz other = (Clazz) obj;
        if (classId != other.classId)
            return false;
        if (className == null) {
            if (other.className != null)
                return false;
        } else if (!className.equals(other.className))
            return false;
        return true;
    }

Clazz clas1 = new Clazz(102,"开发班");
        Clazz clas2 = new Clazz(102,"开发班");
        boolean flg = clas1.equals(clas2);
        System.out.println(flg);
最后的打印结果为：true

那么下面我们就完成clazz实体类
这里还要补充一点的是我们还要为clazz进行一个tostring的方法重写
因为在Java的源码中，打印一个对象的时候，是直接将对象的地址打印出来的，但是我们需要的是打印出对象的每一个字段，所以这里我们还需要对tostring方法进行重写，将打印的结果按照我们想要的格式进行输出。

Clazz c1 = new Clazz(101, "开发");
        System.out.println(c1);
打印结果：entity.Clazz@9e098
如果我们对类进行了一个tostring的方法重写，返回我们需要的格式
    @Override
    public String toString() {
        return "Clazz [clazzId=" + clazzId + ", clazzName=" + clazzName + "]";
    }
    那么我们再打印一个clazz对象就是我们想要的格式了
    打印结果：
    Clazz [clazzId=101, clazzName=开发]

创建clazz实体类

package entity;

/**
 * 班级Clazz(clazzId,clazzName)
 * 
 * @author cr
 * 
 */
public class Clazz {
    private int clazzId;
    // 这里设置属性为private是为了防止任意的篡改clazz的属性字段
    // 让用户只能通过set或者get方法来修改和获取，并且有的属性我们是不希望别人直接看到的
    // 所以一般我们都会把类的属性字段设置为私有属性private
    private String clazzName;


    //添加无参构造和有参构造

    public Clazz() {
        super();
    }

   //有参构造，对clazz类进行实例化操作的时候用，继承的时候用 
    public Clazz(int clazzId, String clazzName) {
        super();
        this.clazzId = clazzId;
        this.clazzName = clazzName;
    }


    //为属性设置set和get方法，因为我们设置了private属性，所以需要为外部提供set和get方法
    public int getClazzId() {
        return clazzId;
    }

    public void setClazzId(int clazzId) {
        this.clazzId = clazzId;
    }

    public String getClazzName() {
        return clazzName;
    }

    public void setClazzName(String clazzName) {
        this.clazzName = clazzName;
    }
    //重写equal方法

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + clazzId;
        result = prime * result
                + ((clazzName == null) ? 0 : clazzName.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Clazz other = (Clazz) obj;
        if (clazzId != other.clazzId)
            return false;
        if (clazzName == null) {
            if (other.clazzName != null)
                return false;
        } else if (!clazzName.equals(other.clazzName))
            return false;
        return true;
    }
    //重写tostring方法

    @Override
    public String toString() {
        return "Clazz [clazzId=" + clazzId + ", clazzName=" + clazzName + "]";
    }

}

接下来创建学生实体类，方法和班级类似，但是要注意的是学生的班级号是班级实体类的属性，所以学生的班级号属性应该是clazz类型的

package entity;

/**
 * 学生实体类 Student对象(stuId,stuName,stuAge,stuClass(Clazz类型))
 * 
 * @author cr
 * 
 */
public class Student {
    private int stuId;
    private String stuName;
    private int stuAge;
    private Clazz stuClass;

    // 无参构造
    public Student() {
        super();
    }

    // 有参构造
    public Student(int stuId, String stuName, int stuAge, Clazz stuClass) {
        super();
        this.stuId = stuId;
        this.stuName = stuName;
        this.stuAge = stuAge;
        this.stuClass = stuClass;
    }

    // set() get()
    public int getStuId() {
        return stuId;
    }

    public void setStuId(int stuId) {
        this.stuId = stuId;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }

    public Clazz getStuClass() {
        return stuClass;
    }

    public void setStuClass(Clazz stuClass) {
        this.stuClass = stuClass;
    }

    // tostring

    @Override
    public String toString() {
        return "Student [stuId=" + stuId + ", stuName=" + stuName + ", stuAge="
                + stuAge + ", stuClass=" + stuClass + "]";
    }

    // equal()

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + stuAge;
        result = prime * result
                + ((stuClass == null) ? 0 : stuClass.hashCode());
        result = prime * result + stuId;
        result = prime * result + ((stuName == null) ? 0 : stuName.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (stuAge != other.stuAge)
            return false;
        if (stuClass == null) {
            if (other.stuClass != null)
                return false;
        } else if (!stuClass.equals(other.stuClass))
            return false;
        if (stuId != other.stuId)
            return false;
        if (stuName == null) {
            if (other.stuName != null)
                return false;
        } else if (!stuName.equals(other.stuName))
            return false;
        return true;
    }

}

创建好学生实体类和班级实体类之后，接下来就是将班级实体类进行实例化，然后将实例化后的对象加入到一个集合中，我们这里就加入到list集合中，list集合是有顺序的，可以重复。而list只是collection下面的一个接口，所以在实例化集合对象的时候，需要new的还是arraylist，而不是new 的list，接口不能实现，，实现的是方法类。但是用arraylist new出来的还是属于list<>类型，中间的对象类型是clazz类型。
对于班级的实例化，我们利用集合来实现，先创建一个集合对象，然后为创建的集合添加实例。
在测试里面我们还是创建一个班级的初始化函数，这样就不用在main函数里面一个一个的来初始化班级对象了。

 //初始化班级
    //创建函数的时候，如果有返回值，那么需要添加返回的类型
    //这里返回的list<Clazz>类型

    public List<Clazz> initClazz(){
        //创建一个list集合，new arraylist（）
        List<Clazz> clazz  = new ArrayList<Clazz>();
        //为创建的集合添加具体的元素
        //这里的每一个元素是一个clazz对象
        //那么需要new一下，进行实例化之后再添加到集合中取
        //调用add()的方法进行添加集合中的元素
        clazz.add(new Clazz(1001,"开发班"));
        clazz.add(new Clazz(1002,"设计班"));
        clazz.add(new Clazz(1003,"教职班"));
        //初始化之后需要返回一个list对象
        return  clazz;
    }

我们再main方法中进行调用
再调用之前需要先实例化一下包含了main方法的类

public static void main(String[] args) {
        //再main方法中需要实例化一个对象，进行调用方法
        Test test  = new Test();
        List<Clazz> ic = test.initClazz();
        for (Clazz clazz : ic) {
            System.out.println(clazz);
        }
打印结果：
Clazz [clazzId=1001, clazzName=开发班]
Clazz [clazzId=1002, clazzName=设计班]
Clazz [clazzId=1003, clazzName=教职班]
可以看到我们对班级的初始化就已经成功了

接下来我们的任务就是添加学生了，添加学生的时候需要输入学生姓名，年龄，班级号，并且还需要判断输入的班级号是否存在于我们的Clazz类里面
同样的我们需要创建一个添加学生的函数