/**
目前创新互联公司已为数千家的企业提供了网站建设、域名、网站空间、网站运营、企业网站设计、钦南网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。
* 我写了一个 希望 有用
*
* 如果 哪位高手 有兴趣
* 帮忙 实现 一下 Teacher 类中的 private void checkClassRepeat() 方法 感谢！！
*/
==================================第一个类 TypeValue
package org.wood.teacher;
/**
* 创建 各种系数常量
* @author Administrator
*
*/
public interface TypeValue {
/**
* 理论课系数 1.2
*/
double COURSE_TYPE_THEORY_VALUE = 1.2;
/**
* 实训课系数 0.8
*/
double COURSE_TYPE_PRACTISE_VALUE = 0.8;
/**
* 班级系数
*/
/**
* 小于40人 系数1
*/
double CLASS_TYPE_STUDENT_NUMBER_UNDER_40_VALUE = 1.0;
/**
* 大于等于40人且小于80人 系数1.1
*/
double CLASS_TYPE_STUDENT_NUMBER_BETWEEN_40_AND_80_VALUE = 1.1;
/**
* 大于等于80人且小于100人 系数1.2
*/
double CLASS_TYPE_STUDENT_NUMBER_BETWEEN_80_AND_100_VALUE = 1.2;
/**
* 大于等于100人 系数1.3
*/
double CLASS_TYPE_STUDENT_NUMBER_ABOVE_100_VALUE = 1.3;
/**
* 职称系数
*/
/**
* 助教 系数1
*/
double LEVEL_TYPE_ASISITANT_VALUE = 1.0;
/**
* 讲师 系数1.2
*/
double LEVEL_TYPE_DOCENT_VALUE = 1.2;
/**
* 副教授 系数1.5
*/
double LEVEL_TYPE_ASSOCIATE_PROFESSOR_VALUE = 1.5;
/**
* 正教授 系数2
*/
double LEVEL_TYPE_PROFESSOR_VALUE = 2.0;
/**
* 理论课重复系数
*/
/**
* 重复课系数
*/
double REPEAT_COURSE_VALUE = 0.8;
/**
* 非重复课 系数
*/
double UNREPEAT_COURSE_VALUE = 1;
}
==================================第二个类 Class类
package org.wood.teacher;
/**
* 班级类 包含
* 班级号 classId
* 班级课程类别(courseName)：如java，c++，.net或其他
* 班级人数(studentNumber)
* 班级理论课时间(theoryTime)
* 班级实训（实践）课时间(practiseTime)
* 班级是不是重复的 repeat(如果是重复的，计算该班级的工作量时，使用的系数与重复的不一样)
* repeat属性，比较特殊，需要在统计该班的工作量之前，确定该班是否是重复了。
* repeat=true; 重复的
* repeat=false; 班级非重复的
*
* 核心方法 calculateClassWorkload
* 该方法 用来计算 带此班的老师的工作量，有一个参数，就是老师的职称系数。
*
* 如：30(理论课天数)*1.2（理论课系数）*1.1（60人,学生人数系数）*1.2（职称系数）*1(非重复系数，人多的班级) + 10(实践天数)*0.8（实践课系数）*1.1（60人，学生人数系数）*1.2（职称系数）
*
* 30(理论课天数)*1.2（理论课系数）*1.1（60人,学生人数系数）*1.2（职称系数）*0.8(重复系数，人少的班级) + 10(实践天数)*0.8（实践课系数）*1.1（60人，学生人数系数）*1.2（职称系数）
* @author Administrator
*
*/
public class Class {
private int classId;
// 班级课程类别
private String courseName;
// 班级人数
private int studentNumber;
// 班级理论课时间
private int theoryTime;
// 班级实训（实践）课时间
private int practiseTime;
private boolean repeat;
public Class() {
super();
}
public Class(int classId, String courseName, int studentNumber,
int theoryTime, int practiseTime) {
super();
this.classId = classId;
this.courseName = courseName;
this.studentNumber = studentNumber;
this.theoryTime = theoryTime;
this.practiseTime = practiseTime;
}
/**
* 计算班级工作量 参数 为 老师的 职称系数
*
* @param teacherLevlValue(参数为 该老师的 职称的系数）
* @return
*/
public double calculateClassWorkload(double teacherLevelValue) {
/**
* 判断是否是重复的课程
*/
if (this.repeat) {
System.out.println(this.courseName+" "+this.classId+"班，重复了！");
System.out.println(
this.theoryTime+" * "
+ TypeValue.COURSE_TYPE_THEORY_VALUE+" * "
+getClassTypeStudentNumberValue()+" * "
+teacherLevelValue+" * "
+TypeValue.REPEAT_COURSE_VALUE +"(重复系数) + "
+this.practiseTime+" * "
+ TypeValue.COURSE_TYPE_PRACTISE_VALUE+" * "
+getClassTypeStudentNumberValue()+" * "
+teacherLevelValue);
/**
* 重复的班级 工作量算法
* 30(理论课天数)*1.2（理论课系数）*1.1（60人,学生人数系数）*1.2（职称系数）*0.8(重复系数，人少的班级) + 10(实践天数)*0.8（实践课系数）*1.1（60人，学生人数系数）*1.2（职称系数）
*/
return this.theoryTime
* TypeValue.COURSE_TYPE_THEORY_VALUE
* getClassTypeStudentNumberValue()
* teacherLevelValue
* TypeValue.REPEAT_COURSE_VALUE
+ this.practiseTime
* TypeValue.COURSE_TYPE_PRACTISE_VALUE
* getClassTypeStudentNumberValue()
* teacherLevelValue;
} else {
// System.out.println(this.classId+"班，非重复！");
System.out.println(
this.theoryTime+" * "
+ TypeValue.COURSE_TYPE_THEORY_VALUE+" * "
+getClassTypeStudentNumberValue()+" * "
+teacherLevelValue+" * "
+TypeValue.UNREPEAT_COURSE_VALUE +"(非重复系数) + "
+this.practiseTime+" * "
+ TypeValue.COURSE_TYPE_PRACTISE_VALUE+" * "
+getClassTypeStudentNumberValue()+" * "
+teacherLevelValue);
/**
* 非重复的班级的 工作量的算法
* 30(理论课天数)*1.2（理论课系数）*1.1（60人,学生人数系数）*1.2（职称系数）*1(非重复系数，人多的班级) + 10(实践天数)*0.8（实践课系数）*1.1（60人，学生人数系数）*1.2（职称系数）
*/
return this.theoryTime
* TypeValue.COURSE_TYPE_THEORY_VALUE
* getClassTypeStudentNumberValue()
* teacherLevelValue
* TypeValue.UNREPEAT_COURSE_VALUE
+ this.practiseTime
* TypeValue.COURSE_TYPE_PRACTISE_VALUE
* getClassTypeStudentNumberValue()
* teacherLevelValue;
}
}
/**
* 获取班级 人数系数
*
* @return
*/
private double getClassTypeStudentNumberValue() {
if (this.studentNumber 0 this.studentNumber 40) {
return TypeValue.CLASS_TYPE_STUDENT_NUMBER_UNDER_40_VALUE;
} else if (this.studentNumber = 40 this.studentNumber 80) {
return TypeValue.CLASS_TYPE_STUDENT_NUMBER_BETWEEN_40_AND_80_VALUE;
} else if (this.studentNumber = 80 this.studentNumber 100) {
return TypeValue.CLASS_TYPE_STUDENT_NUMBER_BETWEEN_80_AND_100_VALUE;
} else if (this.studentNumber = 100) {
return TypeValue.CLASS_TYPE_STUDENT_NUMBER_ABOVE_100_VALUE;
}
return -1;
}
public int getClassId() {
return classId;
}
public void setClassId(int classId) {
this.classId = classId;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
public int getStudentNumber() {
return studentNumber;
}
public void setStudentNumber(int studentNumber) {
this.studentNumber = studentNumber;
}
public int getTheoryTime() {
return theoryTime;
}
public void setTheoryTime(int theoryTime) {
this.theoryTime = theoryTime;
}
public int getPractiseTime() {
return practiseTime;
}
public void setPractiseTime(int practiseTime) {
this.practiseTime = practiseTime;
}
public boolean isRepeat() {
return repeat;
}
public void setRepeat(boolean repeat) {
this.repeat = repeat;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((courseName == null) ? 0 : courseName.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;
final Class other = (Class) obj;
if (courseName == null) {
if (other.courseName != null)
return false;
} else if (!courseName.equals(other.courseName))
return false;
return true;
}
}
==================================第三个类 Teacher类
package org.wood.teacher;
import java.util.ArrayList;
import java.util.List;
/**
* 教师类 包含教室的 姓名，职称（级别）信息
*
* 核心方法 计算该教师的工作量(多个班级的工作量的和) calculateWorkload();
*
* @author Administrator
*
*/
public class Teacher {
/**
* 姓名
*/
private String name;
/**
* 职称/级别 助教、讲师、副教授、正教授
*/
private String level;
/**
* 老师 所带领的班级的集合
*
*/
private ListClass classes = new ArrayListClass();
public Teacher() {
super();
}
public Teacher(String name, String level) {
super();
this.name = name;
this.level = level;
}
/**
* addClass(Class clas) 添加 老师带的班级 到 老师带班集合
*
* @param clas
*/
public void addClass(Class clas) {
this.classes.add(clas);
}
/**
* 计算教师的工作量(workload)
*
* @return
*/
public double calculateWorkload() {
/**
* 获取教师的级别系数
*/
double levlValue = getTeacherLevlValue();
System.out.println("职称系数："+levlValue);
/**
* 检测 教师 所带领的 班级
* 如果 有班级是 重复的，将人数最少的班级 的重复属性 赋值为 true
*/
checkClassRepeat();
/**
* 计算 工作量
* 结合 教师的 职称
*/
double sum=getSum(levlValue);
return sum;
}
private double getSum(double levlValue) {
double sum=0.0;
for(Class c:this.classes){
sum+=c.calculateClassWorkload(levlValue);
System.out.println("SUM:----"+sum);
}
return sum;
}
/**
* 检测 教师 所带领的 班级
* 如果 有班级是 重复的，将人数最少的班级 的重复属性 赋值为 true
*/
private void checkClassRepeat() {
/**
* 此方法 没有实现，请高手 实现
*
* 我的想法是遍历 ListClass classes 集合，比较集合中的对象，
* 如果有对象是相同的（我重写了Class的equals()方法，只要课程名相同，就表示两个班相同）
* 则将 班级人数少的班级的重复 属性 赋值为true(默认为false)----计算班级的工作量是用到 该属性 做判断
*
* 我遇到的问题是，如果一个老师 带的重复的班级 有3个或三个以上(如:3个java班)，我的逻辑就有点乱了，没理过来
* 请高手帮忙!!
*
* 现在只能 手动地设置 某个班级 为重复的，从而进行计算
*/
}
/**
* 获取教师的 职称系数方法
* 通过 教师的 职称 确定的 教师的 职称系数
* @return
*/
private double getTeacherLevlValue() {
// 助教、讲师、副教授、正教授
if ("助教".equals(this.level)) {
return TypeValue.LEVEL_TYPE_ASISITANT_VALUE;
} else if ("讲师".equals(this.level)) {
return TypeValue.LEVEL_TYPE_DOCENT_VALUE;
} else if ("副教授".equals(this.level)) {
return TypeValue.LEVEL_TYPE_ASSOCIATE_PROFESSOR_VALUE;
} else if ("正教授".equals(this.level)) {
return TypeValue.LEVEL_TYPE_PROFESSOR_VALUE;
}
return -1;
}
/**
* 计算教师的收入
*
* @param perWorkloadPrice(单价)
* @return
*/
public double calculateIncome(double perWorkloadPrice) {
return calculateWorkload()*perWorkloadPrice;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
public ListClass getClasses() {
return classes;
}
public void setClasses(ListClass classes) {
this.classes = classes;
}
}
==================================第四个类 测试类 TestCal类
package org.wood.teacher;
public class TestCal {
public static void main(String[] args) {
/**
* 职称/级别 助教、讲师、副教授、正教授
*/
Teacher teacher=new Teacher("张三","讲师");
/**
* 构建 班级1 对象
* 班级2 java课 60人 30天理论 10天实践
*/
Class class01=new Class(1,"java",35,30,10);
class01.setRepeat(true);
/**
* 构建 班级2 对象
* 班级2 java课 60人 30天理论 10天实践
*/
Class class02=new Class(2,"java",60,30,10);
class02.setRepeat(false);
/**
* 将1,2班 添加到教室 带班列表
*/
teacher.addClass(class01);
teacher.addClass(class02);
/**
* 计算工作量
*/
double result=teacher.calculateWorkload();
System.out.println("R:"+result);
/**
* 单个班级 java02 班 测试数据
* 30(理论课天数)*1.2（理论课系数）*1.1（60人,学生人数系数）*1.2（职称系数）*1(非重复系数，人多的班级) + 10(实践天数)*0.8（实践课系数）*1.1（60人，学生人数系数）*1.2（职称系数）
* 理论数据： 30 * 1.2 * 1.1 * 1.2 * 1 + 10 * 0.8 * 1.1 * 1.2 =58.08
* 程序数据： 30 * 1.2 * 1.1 * 1.2 * 1.0 + 10 * 0.8 * 1.1 * 1.2 =58.080000000000005(double类型数据不精确存储)
*/
/**
* 两个班级 java01 java02 班 共同 测试数据
* java 1班，重复了！
* 30 * 1.2 * 1.0 * 1.2 * 0.8(重复系数) + 10 * 0.8 * 1.0 * 1.2
*
* java 2班
* 30 * 1.2 * 1.1 * 1.2 * 1.0(非重复系数) + 10 * 0.8 * 1.1 * 1.2
*
* 程序数据结果：R:102.24000000000001
*
*/
}
}
/**
*
*实现了Teacher 类中的 private void checkClassRepeat() 方法 就可以
*自动判断 哪一个 班级是重复的
* 但是 现在 我未能实现此方法
* 只能 像测试类中的 那样， 手动地 设置 该班级 是否是重复班级
*/
package com.demo;
public class Teacher {
private static double xishu=1.2;//课时数量，定义成static类型保证有教师的课时系数都相同
private double classNo=0.0;//课时数量
public Teacher(){
}
public Teacher(double classNo){//构造函数
this.classNo=classNo;
}
public double courseCompute( ){
return xishu*classNo;
}
public static void main(String[] string){
Teacher teacherOne=new Teacher(4);//申明一个四节课时的教师
Teacher teacherTwo=new Teacher(5);//申明一个四节课时的教师
System.out.println(teacherOne.courseCompute());//输出结果
System.out.println(teacherTwo.courseCompute());
teacherOne.xishu=1;//修改系数
System.out.println(teacherOne.courseCompute());//重新输出结果
System.out.println(teacherTwo.courseCompute());
}
}
运行结果：
可以借助Baidu Hi示意我
有时间可能完成你所面临的任务
差不多的要求也可能示意我
ES:\\598A7C00A52ED03AB45A0FB7B9C4DAB0
交易提醒:预付定金是诈骗
