精华内容
下载资源
问答
  • 学生宿舍管理系统类图设计

    万次阅读 2014-06-12 00:51:05
    面对庞大的学生信息量,一套适合学生公寓使用的管理软件,能够非常方便地管理公寓,包括公寓内员工基本信息管理,学生信息管理,公寓信息管理等,还能便捷的查询公寓内的各种信息,提高了工作人员的工作效率。...

    需求文档

    面对庞大的学生信息量,一套适合学生公寓使用的管理软件,能够非常方便地管理公寓,包括公寓内员工基本信息管理,学生信息管理,公寓信息管理等,还能便捷的查询公寓内的各种信息,提高了工作人员的工作效率。

    通过使用学生公寓管理系统,可以做到规范管理、科学统计和快速查询,极大的减少宿舍管理方面的工作量。在提高工作效率的同时,还可以提高资本投入的经济效益,运行效率,节约资源。

    同时通过该题目的开发实施,可以掌握系统的设计与实现全过程,巩固学生的专业理论知识与实际应用的结合,提高分析问题,解决问题的能力。

     

    二、完整的E-R图。

     

    1.逻辑图


    2.物理图

     

     

     

    三、将E-R图转换为关系表。


     

    五个实体之间关系

    1.room与student之间的“live居住”关系

    2.building与room之间的“locate坐落”关系

    3.building与dorm_Administrator之间的“manage”管理”关系

    4.room与bill之间的“hold持有”关系

    实验总结与一点感想

    这次的实验的难度其实不大,主要是考查我们这个学期对数据库系统学习的掌握程度。虽然能顺利完成实验,但是还是有许多地方的不足。需要不断地改进。下个学期还有数据库的课程设计。我不会停止对数据库的学习。今后,我会继续努力学习数据库的理论知识,加强实践练习,提高自身的能力。数据库用的全英教材对我英语学习也是有一定的帮助,但仅仅靠这本书是不够用的。日后我比较想从事数据库方面的工作。

    展开全文
  • 指导教师 完成时间 成 绩 I 2020/3/27 前 言 项目小组分工 需求分析文档的整理及后期的功能测试 教务管理系统的建模实现 伴随着高校信息化建设的日益完善高等学校的教务管理系统在高校管理中越来越受到老师和学生的...
  • 图书管理系统主要管理对象是图书,系统的用户包括,借阅者,图书管理员。该系统主要设计的类包括:Book (代表一本书)、Borrower (借阅者)和 Worker(图书管理员)。 其中Borrower和Book之间为关联关系,Borrower...

    图书馆管理信息系统的用例图和类图

    类图
    图书管理系统主要管理对象是图书,系统的用户包括,借阅者,图书管理员。该系统主要设计的类包括:Book (代表一本书)、Borrower (借阅者)和 Worker(图书管理员)。
    其中Borrower和Book之间为关联关系,Borrower和Book存在关联关系。类图如下:
    在这里插入图片描述

    用例图
    主要用户有管理员和借阅者:
    管理员可以接收用户的预约处理,检查读者账号后借出图书。接收图书归还,超时则收取罚款。
    借阅者主要包括老师和学生,借阅者可以登陆系统,查询图书,预约图书,借阅图书,查询借阅记录,归还图书,缴纳罚款。
    在这里插入图片描述在这里插入图片描述

    展开全文
  • 学生信息管理系统文档,非常详细,包括用例图,类图,时序图等等
  • 学生信息管理系统UML图,包括活动图,时序图,类图,状态图!
  • 学生信息管理系统课程设计,包含学生信息管理、学生成绩管理、院系管理、及所在专业信息管理。 有两种角色:学生和管理员。 UML建模:包含了类图、序列图、协作图、活动图、状态图。
  • 第一章 需求分析 1 ...2.6.3 维护用户信息模块类图 20 第三章 动态行为模型 21 3.1 系统序列图 21 3.2 建立协作图 23 3.3 建立状态图 24 3.4 建立活动图 25 第四章 部署建模 29 4.1 系统构件图 29 4.2 系统部署图 29
  • 内含有完整系统程序、数据库和论文。...本系统实现了基本的学生信息管理功能,论文中包含有相应的用例图、类图、顺序图、功能模块图、E-R图和数据表等描述。 本系统适合初学者和大学毕业设计参考。
  • 学生学籍管理信息系统设计 uml 用例图 类图 顺序图
  • 在数据库设计中,采用uml的类图来描绘实体类、虚类、表格类及它们之间的依赖、泛化关系,对成人教育函授站底层的信息管理,基于B/S模式的系统设计有很好的参考意义。本系统的运行也为规范相关高校继续教育的管理...
  • 为在院级教务管理系统的设计提供主要依据,包括类图,详细的数据库设计,详细的模块划分和模块类图
  • 软件工程 学生管理系统 实验报告 有用例图 顺序图 流程图 协作图。很完整的一份软件工程思想的实验报告。 1 设计任务与目的 1 1.1 项目计划 1 2 需求分析 1 2.1用例图 3 2.1.1 学生用例图 3 2.1.2 教师用例图 3 ...
  • 设计一个简单的学生成绩管理系统,要求能够录入并存储学生信息、课程信息以及每个学生每门课程的成绩。 学生信息包括姓名、学号。性别和把班级。 课程信息包括课程号、课程名和学分。 系统的功能包括:计算每个学生...

    设计一个简单的学生成绩管理系统,要求能够录入并存储学生信息、课程信息以及每个学生每门课程的成绩。
    学生信息包括姓名、学号。性别和把班级。
    课程信息包括课程号、课程名和学分。
    系统的功能包括:计算每个学生的总成绩、平均成绩和总学分,计算每个班级的平均成绩,按照学生平均成绩由高到低的顺序进行排序,统计所有学生每门课程的平均成绩。

    下面给出题目要求的UML类图


    具体代码如下,代码主要是针对这个问题所设计的类图及之间的关系。

    Main类,程序入口,含各类菜单调用

    package Main;
    
    import java.util.Scanner;
    
    import student.Student;
    import course.Course;
    import file.File;
    import grade.Grade;
    import team.Team;
    
    public class Main {
    
    	static Scanner in = new Scanner(System.in);
    	static Student student = new Student();
    	static Course course = new Course();
    	public static void main(String[] args) {
    		
    		Main.mainPage();
    		
    	}
    	public static void mainPage()
    	{
    		System.out.println("***********************");
    		System.out.println("\t 1.学生信息");
    		System.out.println("\t 2.课程信息");
    		System.out.println("\t 3.班级信息");
    		System.out.println("\t 4.成绩信息");
    //		System.out.println("\t 5.文件操作");
    		System.out.println("***********************");
    		System.out.println("请输入选项,或者按0退出");
    		do {
    			String choice = in.next();
    			String regex = "[0-4]";		//正则表达式
    			if(choice.matches(regex))
    			{
    				int info = Integer.parseInt(choice);
    				switch(info)
    				{
    				case 0:
    					System.out.println("-----------------");
    					System.out.println("您已经退出了系统!");
    					System.exit(1);	//退出程序,返回值随便设置
    					break;
    				case 1:
    					StudentmainPage();
    					break;
    				case 2:
    					CoursemainPage();
    					break;
    				case 3:
    					TeammainPage();
    					break;
    				case 4:
    					GrademainPage();
    					break;
    				case 5:
    					FilemainPage();
    				default:
    					break;
    				}
    			}
    			System.out.println("重新选择或者按0退出");
    		}while(true);
    	}
    	public static void StudentmainPage()
    	{
    		
    	
    		System.out.println("***********************");
    		System.out.println("\t 1.录入学生信息");
    		System.out.println("\t 2.输出学生信息");
    		System.out.println("\t 3.每个学生各门课程总成绩");
    		System.out.println("\t 4.每个学生各门课程平均成绩");
    		System.out.println("\t 5.每个学生课程的总学分");
    		System.out.println("\t 6.课程平均分按从高到低的顺序排序");
    		System.out.println("\t 7.返回上一级");
    		System.out.println("***********************");
    		System.out.println("请输入选项,或者按0退出");
    		do {
    			String choice = in.next();
    			String regex = "[0-7]";		//正则表达式
    			if(choice.matches(regex))
    			{
    				int info = Integer.parseInt(choice);
    				switch(info)
    				{
    				case 0:
    					System.out.println("-----------------");
    					System.out.println("您已经退出了系统!");
    					System.exit(1);	//退出程序,返回值随便设置
    					break;
    				case 1:
    					student = Student.studentinput();
    					break;
    				case 2:
    					Student.studentoutput(Student.studentlist);
    					break;
    				case 3:
    					Student.studentsumOfGrades(Grade.gradeList,Student.studentlist);
    					break;
    				case 4:
    					Student.studentavgOfGrades(Course.courselist,Grade.gradeList,Student.studentlist);
    					break;
    				case 5:
    					Student.studentsumOfCredits(Course.courselist);
    					break;
    				case 6:
    					Student.studentgradeRank();
    					break;
    				case 7:
    					Main.mainPage();
    					break;
    				default:
    					break;
    				}
    			}
    			System.out.println("重新选择或者按0退出");
    		}while(true);
    	}
    	public static void CoursemainPage()
    	{
    		System.out.println("***********************");
    		System.out.println("\t 1.录入课程信息");
    		System.out.println("\t 2.输出课程信息");
    		System.out.println("\t 3.每门课程平均分信息");
    		System.out.println("\t 4.返回上一级");
    		System.out.println("***********************");
    		System.out.println("请输入选项,或者按0退出");
    		do {
    			String choice = in.next();
    			String regex = "[0-4]";		//正则表达式
    			if(choice.matches(regex))
    			{
    				int info = Integer.parseInt(choice);
    				switch(info)
    				{
    				case 0:
    					System.out.println("-----------------");
    					System.out.println("您已经退出了系统!");
    					System.exit(1);	//退出程序,返回值随便设置
    					break;
    				case 1:
    					course = Course.courseinput();
    					break;
    				case 2:
    					Course.courseoutput(Course.courselist);
    					break;
    				case 3:
    					Course.courseavgOfGrades();
    					break;
    				case 4:
    					Main.mainPage();
    					break;
    				default:
    					break;
    				}
    			}
    			System.out.println("重新选择或者按0退出");
    		}while(true);
    	}
    	public static void TeammainPage()
    	{
    		System.out.println("***********************");
    		System.out.println("\t 1.录入班级信息");
    		System.out.println("\t 2.输出班级信息");
    		System.out.println("\t 3.每个班级的班级总分平均分");
    		System.out.println("\t 4.返回上一级");
    		System.out.println("***********************");
    		System.out.println("请输入选项,或者按0退出");
    		do {
    			String choice = in.next();
    			String regex = "[0-4]";		//正则表达式
    			if(choice.matches(regex))
    			{
    				int info = Integer.parseInt(choice);
    				switch(info)
    				{
    				case 0:
    					System.out.println("-----------------");
    					System.out.println("您已经退出了系统!");
    					System.exit(1);	//退出程序,返回值随便设置
    					break;
    				case 1:
    					Team.teaminput(student);
    					break;
    				case 2:
    					Team.teamoutput(Team.teamlist);
    					break;
    				case 3:
    					Team.teamavgOfGrades();
    					break;
    				case 4:
    					Main.mainPage();
    					break;
    				default:
    					break;
    				}
    			}
    			System.out.println("重新选择或者按0退出");
    		}while(true);
    	}
    	public static void GrademainPage()
    	{
    		System.out.println("***********************");
    		System.out.println("\t 1.录入学生成绩信息");
    		System.out.println("\t 2.显示学生成绩信息");
    		System.out.println("\t 3.返回上一级");
    		System.out.println("***********************");
    		System.out.println("请输入选项,或者按0退出");
    		do {
    			String choice = in.next();
    			String regex = "[0-3]";		//正则表达式
    			if(choice.matches(regex))
    			{
    				int info = Integer.parseInt(choice);
    				switch(info)
    				{
    				case 0:
    					System.out.println("-----------------");
    					System.out.println("您已经退出了系统!");
    					System.exit(1);	//退出程序,返回值随便设置
    					break;
    				case 1:
    					Grade.gradeinput(student, course);
    					break;
    				case 2:
    					Grade.gradeoutput(Grade.gradeList);
    					break;
    				case 3:
    					Main.mainPage();
    					break;
    				default:
    					break;
    				}
    			}
    			System.out.println("重新选择或者按0退出");
    		}while(true);
    	}
    	public static void FilemainPage()
    	{
    		System.out.println("***********************");
    		System.out.println("\t 1.录入学生信息到文件");
    		System.out.println("\t 2.录入课程信息到文件");
    		System.out.println("\t 3.录入成绩信息到文件");
    		System.out.println("\t 4.返回上一级");
    		System.out.println("***********************");
    		System.out.println("请输入选项,或者按0退出");
    		do {
    			String choice = in.next();
    			String regex = "[0-3]";		//正则表达式
    			if(choice.matches(regex))
    			{
    				int info = Integer.parseInt(choice);
    				switch(info)
    				{
    				case 0:
    					System.out.println("-----------------");
    					System.out.println("您已经退出了系统!");
    					System.exit(1);	//退出程序,返回值随便设置
    					break;
    				case 1:
    					File.stuedntWrite(Student.studentlist);
    					break;
    				case 2:
    					File.courseWrite(Course.course);
    					break;
    				case 3:
    					File.scoreWrite(Grade.gradeList);
    					break;
    				case 4:
    					Main.mainPage();
    					break;
    				default:
    					break;
    				}
    			}
    			System.out.println("重新选择或者按0退出");
    		}while(true);
    	}
    }
    
    

    课程Course类

    package course;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Scanner;
    import java.util.Set;
    import java.util.TreeSet;
    
    import grade.Grade;
    import student.Student;
    
    public class Course {
    	private String code;
    	private String name;
    	private float credit;
    	static double sum;
    	List<Grade> grades = new ArrayList<Grade>();
    	static Scanner in = new Scanner(System.in);
    	public static List<Course> courselist = new ArrayList<>();
    	public static Course course = new Course();
    	public Course(String code,String name,float credit)
    	{
    		this.code = code;
    		this.name = name;
    		this.credit = credit;
    	}
    	public Course(){}
    	public String getcode()
    	{
    		return code;
    	}
    	public void setcode(String code)
    	{
    		this.code = code;
    	}
    	public String getname()
    	{
    		return name;
    	}
    	public void setname(String name)
    	{
    		this.name = name;
    	}
    	public float getcredit()
    	{
    		return credit;
    	}
    	public void setcredit(float credit)
    	{
    		this.credit = credit;
    	}
    	/*
    	 * 录入信息--课程编号,课程名称,学分
    	 * */
    	public static Course courseinput()
    	{
    		System.out.print("请输入课程编号:");
    		String co = in.next();
    		System.out.print("请输入课程名称:");
    		String na = in.next();
    		System.out.print("请输入课程学分:");
    		float cr = in.nextFloat();
    		Course course = new Course();
    		course.setcode(co);
    		course.setname(na);
    		course.setcredit(cr);
    		courselist.add(course);
    		return course;
    	}
    	/*
    	 * 输出信息--课程编号,课程名称,学分
    	 * */
    	public static void courseoutput(List<Course> courselist)
    	{
    		System.out.println("\t课程编号\t课程名称\t\t学分");
    		for (Iterator iterators = courselist.iterator();iterators.hasNext();)
    		{
    			Course course = (Course) iterators.next();
    			String co = course.getcode();
    			String na = course.getname();
    			float cr = course.getcredit();
    			System.out.println("\t"+co+"\t"+na+"\t\t"+cr);
    		}
    	}
    	/*
    	 * 每门课程的平均成绩
    	 * */
    	public static void courseavgOfGrades()
    	{
    		double avg = 0;
    		Set<String> set = new TreeSet<String>();
    		int j = 0;
    		for(Iterator iterator = Course.courselist.iterator();iterator.hasNext();)
    		{
    			Course c = (Course)iterator.next();
    			String coursename = c.getname();
    			set.add(coursename);
    		}
    		for(j=0;j<set.size();j++)
    		{
    			String[] m = new String[set.size()];
    			set.toArray(m);
    			double sum = 0;
    			int size =0;
    			for(int i=0;i<Grade.gradeList.size();i++)
    			{
    				List temp = new ArrayList();
    				for(Iterator iterator = Grade.gradeList.iterator();iterator.hasNext();)
    				{
    					Grade grade = (Grade)iterator.next();
    					String coursename = grade.getcourse();
    					if(coursename.equals(m[j]))
    					{
    						float coursescore = grade.getscore();
    						temp.add(coursescore);
    					}
    				}
    				for(Iterator iterator = temp.iterator();iterator.hasNext();)
    				{
    					float f= (float)iterator.next();
    					sum += f;
    					++size;
    				}
    				avg = sum/size;
    				System.out.println("\t"+m[j]+"平均分为:"+avg);
    				break;
    			}
    			
    		}	
    	}
    }
    
    

    学生Student类

    package student;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Scanner;
    import java.util.Set;
    import java.util.TreeSet;
    
    import course.Course;
    import grade.Grade;
    import team.Team;
    
    public class Student {
    	private String number;
    	private String name;
    	private char sex;
    	private Team team = new Team();
    	private List<Grade> grades = new ArrayList<Grade>();
    	public static List<Student> studentlist = new ArrayList<>();
    	static List<Grade> gradeList = new ArrayList<>();
    	public static Student student = new Student();
    	static List avglist = new ArrayList();
    	public static Scanner in = new Scanner(System.in);
    	/*
    	 * 添加学生信息
    	 * */
    	public Student(String Stunum,String Stuname,char Stusex,Team Stuteam)
    	{
    		this.number = Stunum;
    		this.name = Stuname;
    		this.sex = Stusex;
    		this.team = Stuteam;
    	}
    	public Student() {}
    	//字符串截取函数
    	public static String jiequ(String str)
    	{
    		return str.substring(0, 1);
    	}
    	//共有-get、set-方法
    	public String getnumber()
    	{
    		return number;
    	}
    	public void setnumber(String number)
    	{
    		this.number = number;
    	}
    	public String getname()
    	{
    		return name;
    	}
    	public void setname(String name)
    	{
    		this.name = name;
    	}
    	public char getsex()
    	{
    		return sex;
    	}
    	public void setsex(char sex)
    	{
    		this.sex = sex;
    	}
    	public Team getteam()
    	{
    		return team;
    	}
    	public void setteam(Team team)
    	{
    		this.team = team;
    	}
    	public List<Grade> getgrade()
    	{
    		return grades;
    	}
    	public void getgrade(List<Grade> grades)
    	{
    		this.grades = grades;
    	}
    	/*
    	 * 录入信息--学号,姓名,性别
    	 * */
    	public static Student studentinput()
    	{
    		System.out.print("请输入学生学号:");
    		String num = in.next();
    		System.out.print("请输入学生姓名:");
    		String na = in.next();
    		System.out.print("请输入学生性别:");
    		char se = in.next().charAt(0);
    		Student student = new Student();
    		student.setnumber(num);
    		student.setname(na);
    		student.setsex(se);
    		studentlist.add(student);
    		return student;
    	}
    	/*
    	 * 输出信息--学号,班级,性别,班级
    	 * */
    	public static void studentoutput(List<Student> studentlist)
    	{
    		System.out.println("\t学号\t姓名\t性别\t班级");
    		for (Iterator iterators = studentlist.iterator();iterators.hasNext();)
    		{
    			Student student = (Student) iterators.next();
    			String num = student.getnumber();
    			String na = student.getname();
    			char se = student.getsex();
    			System.out.println("\t"+num+"\t"+na+"\t"+se+"\t"+jiequ(num));
    		}
    	}
    	/*
    	 * 每个学生的总成绩
    	 * gradelist里有学生,课程名,成绩
    	 * 每个学生的总成绩主要找到一个学生对应的多个成绩,将它们存在一个容器中
    	 * 进行判断,如果等于该学生,则将该学生的成绩压入容器中,遍历容器求和即可
    	 * */
    	public static void studentsumOfGrades(List<Grade> gradeList,List<Student> studentlist)
    	{
    		Set<String> set = new TreeSet<String>();
    		int j = 0;
    		for(Iterator iterator = Student.studentlist.iterator();iterator.hasNext();)
    		{
    			Student s = (Student)iterator.next();
    			String studentname = s.getname();
    			set.add(studentname);
    		}
    		for(j=0;j<set.size();j++)
    		{
    			String[] e = new String[set.size()];
    			set.toArray(e);
    			double sum = 0;
    			for(int i=0;i<Grade.gradeList.size();i++)
    			{
    				List temp = new ArrayList();
    				
    				for(Iterator iterator = Grade.gradeList.iterator();iterator.hasNext();)
    				{
    					Grade grade = (Grade)iterator.next();
    					String studentname = grade.getstudent();
    					if(studentname.equals(e[j]))
    					{
    						float coursescore = grade.getscore();
    						temp.add(coursescore);
    					}
    				}
    				for(Iterator iterator = temp.iterator();iterator.hasNext();)
    				{
    					float f= (float)iterator.next();
    					sum += f;
    				}
    				System.out.println("\t"+e[j]+"总分为:"+sum);
    				break;
    			}
    			
    		}	
    	}
    	/*
    	 * 每个学生各门课程平均成绩
    	 * gradelist里有学生,课程名,成绩,不存在重复信息
    	 * 
    	 * */
    	public static List studentavgOfGrades(List<Course> courselist,List<Grade> gradelist,List<Student> studentlist)
    	{
    		double avg;
    		HashMap<String, String> map =new HashMap<String, String>();
    		for (Iterator iterator = Course.courselist.iterator(); iterator.hasNext(); ) 
    		{
            	Course temp=(Course)iterator.next();
            	String courname = temp.getname();
            	float courcredit = temp.getcredit();
            	String s=String.valueOf(courcredit);
            	map.put(courname, s);
            }
    		int size = map.size();
    		Set<String> set = new TreeSet<String>();
    		int j = 0;
    		for(Iterator iterator = Student.studentlist.iterator();iterator.hasNext();)
    		{
    			Student s = (Student)iterator.next();
    			String studentname = s.getname();
    			set.add(studentname);
    		}
    		for(j=0;j<set.size();j++)
    		{
    			String[] e = new String[set.size()];
    			set.toArray(e);
    			double sum = 0;
    			for(int i=0;i<Grade.gradeList.size();i++)
    			{
    				List temp = new ArrayList();
    				
    				for(Iterator iterator = Grade.gradeList.iterator();iterator.hasNext();)
    				{
    					Grade grade = (Grade)iterator.next();
    					String studentname = grade.getstudent();
    					if(studentname.equals(e[j]))
    					{
    						float coursescore = grade.getscore();
    						temp.add(coursescore);
    					}
    				}
    				for(Iterator iterator = temp.iterator();iterator.hasNext();)
    				{
    					float f= (float)iterator.next();
    					sum += f;
    				}
    				avg = sum/size;
    				avglist.add(avg);
    				System.out.println("\t"+e[j]+"平均分为:"+sum/size);
    				break;
    			}
    		}	
    		return avglist;
    	}
    	/*
    	 * 每个学生课程的总学分
    	 * courselist里有课程编号,课程名称,学分
    	 * 找一个容器,将courselist里的课程名称和学分存进去(不能有重复元素)
    	 * 然后遍历该容器,将这个容器的里的学分求和即可
    	 * */
    	public static double studentsumOfCredits(List<Course> courselist)
    	{
    		HashMap<String, String> map =new HashMap<String, String>();
    		double sum=0;
    		for (Iterator iterator = Course.courselist.iterator(); iterator.hasNext(); ) 
    		{
            	Course temp=(Course)iterator.next();
            	String courname = temp.getname();
            	float courcredit = temp.getcredit();
            	String s=String.valueOf(courcredit);
            	map.put(courname, s);
            }
    		int size = map.size();
    		for(Entry<String, String> entry : map.entrySet())
    		{  
                String val = entry.getValue();
                try {
                    float a = Float.parseFloat(val);
                    sum+=a;
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
    		}   
    		System.out.println("\t系统"+size+"门课程总学分为:"+sum);
    		return sum;
    	}
    	/*每个学生课程的平均成绩排序(按从高到低进行排序)
    	 * 
    	 * */
    	public static void studentgradeRank()
    	{
    		Map map = new HashMap();
    		Set<String> set = new TreeSet<String>();
    		int j = 0;
    		for(Iterator iterator = Student.studentlist.iterator();iterator.hasNext();)
    		{
    			Student s = (Student)iterator.next();
    			String studentname = s.getname();
    			set.add(studentname);
    		}
    		String[] key = new String[set.size()];
    		set.toArray(key);
    		int i = 0;
    		while(i<key.length)
    		{
    			for (Iterator iterator =Student.avglist.iterator(); iterator.hasNext(); ) 
    			{	
    				double value=(double)iterator.next();
    				map.put(key[i],value);
    				i++;
    	        }
    		}
    		List<Map.Entry<String, Double>> wordMap = new ArrayList<Map.Entry<String, Double>>(map.entrySet());
    		Collections.sort(wordMap, new Comparator<Map.Entry<String, Double>>() {// 根据value排序
    			public int compare(Map.Entry<String, Double> o1, Map.Entry<String, Double> o2) 
    			{
    				double result = o2.getValue() - o1.getValue();
    				if (result > 0)
    					return 1;
    				else if (result == 0)
    					return 0;
    				else
    					return -1;
    			}
    		});
    //		System.out.println(wordMap);
    		for(Map.Entry<String, Double> px:wordMap)
    		{
    			System.out.println("\t"+px.getKey() +":"+px.getValue());
    		}
    	}
    	
    }
    

    班级Team类

    package team;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Scanner;
    import java.util.Set;
    import java.util.TreeSet;
    import java.util.Map.Entry;
    
    import course.Course;
    import grade.Grade;
    import student.Student;
    
    public class Team {
    	private String no;
    	public static List<Team> teamlist = new ArrayList<>();
    	public static  Set set = new HashSet();
    	Scanner in = new Scanner (System.in);
    	/*
    	 * 添加班级信息
    	 * */
    	public Team(String no)
    	{
    		this.no = no;
    	}
    	public Team() {}
    	public String getno()
    	{
    		return no;
    	}
    	public void setno(String str)
    	{
    		no = str;
    	}
    	public static String jiequ(String str)
    	{
    		return str.substring(0, 1);
    	}
    	public static List teaminput(Student student)
    	{
    		Team team = new Team();
    		String str1 = student.getnumber();
    		String str = jiequ(str1);
    		team.setno(str);
    		teamlist.add(team);
    		set.add(team);
    		return teamlist;
    	}
    	public static void teamoutput(List<Team> teamlist)
    	{
    		System.out.println("\t班级");
    		for (Iterator iterators = teamlist.iterator();iterators.hasNext();)
    		{
    			Team team =(Team) iterators.next();
    			String no = team.getno();
    			System.out.println("\t"+no);
    		}
    	}
    	/*
    	 * 每个班级的平均成绩
    	 * */
    	public static void teamavgOfGrades()
    	{
    		HashMap<String, Float> map =new HashMap<String, Float>();
    		for (Iterator iterators = Grade.gradeList.iterator();iterators.hasNext();)
    		{
    			Grade grade = (Grade) iterators.next();
    			String stuteam = grade.getteam();
    			float sc = grade.getscore();
    			map.put(stuteam, sc);		//班号对应成绩
    		}
    		HashMap<String, String> map1 =new HashMap<String, String>();
    		for (Iterator iterator = Course.courselist.iterator(); iterator.hasNext(); ) 
    		{
            	Course temp=(Course)iterator.next();
            	String courname = temp.getname();
            	float courcredit = temp.getcredit();
            	String s=String.valueOf(courcredit);
            	map1.put(courname, s);			//课程对应学分
            }
    		int size1 = map1.size();				//获得课程数
    		HashMap<String, String> map2 =new HashMap<String, String>();
    		for (Iterator iterator = Student.studentlist.iterator();iterator.hasNext(); ) 
    		{
            	Student temp=(Student)iterator.next();
            	String stunum = temp.getnumber();
            	stunum = jiequ(stunum);
            	String stuname = temp.getname();
            	map2.put(stunum,stuname);		//班号对应姓名
            }
    		Set<String> set = new TreeSet<String>();
    		for(Entry<String, String> entry : map2.entrySet())
    		{ 
    			String key = entry.getKey();
    			set.add(key);
    		}
    		String[] e = new String[set.size()];
    		set.toArray(e);
    		HashMap<String, Integer> map3 =new HashMap<String, Integer>();
    		for(int j=0;j<set.size();j++)
    		{
    			int cnt =0;
    			for(Entry<String, String> entry : map2.entrySet())
    			{ 
    				String key = entry.getKey();
    				if(key.equals(e[j]))
    				{
    					++cnt;
    				}
    			}
    			map3.put(e[j],cnt);	//统计相同班数的人数,班号对应人数
    		}
    //		System.out.println(map3);
    		/*
    		 * map3里有班号,人数
    		 * size1课程数
    		 * map1里班号,成绩
    		 * */
    		List<Integer> arr = new ArrayList<Integer>();
    		for(Entry<String, Integer> entry : map3.entrySet())
    		{ 
    			Integer val = entry.getValue();
    			arr.add(val);
    		}
    //    	for(Integer elem : arr){
    //    		System.out.println(elem);
    //    	}
    		for(int j=0;j<set.size();j++)
    		{
    			double sumgrade = 0;
    			for (Iterator iterators = Grade.gradeList.iterator();iterators.hasNext();)
    			{
    				Grade grade = (Grade) iterators.next();
    				String stuteam = grade.getteam();
    				float sc = grade.getscore();
    				if(stuteam.equals(e[j]))
    				{
    					sumgrade+=sc;
    				}
    			}
    			double avg = sumgrade/size1/arr.get(j);			
    			System.out.println("\t"+e[j]+"班"+"平均分是"+avg);
    		}
    	}
    }
    
    

    成绩Grade类

    package grade;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Scanner;
    
    import course.Course;
    import student.Student;
    
    public class Grade {
    	private static Student student;
    	private static Course course;
    	private  float score;
    	String cour,stu,stuteam;
    	public static List<Grade> gradeList = new ArrayList<>();
    	static List<Student> studentlist = new ArrayList<>();
    	static Scanner in = new Scanner(System.in);
    	public Grade(Student student,Course course,float score)
    	{
    		this.student = student;
    		this.course = course;
    		this.score = score;
    	}
    	public Grade() {}
    	//字符串截取函数
    	public static String jiequ(String str)
    	{
    		return str.substring(0, 1);
    	}
    	public String getstudent()
    	{
    		return stu;
    	}
    	public void setstudent(Student student)
    	{
    		stu = student.getname();
    	}
    	public String getcourse()
    	{
    		return cour;
    	}
    	public void setteam(Student student)
    	{
    		stuteam = student.getnumber();
    		stuteam = jiequ(stuteam);
    	}
    	public String getteam()
    	{
    		return stuteam;
    	}
    	public void setcourse(Course course)
    	{
    		cour = course.getname();
    	}
    	public float getscore()
    	{
    		return score;
    	}
    	public void setsocre(float score)
    	{
    		this.score = score;
    	}
    	public static List gradeinput(Student student,Course course)
    	{
    		System.out.print("请输入成绩:");
    		float sc = in.nextFloat(); 
    		Grade grade = new Grade();
    		grade.setstudent(student);
    		grade.setcourse(course);
    		grade.setsocre(sc);
    		grade.setteam(student);
    		gradeList.add(grade);
    		return gradeList;
    	}
    	
    	public static void gradeoutput(List<Grade> gradelist)
    	{
    		System.out.println("\t姓名\t课程名称\t\t成绩");
    		for (Iterator iterators = gradeList.iterator();iterators.hasNext();)
    		{
    			Grade grade = (Grade) iterators.next();
    			String name1 = grade.getstudent();
    			String name2 = grade.getcourse();
    			float sc = grade.getscore();
    			System.out.println("\t"+name1+"\t"+name2+"\t\t"+sc);
    		}
    	}	
    }
    
    展开全文
  • OOAD-类图

    2017-04-13 17:21:16
    为了解决学校学生选课收集学生选课信息的繁琐,减少课程管理员的工作负担,及时向同学们更新选课信息,使得学生选课工作能够高效进行等问题,我们需要开发一选课系统。选课系统应该满足以下需求: 在每个学期开始时...

    1.       问题陈述 Problem statement

    为了解决学校学生选课收集学生选课信息的繁琐,减少课程管理员的工作负担,及时向同学们更新选课信息,使得学生选课工作能够高效进行等问题,我们需要开发一选课系统。选课系统应该满足以下需求:

    在每个学期开始时,课程管理员根据课程设置部门和教室分配部门分别提供的教学计划和教室分配情况,按专业生成以及维护本学期的选课表,然后在网上发布,以供学生选课之用。

    在课表发布之后,学期开始的前两个星期内,学生按培养计划进行课程的试听和选课。在这期间,学生随时可以查询与更改所选课程。选课期间学生可以查询课程介绍、任课老师情况以及自己以往的选课的成绩,选课只能选择自己的课程。每门课开课的人数条件为多余20人并少于80人,人数过多时一门课可以分成多班级教学。两个星期后如果学生所选课程不满足开课条件,学生可以在第三周内选择其他课程。第四周起,课程管理员生成开课汇总表,把相关信息发送给有关部门(财务部、教材部等)并在网上公布开课汇总表,同时学生课上网查询自己的选课信息。

    2.       词汇表 Glossary

    课程管理员:

    负责根据教学计划和教室分配情况给每个专业生成选课表,并在后期进行维护的工作人员。

    教学计划:

              学校教务部门对每个专业的掌握相关知识和技能的要求

    选课表:

              不同专业的学生有不同的可选课程,这些信息和具体的课程介绍构成了选课表

    培养计划:

    学校教务部门对每个专业的学生对选课有一定的要求,不同专业的学生必须选择专业对应模块中的课程。

    课程:

              大学提供给学生的课程

    学生:

              大学内上课的学生

    任课老师:

              给对应课程授课的老师

    开课汇总表:

              所有满足开课条件成功开课的课程

                    

    3.       领域类图 Domain class diagram


    展开全文
  • 界面一:登录界面,应包含学号、密码的输入框,确认后如果用户为学生跳转界面二,用户为教师跳转界面三,用户为系统管理员跳转界面四。 界面二:学生登录后会得到一份包含本学期要开设的课程目录。每门课程包含的...
  • 教材管理系统供教师填写教材信息学生在线查看教材并进行预定,教务员课通过该系统进行教材通知发布等。 ② 类描述 教务员 属性说明: ○1ID:每一个教务员的唯一标识符 ○2姓名:教务员姓名 操作说明: ○1教材...
  • (4) 给定某位学生的学号,修改该学生的作业完成信息; (5) 给定某位学生的学号,删除该学生信息; (6) 提供一些统计各类信息的功能。 设计要求: (1)要求利用面向对象的方法以及MFC框架来完成系统的设计; (2...
  • 主要实现对图书馆信息的管理,该系统可以分为两大块:图书信息的服务系统和图书的综合管理系统。图书的使用对象是借阅者,例如学生,教师;管理者是图书馆的管理员。根据这些图书馆业务信息,本系统的主要功能包括:...
  • 面向对象技术课程设计的课程设计报告书。基于MyEclipse10+Tomca6.3.5+JSP+MySql编写。 要源码+数据库+论文请下载我另一个打包的资源!... 5.2 管理员操作 32 5.3 教师操作 33 5.4 学生操作 34 6.个人总结 36
  • 学生选课系统.zip

    2019-10-22 19:00:57
    a) 学生信息管理:添加学生,修改学生基本信息; b) 课程管理:添加课程,修改课程信息; c) 选课管理:设置学生选修某课程,或取消某课程的选修; d) 数据统计:可分别按学生和课程统计选课情况; 4、 考虑各类异常...
  • 在上一次的课堂上,我们进行了对学生信息管理系统的初步设计,在此我想对这次建模过程做一个初步的总结与完善。 下图是我在课上对根据管理系统的需求简单绘制的一个类艹图,在此记录下,为之后的完善工作提供参考。...
  • 本科生毕业设计管理系统

    热门讨论 2012-11-30 20:15:17
    本文档的编写目的是:详细定义《本科生毕业设计管理系统》软件的总体功能;给出系统的结构设计和过程设计,作为程序编写的依据。 1.2 参考资料 a.项目来源 为了尽快满足学校教学管理人员、教师和学生对高效的毕业...
  • 教学管理系统有一个登录功能,针对三种不同的用户:对学生有三个功能:选课、查询课表、 查询成绩,对老师有三个功能:查询课表、录入成绩、查询课表,对教务员有三个功能:管 理学生、管理老师、管理课程。各个界面...
  • 我们做的是图书管理系统,分别有借阅者、系统管理员和图书管理员。为了方便图书馆管理人员对图书的借阅、归还等提供轻松快捷的管理方式,同时也方便学生可以随时随地的对图书进行续借、查询、缴纳罚款等。主要体现在...
  • 信息系统论文模板

    2013-12-13 09:00:13
    高校教材管理系统的使用人员主要有三类:第一类是学生;第二类是教师;第三类是管理人员。管理员主要的工作有教材的入库、出库、数据的查询、统计以及系统的维护、数据的统计、修改和查询;在校学生则可以查询到本人...
  • 4.21 管理员修改课程信息顺序图 5 4.22学生用户退选课的顺序图 5 4.23教师提交成绩顺序图 6 4.3协作图 7 4.31 学生用户选课协作图 7 4.32 教师提交成绩协作图 8 4.4运行环境规定 8 4.41设备 8 5 系统设计 9 5.1 设计...
  • 图书管理系统实验报告-面向对象的分析与设计

    千次阅读 多人点赞 2020-07-05 11:47:17
    图书管理系统实验报告-面向对象的分析与设计 背景、意义;需求分析;用例分析、类图、顺序图、通信图、活动图 1.研究背景及意义 图书馆是一所学校或是一座城市的一个文化标志,可以为学生以及社会上的各界人士提供...
  • 已知资料管理系统提供资料信息维护、资料查询、借阅/归还三项基本功能。使用本系统的角色包括管理员、教师、学生三类。管理员可从事所有操作,学生与教师只能进行资料查询、借阅/归还操作。教师最多可以同时借阅10本...
  • 学籍管理实验三

    2019-06-02 12:43:19
    学籍管理系统学生有三个功能:登陆、查询学籍、修改密码;对学籍管理人员有五个功能:登陆、删除学籍、查询学籍、修改学籍、制定计划;对于成绩管理人员仅有发送成绩功能。各个界面类都需要各自的控制类返回信息。...
  • 教务管理系统 设计类图 :1.选课管理:2.成绩管理: 类图文档1.选课管理:(1)教务管理员类图综述:用于记录教务管理员的信息与功能类描述:l 属性:姓名、工作证号l 操作:生成学期选课表、维护选课表、课表...

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

学生信息管理系统类图