java教师工作量代码,java老师工资

java教师工作量计算法

/**

目前创新互联公司已为数千家的企业提供了网站建设、域名、网站空间、网站运营、企业网站设计、钦南网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。

* 我写了一个 希望 有用

*

* 如果 哪位高手 有兴趣

* 帮忙 实现 一下 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() 方法 就可以

*自动判断 哪一个 班级是重复的

* 但是 现在 我未能实现此方法

* 只能 像测试类中的 那样， 手动地 设置 该班级 是否是重复班级

*/

1、java中编写一个类Teacher，描述教师的课时数量和计算课时的系数，均为double类型。

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());

}

}

运行结果：

谁帮做个Java的设计，基于access的教师工作量系统，有酬谢！（Q谈）急啊！

可以借助Baidu Hi示意我

有时间可能完成你所面临的任务

差不多的要求也可能示意我

ES:\\598A7C00A52ED03AB45A0FB7B9C4DAB0

交易提醒:预付定金是诈骗