UML构造函数到Java的转换
在面向对象设计中，uml类图是系统结构的可视化表示。虽然uml规范中构造函数通常用«create»构造型标记，并返回类实例（例如 + «create» student(name:string):student），但在实际开发中，许多主流oop语言（如java）遵循将构造函数命名与类名相同且无显式返回类型的约定。因此，当uml图中出现 student(name:string) 这样的操作时，通常应将其理解为该类的构造函数。
在Java中，根据UML图中Student(name:String)的定义，其对应的构造函数实现如下：
public class Student {
private String name;
private int[] homeworkScores; // 存储作业分数
private int[] examScores; // 存储考试分数
// 其他属性，如平均分、最终成绩等，通常通过方法计算而非直接存储
// private double homeworkAverage;
// private int finalScore;
/**
* 构造函数，用于初始化学生对象。
* @param name 学生的姓名。
*/
public Student(String name) {
this.name = name;
// 在构造函数中初始化数组，分配默认大小
// 根据需求，学生有6个作业分数和3个考试分数
this.homeworkScores = new int[6];
this.examScores = new int[3];
// 数组元素默认初始化为0
}
// ... 其他方法
}数组属性的初始化与管理
在构造函数中初始化数组属性是创建对象时的关键一步。对于固定大小的数组，可以直接使用new int[size]语法分配内存。例如，为homeworkScores分配6个整数空间，为examScores分配3个整数空间。
public class Student {
private String name;
private int[] homeworkScores; // 6个作业分数
private int[] examScores; // 3个考试分数
public Student(String name) {
this.name = name;
this.homeworkScores = new int[6]; // 初始化为6个元素的数组，默认值为0
this.examScores = new int[3]; // 初始化为3个元素的数组，默认值为0
}
// ... getters and setters
}计算方法的实现
根据UML图和问题描述，Student类应包含计算作业平均分和最终成绩的方法。
1. 计算作业平均分 (getHomeworkAverage)
该方法需要遍历homeworkScores数组，累加所有分数并除以作业数量。
立即学习“Java免费学习笔记（深入）”；
public class Student {
// ... 属性和构造函数
/**
* 计算并返回学生的作业平均分。
* @return 作业平均分。如果无作业，返回0.0。
*/
public double getHomeworkAverage() {
if (homeworkScores == null || homeworkScores.length == 0) {
return 0.0;
}
int sum = 0;
for (int score : homeworkScores) {
sum += score;
}
return (double) sum / homeworkScores.length;
}
// ... 其他方法
}2. 计算最终成绩 (getFinalScore)
最终成绩的计算涉及不同部分的加权平均：15% 考试1，25% 考试2，30% 考试3，30% 作业平均分。
public class Student {
// ... 属性和构造函数
// ... getHomeworkAverage() 方法
/**
* 计算并返回学生的最终成绩。
* 权重：考试1 (15%), 考试2 (25%), 考试3 (30%), 作业平均分 (30%)。
* @return 最终成绩（百分制）。
*/
public int getFinalScore() {
if (examScores == null || examScores.length < 3) {
// 确保有足够的考试分数进行计算
return 0; // 或者抛出异常
}
double exam1Weight = 0.15;
double exam2Weight = 0.25;
double exam3Weight = 0.30;
double homeworkWeight = 0.30;
double exam1Score = examScores[0];
double exam2Score = examScores[1];
double exam3Score = examScores[2];
double homeworkAvg = getHomeworkAverage();
double finalScore = (exam1Score * exam1Weight) +
(exam2Score * exam2Weight) +
(exam3Score * exam3Weight) +
(homeworkAvg * homeworkWeight);
return (int) Math.round(finalScore); // 返回四舍五入的整数成绩
}
// ... 其他方法
}封装性与数组处理的最佳实践
直接从getter方法返回数组引用或在setter方法中直接接收数组引用，会破坏对象的封装性，并可能导致外部代码在不知情的情况下修改对象内部状态。这被称为“泄露”内部表示。
潜在风险：
-
Getter泄露： getHomeworkScores() 返回 homeworkScores 的引用后，外部代码可以直接修改数组内容，而无需通过 Student 类的控制。
Student student = new Student("Alice"); int[] homeworks = student.getHomeworkScores(); homeworks[0] = 100; // 直接修改了student对象内部的homeworkScores -
Setter泄露： setHomeworkScores(int[] newScores) 直接将传入的数组引用赋给 this.homeworkScores。如果外部代码在设置后修改了 newScores 数组，Student 对象的内部状态也会随之改变。
Student student = new Student("Alice"); int[] externalScores = {90, 85, 95, 80, 75, 70}; student.setHomeworkScores(externalScores); externalScores[0] = 50; // student对象内部的homeworkScores[0]也变成了50
解决方案：防御性复制 (Defensive Copying)
为了维护封装性，应该在getter和setter方法中进行数组的防御性复制。
- Getter： 返回数组的副本，而不是原始引用。
- Setter： 接收数组时，创建一个副本并存储，而不是直接存储传入的引用。
import java.util.Arrays; // 用于数组复制
public class Student {
private String name;
private int[] homeworkScores;
private int[] examScores;
public Student(String name) {
this.name = name;
this.homeworkScores = new int[6];
this.examScores = new int[3];
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 获取作业分数数组的副本，防止外部修改内部状态。
* @return 作业分数数组的副本。
*/
public int[] getHomeworkScores() {
return Arrays.copyOf(homeworkScores, homeworkScores.length);
}
/**
* 设置作业分数。传入的数组会被复制，防止外部修改内部状态。
* @param homeworkScores 新的作业分数数组。
*/
public void setHomeworkScores(int[] homeworkScores) {
if (homeworkScores == null || homeworkScores.length != this.homeworkScores.length) {
throw new IllegalArgumentException("Homework scores array must not be null and must have " + this.homeworkScores.length + " elements.");
}
// 防御性复制
System.arraycopy(homeworkScores, 0, this.homeworkScores, 0, homeworkScores.length);
// 或者使用 this.homeworkScores = Arrays.copyOf(homeworkScores, homeworkScores.length);
// 但如果希望保持原有数组引用，则使用System.arraycopy
}
/**
* 获取考试分数数组的副本，防止外部修改内部状态。
* @return 考试分数数组的副本。
*/
public int[] getExamScores() {
return Arrays.copyOf(examScores, examScores.length);
}
/**
* 设置考试分数。传入的数组会被复制，防止外部修改内部状态。
* @param examScores 新的考试分数数组。
*/
public void setExamScores(int[] examScores) {
if (examScores == null || examScores.length != this.examScores.length) {
throw new IllegalArgumentException("Exam scores array must not be null and must have " + this.examScores.length + " elements.");
}
// 防御性复制
System.arraycopy(examScores, 0, this.examScores, 0, examScores.length);
}
// ... getHomeworkAverage() 和 getFinalScore() 方法
}注意： 在setHomeworkScores和setExamScores中，如果只是简单地this.homeworkScores = Arrays.copyOf(homeworkScores, homeworkScores.length);，这会创建一个新数组并替换掉旧的引用。如果希望保持原有数组引用（例如，其他部分的代码可能依赖于这个引用），则应使用System.arraycopy将新数据复制到现有数组中。这里选择System.arraycopy以展示另一种防御性复制方法，并强调可以保持数组引用不变。同时，增加了对输入数组null和长度的校验，以提高健壮性。
总结
将UML类图转换为Java对象时，理解构造函数的约定至关重要。正确初始化数组属性是构建完整对象的基础，而实现计算逻辑则赋予对象行为能力。最重要的是，在处理数组这类可变对象时，务必采用防御性复制策略来维护类的封装性，避免因外部代码意外修改内部状态而导致程序行为不可预测。遵循这些最佳实践，将有助于开发出更健壮、更易于维护的Java应用程序。
