Java学习第37天--SE综合案例(基础功能)

千锋逆战班：孙华建
在千锋学习第37天
“未来的你会感谢今天奋斗的自己”
今天我学习了java课程，SE综合案例
#中国加油！武汉加油！千锋加油！也为自己加油！！！#…

Menu

package com.qf.project.menu;

import java.util.Scanner;

import com.qf.project.entity.Student;
import com.qf.project.service.StudentService;

public class SystemMain {
	static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		StudentService ss = new StudentService();
		int choice = 0;
		
		for(int i = 0;i<10;i++) {
			String name="吴"+i;
			int age = (int)(Math.random()*50);
			String gender = "男";
			String className = "NZ2002";
			double javaScore = (double)(Math.random()*100);
			double htmlScore = (double)(Math.random()*100);
			double springScore = (double)(Math.random()*100);
			ss.addStudent(new Student(name,className,age,gender,javaScore,htmlScore,springScore));
			
		}
		
		while(true) {
			System.out.println("欢迎进入千峰学生系统");
			System.out.println("1,查看所有学员");
			System.out.println("2,新增学员");
			System.out.println("3,查询指定ID的学生信息");
			System.out.println("4,根据ID删除学生");
			System.out.println("5,根据ID修改学生信息");
			System.out.println("6,根据班级名称查询学员");
			System.out.println("7,根据姓名（姓/名）查询学员");
			System.out.println("8,根据需求排序学生信息");
			System.out.println("9,根据需求展示符合条件的学生信息");
			System.out.println("10,退出");
			System.out.println("请输入编号选择想要进行的操作");
			
			choice = sc.nextInt();
			switch(choice) {
			case 1:
				//查看所有学员
				ss.show();
				break;
			case 2:
				//新增学员
				ss.addStudent();
				break;
			case 3:
				ss.getStudentById();
				break;
			case 4:
				ss.deleteStudentById();
				break;
			case 5:
				ss.updateStudentById();
				break;
			case 6:
				ss.getStudentByClassName();
				break;
			case 7:
				ss.getStudentByLike();
				break;
			case 8:
				ss.sortStu();
				break;
			case 9:
				ss.showFilter();
				break;
			case 10:
				System.out.println("欢迎下次使用"); 
				return;
			case 0:
				//退出
				return;
			default:
				break;
			}
		}
		
		
		
	
	}
}

StudentService

package com.qf.project.service;

import java.util.Scanner;

import com.qf.project.entity.Student;
import com.qf.project.manager.StudentManager;
import com.qf.project.util.MyComparator;
import com.qf.project.util.MyFileter;

public class StudentService {
	//接受菜单请求，执行对应方法
	//调用StudentManager,传递数据，插入到底层
	
	Scanner sc = new Scanner(System.in);
	StudentManager stm = new StudentManager();
	
	/**
	 * 展示所有学生
	 */
	public void show() {
		stm.get();
	}
	
	/**
	 * 新增学员的方法
	 * 让用户输入数据，并判断数据
	 */
	public void addStudent() {

		//对输入的ID进行判断，输入错误循环重新输入
		
		System.out.println("请输入学生姓名");
		String name = sc.next();
		
		System.out.println("请输入学生班级");
		String className = sc.next();
		
		int age = 0;
		do{
			System.out.println("请输入学生年龄");
			age = sc.nextInt();
			if(age<=0||age>125) {
				System.out.println("哈哈你是魔鬼吗？写真实年龄啦");
			}
		}while(age<=0||age>125);
		
		
		System.out.println("请输入学生性别（男/女）");
		String gender = sc.next();
		
		System.out.println("请输入学生java考试成绩，若没有，请输入0");
		double javaScore = sc.nextDouble();
		
		System.out.println("请输入学生heml考试成绩，若没有，请输入0");
		double htmlScore = sc.nextDouble();
		
		System.out.println("请输入学生spring考试成绩，若没有，请输入0");
		double springScore = sc.nextDouble();
		
		Student stu = new Student(name,className,age,gender,javaScore,htmlScore,springScore);
		
		boolean result =stm.add(stu);
		if(result==true) {
			System.out.println("添加成功");
			System.out.println(stu);
		}else {
			System.out.println("添加失败");
		}
	}

	public void addStudent(Student stu) {
		stm.add(stu);
	}
	
	public void getStudentById() {
		//1，判断ID是否正确
		int id = 0;
		do {
			System.out.println("请输入学生ID：");
			id = sc.nextInt();
			if(id<=0) {
				System.out.println("学生ID为大于0的整数");
			}
		}while(id<=0);
		//2，判断学生是否存在
		Student stu =stm.get(id);
		
		if(stu!=null) {
			System.out.println("学号为"+id+"的学员的信息为：");
			System.out.println(stu);
		}else {
			System.out.println("学号为"+id+"的学员信息不存在");
		}
	}

	public void deleteStudentById() {
		//1,判断输入是否正确
		int id = 0;
		do {
			System.out.println("请输入学生ID：");
			id = sc.nextInt();
			if(id<=0) {
				System.out.println("学生ID为大于0的整数");
			}
		}while(id<=0);
		Student stu = stm.remove(id);
		if(stu != null) {
			System.out.println("删除成功");
		}else {
			System.out.println("删除失败");
		}
	}

	public void updateStudentById() {
		int id = 0;
		do {
			System.out.println("请输入学生ID：");
			id = sc.nextInt();
			if(id<=0) {
				System.out.println("学生ID为大于0的整数");
			}
		}while(id<=0);
		Student stu = stm.get(id);
		if(stu!=null) {
			System.out.println("现在要修改"+stu.getName()+"的信息：");
			System.out.println("学生ID："+stu.getId());
			System.out.println("学生姓名："+stu.getName());
			System.out.println("学生性别："+stu.getGender());
			System.out.println("学生年龄："+stu.getAge());
			System.out.println("学生班级："+stu.getClassName());
			System.out.println("学生java成绩："+stu.getJavaScore());
			System.out.println("学生html成绩："+stu.getHtmlScore());
			System.out.println("学生spring成绩："+stu.getSpringScore());
			System.out.println("----------------------------------------");
			
			int choice = 0;
			while(true) {
				System.out.println("1，修改学生姓名");
				System.out.println("2，修改学生性别");
				System.out.println("3，修改学生年龄");
				System.out.println("4，修改学生班级");
				System.out.println("5，修改学生java成绩");
				System.out.println("6，修改学生heml成绩");
				System.out.println("7，修改学生spring成绩");
				System.out.println("8，保存修改，退出");
				choice = sc.nextInt();
				switch(choice) {
				case 1:
					System.out.println("请输入学生的新姓名");
					String name = sc.next();
					stu.setName(name);
					break;
				case 2:
					System.out.println("请输入你想修改成的性别");
					String gender = sc.next();
					stu.setGender(gender);
					break;
				case 3:
					System.out.println("请输入你想修改成的年龄");
					int age = sc.nextInt();
					stu.setAge(age);
					break;
				case 4:
					System.out.println("请输入学生的新班级");
					String className = sc.next();
					stu.setClassName(className);
					break;
				case 5:
					System.out.println("请输入学生的新java成绩");
					double javaScore = sc.nextDouble();
					stu.setJavaScore(javaScore);
					break;
				case 6:
					System.out.println("请输入学生的新html成绩");
					double htmlScore = sc.nextDouble();
					stu.setHtmlScore(htmlScore);
					break;
				case 7:
					System.out.println("请输入学生的新string成绩");
					double springScore = sc.nextDouble();
					stu.setSpringScore(springScore);
					break;
				case 8:
					System.out.println("退出,修改完成并保存");
					System.out.println("修改后的学员信息为"+stu);
					return;
				default:
					break;
				}	
			}
		
		}else {
			System.out.println("查无此人，请核对学号");
		}
	}

	public void getStudentByClassName() {
		System.out.println("请输入班级名称：");
		String className = sc.next();
		stm.get(className);
	}
	
	public void getStudentByLike() {
		int choice = 0;
		while(true) {
			System.out.println("请选择：");
			System.out.println("1，根据姓氏查询；2，根据名字查询；0，退出");
			choice = sc.nextInt();
			switch(choice) {
			case 1:
				System.out.println("请输入姓氏");
				String surname = sc.next();
				stm.getSurname(surname);
				break;
			case 2:
				System.out.println("请输入名字");
				String lastname = sc.next();
				stm.getLastname(lastname);
				break;
			case 0:
				System.out.println("退出");
				return;
			}
		}
	}
	
	public void sortStu() {
		//默认为降序
		//可以选择不同方式来排序：1，ID；2，age，3，score
		//选择方式：选择排序
		int choice = 0;
		
		while(true) {
			System.out.println("将按照默认顺序排序，请选择条件：");
			System.out.println("1，id；2，age；3，score；0，退出");
			choice = sc.nextInt();
			switch(choice) {
			case 1:
				/*
				stm.sort(new MyComparator<Student>() {

					@Override
					public int compare(Student stu1, Student stu2) {					
						return stu1.getId()-stu2.getId();
					}
				});
				*/
				stm.sort((stu1,stu2)->stu1.getId()-stu2.getId());
				
				break;
			case 2:
				stm.sort((stu1,stu2)->stu1.getAge()-stu2.getAge());
				break;
			case 3:
				stm.sort((stu1,stu2)->(int)((stu1.getTotalScore()-stu2.getTotalScore())*100));
				break;
			case 0:
				break;
				
			}
		}
	}
	
	public void showFilter() {
		//1,查询年龄大于15的
		//2，查询总分大于150分的
		int choice = 0;
		while(true) {
			System.out.println("选择过滤规则");
			System.out.println("1，年龄大于15的，2，总分大于150分的，0，退出");
			choice = sc.nextInt();
			switch(choice) {
			case 1:
				stm.showStuForFilter((s)->s.getAge()>=15);
				
//				stm.showStuForFilter(new MyFileter<Student>() {
//
//					@Override
//					public boolean accept(Student e) {
//						
//						return e.getAge() >= 15;
//					}
//					
//				} );
				break;
			case 2:
				stm.showStuForFilter((s)->s.getTotalScore()>=150);
				break;
			case 0:
				return;
			
			}
		}
		
	}
	
	
	
	
	
	
	
}

StudentManager

package com.qf.project.manager;

import com.qf.project.entity.Student;
import com.qf.project.util.MyComparator;
import com.qf.project.util.MyFileter;
import com.qf.project.util.impl.MyArrayList;

/**
 * 完成所有学生管理系统的相关功能
 * 逻辑代码
 * @author winter
 *
 */

public class StudentManager {
	//存储学生对象
	private MyArrayList<Student> allStudents = null; 
	
	public StudentManager() {
		allStudents = new MyArrayList<Student>();
	}
	//传入指定容量，底层有对容量做要求大于0，小于Integer,MAX_VALUE,如不满足，报异常
	public StudentManager(int initCapacity) {
		allStudents = new MyArrayList<Student>(initCapacity);
	}
	/**
	 * 增加，采用尾插法
	 * @param stu
	 * @return，增加成功返回true,失败返回false
	 */
	public boolean add(Student stu) {
		if(stu == null) {
			System.out.println("存入学生不能是一个空对象");
			return false;
		}
		//存入集合中
		allStudents.add(stu);
		return true;
	}
	
	/**
	 * 删除
	 * @param studentID，根据学生唯一的ID
	 * @return
	 */
	public Student remove(int studentID) {
		//1，检查ID在集合中的下标位置
		int index = findIndexById(studentID);
		try {
			return allStudents.remove(index);
		}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println(e.getMessage() );
		}
		return null;
	}
	
	/**
	 * 根据学生ID修改
	 * @param studentID
	 * @return，成功返回true，失败返回false
	 */
	public boolean modify(int studentID) {
		return false;
	}
	
	/**
	 * 根据学生ID查找对应的学生
	 * @param studentID
	 * @return，查到返回学术对象，失败返回null
	 */
	public Student get(int studentID) {
		//1，判断下标是否正确
		int index = findIndexById(studentID);
		//2，将获得的学生对象返回给StudentService
		if(index>=0) {
			return allStudents.get(index);
		}
		return null;
	}
	
	/**
	 * 根据学员ID寻找集合中的下标
	 * @param studentID
	 * @return，存在的话返回大于0 的下标，失败返回-1
	 */
	public int findIndexById(int studentID) {
		int index = -1;
		for(int i = 0;i<allStudents.size();i++) {
			if(allStudents.get(i).getId()==studentID) {
				index = i;
				break;
			}
		}
		
		return index;//返回查找到的下标
		
	}
	
	/**
	 * 查询所有，遍历集合
	 */
	public void get() {
		//打印所有学生信息
		for(int i =0;i<allStudents.size();i++) {
			System.out.println(allStudents.get(i));
		}
	}
	/**
	 * 根据班级 名称，查询学员列表
	 * @param className
	 */
	public void get(String className) {
		for(int i = 0;i<allStudents.size();i++) {
			if(allStudents.get(i).getClassName().equals(className)) {
				System.out.println(allStudents.get(i));
			}
		}
	}
	
	public void getSurname(String surname) {
		for(int i = 0;i<allStudents.size();i++) {
			if(allStudents.get(i).getName().startsWith(surname)) {
				System.out.println(allStudents.get(i));
			}
		}
	}
	
	public void getLastname(String lastname) {
		for(int i = 0;i<allStudents.size();i++) {
			if(allStudents.get(i).getName().contains(lastname)) {
				System.out.println(allStudents.get(i));
			}
		}
	}
	/**
	 * 根据ID排序
	 */
	/*
	public void sort() {
		//排序不允许在原始数据上做操作，把原数组复制一份
		Object[] sortTemp = allStudents.toArray();
		//选择排序
		for(int i = 0;i<sortTemp.length-1;i++) {
			for(int j = i+1;j<sortTemp.length;j++) {
				if( ((Student)sortTemp[i]).getId() < ((Student)sortTemp[j]).getId()) {
					Student temp = (Student)sortTemp[i];
					sortTemp[i] = sortTemp[j];
					sortTemp[j] = temp;
				}
			}
		}
		for(Object obj:sortTemp) {
			System.out.println(obj);
		}
		
	}
	*/
	/**
	 * 指定排序规则，使用自定义排序接口的方法
	 * @param com
	 */
	public void sort(MyComparator<Student> com) {
		//排序不允许在原始数据上做操作，把原数组复制一份
		Object[] sortTemp = allStudents.toArray();
		//选择排序
		for(int i = 0;i<sortTemp.length-1;i++) {
			for(int j = i+1;j<sortTemp.length;j++) {
				if(com.compare((Student)sortTemp[i],(Student)sortTemp[j])>0) {
					Student temp = (Student)sortTemp[i];
					sortTemp[i] = sortTemp[j];
					sortTemp[j] = temp;
				}
			}
		}
		for(Object obj:sortTemp) {
			System.out.println(obj);
		}	
		
	}
	/**
	 * 自定义过滤器规则，满足条件的会展示
	 * 
	 * @param filter 传的是实现
	 */
	public void showStuForFilter(MyFileter<Student> filter) {
		for(int i = 0;i<allStudents.size();i++) {
			
			if(filter.accept(allStudents.get(i))) {
				
				System.out.println(allStudents.get(i));
			}
		}
		
		
		
		
//		for(int i = 0;i<allStudents.size();i++) {
//			if(allStudents.get(i).getAge() >= 15) {
//				System.out.println(allStudents.get(i));
//			}
//		}
	}
	
	
}

MyArrayList

package com.qf.project.util.impl;

import java.util.Arrays;

import com.qf.project.util.MyList;

public class MyArrayList<E> implements MyList<E> {
	//1.保存任意类型数据的数组，集合的底层
	private Object[] elementData = null;
	//2.集合初始容量
	private static final int DEFAULT_CAPACITY=10;
	//3.保存数组中有效元素个数 (下一个元素插入的下标)
	private int size = 0; 
	
	public  MyArrayList() {
//		elementData = new Object[DEFAULT_CAPACITY];
		/*
		 * 统一化当前集合页的初始化方式
		 */
		this(DEFAULT_CAPACITY);
	}
	/**
	 * 手工初始化集合的容量
	 * @param initCapacity 传入的容量大小：要求传入的容量大于0并且小于Integer.MAX_VALUE -8
	 */
	public MyArrayList(int initCapacity) {
		//判断 initCapacity是否符合要求
		if(initCapacity <0 || initCapacity > Integer.MAX_VALUE - 8) {
			throw new IllegalArgumentException("传递了一个不符合规范的初始容量！："+initCapacity);
//			elementData = new Object[DEFAULT_CAPACITY]; 错误的！ 
		}else {
			elementData = new Object[initCapacity];
		}
	}
	
	public boolean add(E e) {
		if(size == elementData.length) {//数组是否满了
			//满了就扩容！
			grow(size + 1);
		}
		elementData[size] = e;
		size++;
		return true;
	}
	/**
	 * 为底层数组elementData做扩容！
	 * @param minCapacity 扩容需要得最小容量！
	 */
	private void grow(int minCapacity) {
		int oldCapacity = elementData.length;
		int newCapacity = oldCapacity + (oldCapacity >> 1);//要扩容的大小
		
		if(newCapacity > Integer.MAX_VALUE-8) {
			throw new OutOfMemoryError("集合溢出了！");
		}
		if(newCapacity - minCapacity == 0) {
			
			newCapacity = minCapacity;
		}
		/*
		 * 1、创建新数组
		 * 2.拷贝元数据到新数组
		 * 3.返回新数组的首地址
		 * 4，替换
		 */
		elementData = Arrays.copyOf(elementData,newCapacity);
	}

	@Override
	public boolean add(int index, E e) {
		checkIndex(index);//1.先判断下标是否合理.不合理，抛异常，程序因异常而终止
		if(size == elementData.length) {
			grow(size + 1);
		}
		/*
		 * 1 3 10 5 7 9
		 * index = 2; num = 10
		 * 
		 */
		for(int i = size;i > index; i--) {
			elementData[i] = elementData[i-1];
		}
		elementData[index] = e;
		size++;
		return true;
	}
	/**
	 * 指定下标的安全检查！下标值不符合要求就抛异常
	 * @param index  下标
	 */
	private void checkIndex(int index) {
		if(index<0 ||index >=size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}
	@Override
	public E remove(Object o) {
		return null;
	}

	@Override
	public E remove(int index) {
		//1，获取对应下标的对象（get已对下标进行检查)
		E temp = this.get(index);
		//2，元素移动
		for(int i = index;i<size-1;i++) {
			elementData[i]= elementData[i+1];
		}
		elementData[size-1]=null;
		size--;
		return temp;
	}

	@Override
	public E set(int index, E e) {
		return null;
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public Object[] toArray() {
		return Arrays.copyOf(elementData, size);//复制数组元素到一个新数组
	}

	@Override
	public boolean isEmpty() {
		return false;
	}

	@Override
	public boolean contains(Object o) {
		return false;
	}

	@Override
	public MyList<E> subList(int start, int end) {
		return null;
	}

	@Override
	public int indexOf(Object o) {
		return 0;
	}

	@Override
	public int lastIndexOf(Object o) {
		return 0;
	}

	@Override
	public E get(int index) {
		checkIndex(index);//检查下标
		return (E)elementData[index];//返回指定下标的元素
	}

}

MyList

package com.qf.project.util;

/**
 * 增加：
 * add(E e);
 * add(int index,E e);
 * 删除：
 * remove(E e);
 * remove(int index);
 * 改：
 * set(int index,E e);
 * 获取：
 * int size();
 * Object[] toArray();
 * boolean isEmpty();
 * boolean contains(Object o);
 * MyArrayList<E> subList(int start,int end);
 * int indexOf(Object o);
 * int lastIndexOf(Object o);
 * E get(int index);
 * @author winter
 *
 * @param <E>  泛型 应用在不同类型下，作为集合
 */
public interface MyList<E> {
	/**
	 * 添加方法，添加元素到集合末尾
	 * @param e泛型
	 * @return true成功    false失败
	 */
	boolean add(E e);
	/**
	 * 添加方法，指定下标位置进行添加
	 * @param index 指定的下标位置
	 * @param e 元素 泛型
	 * @return true成功  false失败
	 */
	boolean add(int index,E e);
	/**
	 * 移除方法，指定移除的元素
	 * @param o 元素
	 * @return 移除的元素
	 */
	E remove(Object o);
	/**
	 * 移除方法，指定移除的下标
	 * @param index 指定的下标
	 * @return 移除的元素
	 */
	E remove(int index);
	/**
	 * 覆盖方法，替换指定下标的元素
	 * @param index 下标
	 * @param e 替换的元素
	 * @return 被替换的元素
	 */
	E set(int index,E e);
	/**
	 * 获取集合中有效元素的个数
	 * @return 有效元素的个数
	 */
	int size();
	/**
	 * 获得当前集合中，所有元素的Object类型的数组
	 * @return Object[] 包含集合中所有的对象
	 */
	Object[] toArray();
	/**
	 * 判断当前集合是否为空
	 * @return 如果一个元素都没有，返回true，有元素返回false
	 */
	boolean isEmpty();
	/**
	 * 判断某个对象o，在集合中是否存在
	 * @param o 需要查找的对象
	 * @return 存在返回true，不存在返回false
	 */
	boolean contains(Object o);
	/**
	 * 根据需求，返回start到end之间的MyList集合的子集合
	 * @param start 要求有效下标的范围，不能超过end
	 * @param end要求有效下标的范围，不能小于等于start
	 * @return 数据符合要求，返回一个当前集合的子集合。若数据不符合要求，返回NULL
	 */
	MyList<E> subList(int start,int end);
	/**
	 * 获得指定元素在集合中第一次出现的位置
	 * @param o 指定的元素
	 * @return 找到返回值 返回下标，没找到返回-1
	 */
	int indexOf(Object o);
	/**
	 * 获取指定元素在集合中最后一次出现的位置
	 * @param o指定的元素
	 * @return 找到返回值 返回下标，没找到返回-1
	 */
	int lastIndexOf(Object o);
	/**
	 * 根据指定的下标位置，获得元素
	 * @param index 下标
	 * @return 元素对象
	 */
	E get(int index);
	
	
	
	
	
	
	
}

MyComparator

package com.qf.project.util;

public interface MyComparator<E> {
	/**
	 * 自定义排序方法，方法的返回值是int类型
	 * @param stu1 
	 * @param stu2
	 * @return 返回值大于0，前者大于后者，小于0前者小于后者，等于0，两者相等
	 */
	public int compare(E stu1,E stu2);
}

MyFilter

package com.qf.project.util;

public interface MyFileter<E> {
	public boolean accept(E e);
}

Student

package com.qf.project.entity;

public class Student {
	 private int id;
	 private String name;
	 private String className;
	 private int age;
	 private String gender;
	 private double javaScore;
	 private double htmlScore;
	 private double springScore;
	 private double totalScore;
	 private static int count = 0;
	 
	 
	 //无参
	 public Student() {}
	 
	 /**
	  * 提供基本信息的构造方法
	  * @param id
	  * @param name
	  * @param className
	  * @param age
	  * @param gender
	  */
	
	 public Student( String name, String className, int age, String gender) {
		super();
		count++;//学生ID不手动输入，自动增长
		this.id = count;
		this.name = name;
		this.className = className;
		this.age = age;
		this.gender = gender;
		
	}
	 
	 /**
	  * 提供成绩的构造方法
	  * @param id
	  * @param name
	  * @param className
	  * @param age
	  * @param gender
	  * @param javaScore
	  * @param htmlScore
	  * @param springScore
	  *
	  */
	public Student(String name, String className, int age, String gender, double javaScore, double htmlScore,
			double springScore) {
		this( name, className, age, gender);
		this.javaScore = javaScore;
		this.htmlScore = htmlScore;
		this.springScore = springScore;
		this.totalScore = javaScore+htmlScore+springScore;
	}

	public int getId() {
		return id;
	}

	public String getName() {
		return name;
	}

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

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

	public int getAge() {
		return age;
	}

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

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public double getJavaScore() {
		return javaScore;
	}

	public void setJavaScore(double javaScore) {
		this.totalScore -= this.javaScore;//先把原来的成绩剪掉
		this.javaScore = javaScore;//赋值
		this.totalScore += this.javaScore;//加上新成绩
	}

	public double getHtmlScore() {
		return htmlScore;
	}

	public void setHtmlScore(double htmlScore) {
		this.totalScore -= this.htmlScore;//先把原来的成绩剪掉
		this.htmlScore = htmlScore;//赋值
		this.totalScore += this.htmlScore;//加上新成绩
	}

	public double getSpringScore() {
		return springScore;
	}

	public void setSpringScore(double springScore) {
		this.totalScore -= this.springScore;//先把原来的成绩剪掉
		this.springScore = springScore;//赋值
		this.totalScore += this.springScore;//加上新成绩
	}
	
	//总分只能看不能改
	public double getTotalScore() {
		return totalScore;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", className=" + className + ", age=" + age + ", gender="
				+ gender + ", javaScore=" + javaScore + ", htmlScore=" + htmlScore + ", springScore=" + springScore
				+ ", totalScore=" + totalScore + "]";
	}
	
	

}