JAVA--多对多关系

时间：2023-02-14 18:30:36

使用类集不仅可以表示出一对一的关系，也可以表示出多对多的关系。例如，一个学生可以选多门课程，一门课程可以有多个学生参加，那么这就是一个典型的多对多关系。

要完成本程序，首先应该定义两个类：学生信息类Student、课程信息类Course。在一个学生类中存在一个集合，保存全部的课程；而在课程类中也要存在一个集合，保存全部的学生。

范例：定义学生类

 
 
    

  1. package org.lxh.demo13.execdemo02;  
    2. 
  
  
  2. 
import java.util.ArrayList;  

    3. 
  
  
  3. 
import java.util.List;  

    4. 
  
  
  4. 
public class Student {                            
    // 定义学生类  

    5. 
  
  
  5. 
    private String name ;                      
    // 定义name属性  

    6. 
  
  
  6. 
    private int age ;                         
    // 定义age属性  

    7. 
  
  
  7. 
    private List<Course> allCourses ;          
    // 定义集合保存全部课程  

    8. 
  
  
  8. 
    public Student(){                         
    // 无参构造  

    9. 
  
  
  9. 
        this.allCourses = new ArrayList<Course>
    () ;    // 实例化List集合  

    10. 
  
  
  10.     }  
    11. 
  
  
  11. 
    public Student(String name,int age){     
    // 通过构造设置属性内容  

    12. 
  
  
  12. 
        this() ;                            
    // 调用无参构造  

    13. 
  
  
  13. 
        this.setName(name) ;                
    // 设置name属性内容  

    14. 
  
  
  14. 
        this.setAge(age) ;                  
    // 设置age属性内容  

    15. 
  
  
  15.     }  
    16. 
  
  
  16. 
    public String getName() {             
    // 取得name属性  

    17. 
  
  
  17. 
        return name;  

    18. 
  
  
  18.     }  
    19. 
  
  
  19. 
    public void setName(String name) {       
    // 设置name属性  

    20. 
  
  
  20. 
        this.name = name;  

    21. 
  
  
  21.     }  
    22. 
  
  
  22. 
    public int getAge() {                    
    // 取得age属性  

    23. 
  
  
  23. 
        return age;  

    24. 
  
  
  24.     }  
    25. 
  
  
  25. 
    public void setAge(int age) {              
    // 设置age属性  

    26. 
  
  
  26. 
        this.age = age;  

    27. 
  
  
  27.     }  
    28. 
  
  
  28. 
    public List<Course> getAllCourses() {      
    // 取得全部课程  

    29. 
  
  
  29. 
        return allCourses;  

    30. 
  
  
  30.     }  
    31. 
  
  
  31. 
    public String toString(){                     
    // 覆写toString()方法  

    32. 
  
  
  32. 
        return "学生姓名：" + this.name + "；年龄：" + this.age ;  

    33. 
  
  
  33.     }  
    34. 
  
  
  34. } 
    35.

在学生类中存在一个allCourses的List集合，这样在程序运行时，一个学生类中可以保存多个Course对象。

范例：定义课程类

 
 
    

  1. package org.lxh.demo13.execdemo02;  
    2. 
  
  
  2. 
import java.util.ArrayList;  

    3. 
  
  
  3. 
import java.util.List;  

    4. 
  
  
  4. 
public class Course {                      
    // 定义Course类  

    5. 
  
  
  5. 
    private String name ;                 
    // 定义name属性  

    6. 
  
  
  6. 
    private int credit ;                  
    // 定义credit属性，表示学分  

    7. 
  
  
  7. 
    private List<Student> allStudents ;   
    // 定义集合保存多个学生  

    8. 
  
  
  8. 
    public Course(){                    
    // 无参构造方法  

    9. 
  
  
  9. 
        this.allStudents = new ArrayList<Student>() ;
    // 实例化List集合  

    10. 
  
  
  10.     }  
    11. 
  
  
  11. 
    public Course(String name,int credit){     
    // 设置name和credit  

    12. 
  
  
  12. 属性  
    13. 
  
  
  13. 
        this() ;                             
    // 调用无参构造  

    14. 
  
  
  14. 
        this.setName(name) ;                  
    // 设置name属性  

    15. 
  
  
  15. 
        this.setCredit(credit) ;              
    // 设置credit属性  

    16. 
  
  
  16.     }  
    17. 
  
  
  17. 
    public String getName() {                
    // 取得name属性  

    18. 
  
  
  18. 
        return name;  

    19. 
  
  
  19.     }  
    20. 
  
  
  20. 
    public void setName(String name) {        
    // 设置name属性  

    21. 
  
  
  21. 
        this.name = name;  

    22. 
  
  
  22.     }  
    23. 
  
  
  23. 
    public int getCredit() {                  
    // 取得credit属性  

    24. 
  
  
  24. 
        return credit;  

    25. 
  
  
  25.     }  
    26. 
  
  
  26. 
    public void setCredit(int credit) {       
    // 设置credit属性  

    27. 
  
  
  27. 
        this.credit = credit;  

    28. 
  
  
  28.     }  
    29. 
  
  
  29. 
    public List<Student> getAllStudents() {    
    // 得到全部学生  

    30. 
  
  
  30. 
        return allStudents;  

    31. 
  
  
  31.     }  
    32. 
  
  
  32. 
    public void setAllStudents(List<Student>
    allStudents) {    // 设置全部学生  

    33. 
  
  
  33. 
        this.allStudents = allStudents;  

    34. 
  
  
  34.     }  
    35. 
  
  
  35. 
    public String toString(){             
    // 覆写toString()  

    36. 
  
  
  36. 方法  
    37. 
  
  
  37. 
        return "课程名称：" + this.name + "；
    课程学分"     + this.credit ;  

    38. 
  
  
  38.     }  
    39. 
  
  
  39. } 
    40.

课程类与学生类一样，都定义了一个List集合，用于保存多个学生信息。

范例：测试程序

 
 
    

  1. package org.lxh.demo13.execdemo02;  
    2. 
  
  
  2. 
import java.util.Iterator;  

    3. 
  
  
  3. 
public class TestMore {  

    4. 
  
  
  4. 
    public static void main(String args[]) {  

    5. 
  
  
  5. 
        Course c1 = new Course("英语", 3);      
    // 实例化课程对象  

    6. 
  
  
  6. 
        Course c2 = new Course("计算机", 5);    
    // 实例化课程对象  

    7. 
  
  
  7. 
        Student s1 = new Student("张三", 20);  
    // 实例化学生对象  

    8. 
  
  
  8. 
        Student s2 = new Student("李四", 21);  
    // 实例化学生对象  

    9. 
  
  
  9. 
        Student s3 = new Student("王五", 22);   
    // 实例化学生对象  

    10. 
  
  
  10. 
        Student s4 = new Student("赵六", 23); 
    // 实例化学生对象  

    11. 
  
  
  11. 
        Student s5 = new Student("孙七", 24);  
    // 实例化学生对象  

    12. 
  
  
  12. 
        Student s6 = new Student("钱八", 25);  
    // 实例化学生对象  

    13. 
  
  
  13. 
        // 第一门课程有3个人参加，向课程中增加
    3个学生信息，同时向学生中增加课程信息      

    14. 
  
  
  14. 
        c1.getAllStudents().add(s1);       
    // 向课程增加学生信息  

    15. 
  
  
  15. 
        c1.getAllStudents().add(s2);      
    // 向课程增加学生信息  

    16. 
  
  
  16. 
        c1.getAllStudents().add(s6);     
    // 向课程增加学生信息  

    17. 
  
  
  17. 
        s1.getAllCourses().add(c1);       
    // 向学生中增加课程信息  

    18. 
  
  
  18. 
        s2.getAllCourses().add(c1);     
    // 向学生中增加课程信息  

    19. 
  
  
  19. 
        s6.getAllCourses().add(c1);        
    // 向学生中增加课程信息  

    20. 
  
  
  20. 
        // 第二门课程有6个人参加，向课程中增加
    6个学生信息，同时向学生中增加课程信息      

    21. 
  
  
  21. 
        c2.getAllStudents().add(s1);       
    // 向课程增加学生信息  

    22. 
  
  
  22. 
        c2.getAllStudents().add(s2);       
    // 向课程增加学生信息  

    23. 
  
  
  23. 
        c2.getAllStudents().add(s3);       
    // 向课程增加学生信息  

    24. 
  
  
  24. 
        c2.getAllStudents().add(s4);       
    // 向课程增加学生信息  

    25. 
  
  
  25. 
        c2.getAllStudents().add(s5);       
    // 向课程增加学生信息  

    26. 
  
  
  26. 
        c2.getAllStudents().add(s6);       
    // 向课程增加学生信息  

    27. 
  
  
  27. 
        s1.getAllCourses().add(c2);       
    // 向学生中增加课程信息  

    28. 
  
  
  28. 
        s2.getAllCourses().add(c2);        
    // 向学生中增加课程信息  

    29. 
  
  
  29. 
        s3.getAllCourses().add(c2);        
    // 向学生中增加课程信息  

    30. 
  
  
  30. 
        s4.getAllCourses().add(c2);        
    // 向学生中增加课程信息  

    31. 
  
  
  31. 
        s5.getAllCourses().add(c2);        
    // 向学生中增加课程信息  

    32. 
  
  
  32. 
        s6.getAllCourses().add(c2);        
    // 向学生中增加课程信息  

    33. 
  
  
  33. 
        // 输出一门课程的信息，观察一门课程有多
    少个学生参加      

    34. 
  
  
  34. 
        System.out.println(c1);             
    // 输出第一门课程信息  

    35. 
  
  
  35.         Iterator<Student> iter1 = c1.
    getAllStudents().iterator();  
    36. 
  
  
  36. 
        while (iter1.hasNext()) {           
    // 迭代输出  

    37. 
  
  
  37. 
            Student s = iter1.next();         
    // 取出学生对象  

    38. 
  
  
  38. 
            System.out.println("/t|- " + s);   
    // 输出学生信息  

    39. 
  
  
  39.         }  
    40. 
  
  
  40. 
        // 输出一个学生参加的课程信息，观察有多少门课程  

    41. 
  
  
  41. 
        System.out.println(s6);               
    // 输出学生信息  

    42. 
  
  
  42.         Iterator<Course> iter2 = s6.
    getAllCourses().iterator();  
    43. 
  
  
  43. 
        while (iter2.hasNext()) {         
    // 迭代输出  

    44. 
  
  
  44. 
            Course c = iter2.next();        
    // 取得所参加的课程  

    45. 
  
  
  45. 
            System.out.println("/t|- " + c);  
    // 输出课程信息  

    46. 
  
  
  46.         }  
    47. 
  
  
  47.     }  
    48. 
  
  
  48. } 
    49.

程序运行结果：

 
 
    

  1. 课程名称：英语；课程学分3 
    2. 
  
  
  2. 
    |- 学生姓名：张三；年龄：20 

    3. 
  
  
  3. 
    |- 学生姓名：李四；年龄：21 

    4. 
  
  
  4. 
    |- 学生姓名：钱八；年龄：25 

    5. 
  
  
  5. 
学生姓名：钱八；年龄：25 

    6. 
  
  
  6. 
    |- 课程名称：英语；课程学分3 

    7. 
  
  
  7. 
    |- 课程名称：计算机；课程学分5 

    8.

从程序来看，设置关系的地方较为复杂，因为现在的程序采用的是双向的处理关系，所以学生在选择一个课程时，除了课程中要添加学生以外，在学生中也要添加课程信息。在输出课程信息时，可以通过课程对象中的集合找到参加此课程的全部学生信息，也可以通过学生对象找到全部参加的课程信息。

标签：

相关文章