Java 类集案例

一、一对多关系

使用类集可以表示以下关系：一个学校可以包含多个学生，一个学生属于一个学校，这就是典型的一对多关系，此时就可以通过类集进行关系的表示。

（1）定义学生类：

class Student{
    private String name;
    private int age;
    private School school;//一个学生属于一个学校
    public Student(String name,int age){
        this.setName(name);
        this.setAge(age);
    }

    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 School getSchool() {
        return school;
    }

    public void setSchool(School school) {
        this.school = school;
    }
    public String toString(){
        return "学生姓名：" + this.name + "；年龄：" + this.age;
    }
}

Student 类中包含了一个 School 属性，表示一个学生属于一个学校
（2）定义学校类

class School{
    private String name;
    private List<Student> allStudents;//一个学校有多个学生
    public School(){//无参构造
        this.allStudents = new ArrayList<Student>();//实例化 List 集合
    }
    public School(String name){//通过构造设置 name属性
        this();//调用无参构造
        this.setName(name);//设置 name 属性内容
    }

    public String getName() {
        return name;
    }

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

    public List<Student> getAllStudents() {//取得全部的学生
        return allStudents;
    }
    public String toString(){
        return "学校名称：" + this.name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

这里使用 List 类型的属性，并指定泛型为 Student 类型，表示在一个 School 对象中会包含多个 Student 类型的引用。
（3）测试程序

public class Test{
    public static void main(String[] args) {
        School sch = new School("Java 大学");
        Student s1 = new Student("J1",20);
        Student s2 = new Student("J2",25);
        Student s3 = new Student("J3",29);
        sch.getAllStudents().add(s1);
        sch.getAllStudents().add(s2);
        sch.getAllStudents().add(s3);
        s1.setSchool(sch);
        s2.setSchool(sch);
        s3.setSchool(sch);
        System.out.println(sch);
//        实例化 Iterator 对象，用于输出全部的学生信息
        Iterator<Student> iter = sch.getAllStudents().iterator();
        while (iter.hasNext()) {
            System.out.println("\t" + iter.next());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

二、多对多关系

使用类集同样可以表示多对多的关系，比如一个学生可以选多门课程，一门课程可以有多个学生参加。
这需要定义两个类，学生信息类 Student、课程信息类 Course，在一个学生类中存在一个集合保存全部的课程，在课程类中也存在一个集合保存全部的学生
（1）定义学生类

class Student{
    private String name;
    private int age;
    private List<Course> allCourses;//定义集合保存全部课程
    public Student(){
        this.allCourses = new ArrayList<Course>();
    }
    public Student(String name,int age){
        this();
        this.setName(name);
        this.setAge(age);
    }

    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 List<Course> getAllCourses() {//取得全部课程
        return allCourses;
    }

    public String toString(){
        return "学生姓名：" + this.name + "；年龄：" + this.age;
    }
}

（2）定义课程类

class Course{
    private String name;
    private int credit;
    private List<Student> allStudents;//定义集合保存多个学生
    public Course(){//无参构造
        this.allStudents = new ArrayList<Student>();//实例化 List 集合
    }
    public Course(String name,int credit){//通过构造设置 name属性
        this();//调用无参构造
        this.setName(name);//设置 name 属性内容
        this.setCredit(credit);
    }

    public String getName() {
        return name;
    }

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

    public int getCredit() {
        return this.credit;
    }

    public void setCredit(int credit) {
        this.credit = credit;
    }

    public List<Student> getAllStudents() {//取得全部的学生
        return allStudents;
    }

    public String toString(){
        return "课程名称：" + this.name + "; 课程学分：" + this.credit;
    }
}

（3）测试程序

public class Test{
    public static void main(String[] args) {
        Course c1 = new Course("Java",3);
        Course c2= new Course("Python",3);
        Student s1 = new Student("J1",20);
        Student s2 = new Student("J2",25);
        Student s3 = new Student("J3",29);
        c1.getAllStudents().add(s1);
        c1.getAllStudents().add(s2);
        s1.getAllCourses().add(c1);
        s2.getAllCourses().add(c1);
        c2.getAllStudents().add(s1);
        c2.getAllStudents().add(s2);
        c2.getAllStudents().add(s3);
        s1.getAllCourses().add(c2);
        s2.getAllCourses().add(c2);
        s3.getAllCourses().add(c2);
//        输出一门课程的信息，观察一门课程有多少个学生参加
        System.out.println(c1);
//        实例化 Iterator 对象，用于输出全部的学生信息
        Iterator<Student> iter1 = c1.getAllStudents().iterator();
        while (iter1.hasNext()) {
            System.out.println("\t" + iter1.next());
        }
        //        输出一个学生的信息，观察有多少门课程
        System.out.println(s1);
//        实例化 Iterator 对象，用于输出全部的学生信息
        Iterator<Course> iter2 = s1.getAllCourses().iterator();
        while (iter2.hasNext()) {
            System.out.println("\t" + iter2.next());
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34