「java工作量」java程序员一天工作量
本篇文章给大家谈谈java工作量，以及java程序员一天工作量对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
做java工程师或java程序员怎么样？工作量大不大？累不累？
有的工作很累，有的很闲，找工作也看人品，不过总的说来，搞开发的累的比例比较大。
北大青鸟java培训：几种测试工作量的估算方法？
在测试项目管理中或编写测试计划时，经常需要对某个测试工作进行工作量的预算，很多时候都是凭个人的工作经验进行估算的，如能结合一些常规的估算方法，有助于估算的精确度。
河北IT培训建议是网上找到的一些常规的估算测试工作量的方法：1、Ad-hoc方法这种方法下的测试工作量不基于任何确定的期限。
工作一直继续直到达到一些由管理或市场人员预先定下的时间表。
或者，一直到用完了预算的经费。
这种情况普遍存在于非常不成熟的组织，并且时常有100%的错误差数。
2、开发时间的百分比法Percentageofdevelopmenttime。
这个方法的基本前提是测试工作量依赖于开发时间/开发工作量。
首先，开发工作量使用例如LOC或FP方法被估算出来，然后使用一些探索性的方法来限制测试的工作量。
这种方法变化比较大而且通常基于以前的经验。
通常预留项目的总花费时间的35%给测试。
?5-7%给组件和集成测试?18-20%给系统测试?10%给接收测试(或回归测试等)3、类比法(经验值法或历史数据法)根据以前或相似项目(主要在项目性质，领域，规模上有相似)所积累的经验或历史数据来估算工作量。
类比法估计结果的精确度取决于历史项目数据的完整性和准确度，因此，用好类比法的前提条件之一是组织建立起较好的项目后评价与分析机制，对历史项目的数据分析是可信赖的。
需要收集以下相关的历史数据：?在设计和实现阶段花费的时间?测试工作的规模，例如用户需求的数量，页面数，功能点?数据样式，例如实体，字段的数量?屏幕或字段数量?测试对象的规模，例如KLOC4、WBS(workbreakdownstructure)估算法将项目或产品分解为具体的工作，然后分别对各个工作进行时间估算，最终求和得出项目或产品的测试工作量/时间。
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() 方法 就可以
*自动判断 哪一个 班级是重复的
* 但是 现在 我未能实现此方法
* 只能 像测试类中的 那样， 手动地 设置 该班级 是否是重复班级
*/
关于java工作量和java程序员一天工作量的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2022-11-26，除非注明，否则均为原创文章，转载请注明出处。