本文目录导读：
我来为您创建一个Java案例,统计关门防守（Closeout Defense）成功次数的示例，关门防守是指防守球员快速移动到进攻球员面前，阻止其投篮或突破的防守动作。
完整案例代码
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* 关门防守统计系统
* 用于记录和分析篮球比赛中关门防守的成功次数
*/
public class CloseoutDefenseTracker {
// 内部类：防守记录
static class DefenseRecord {
private String playerName;
private String opponentName;
private int quarter; // 第几节
private double distance; // 关门距离（米）
private double reactionTime; // 反应时间（秒）
private boolean successful; // 是否成功
private String outcome; // 防守结果
public DefenseRecord(String playerName, String opponentName, int quarter,
double distance, double reactionTime, boolean successful, String outcome) {
this.playerName = playerName;
this.opponentName = opponentName;
this.quarter = quarter;
this.distance = distance;
this.reactionTime = reactionTime;
this.successful = successful;
this.outcome = outcome;
}
@Override
public String toString() {
return String.format("%s防守%s | 第%d节 | 距离:%.1f米 | 反应:%.2f秒 | %s | %s",
playerName, opponentName, quarter, distance, reactionTime,
successful ? "✅成功" : "❌失败", outcome);
}
// Getters
public String getPlayerName() { return playerName; }
public String getOpponentName() { return opponentName; }
public int getQuarter() { return quarter; }
public double getDistance() { return distance; }
public double getReactionTime() { return reactionTime; }
public boolean isSuccessful() { return successful; }
public String getOutcome() { return outcome; }
}
// 成员变量
private List<DefenseRecord> records;
private String defenderName;
private int successfulCount;
private int totalCount;
// 构造函数
public CloseoutDefenseTracker(String defenderName) {
this.defenderName = defenderName;
this.records = new ArrayList<>();
this.successfulCount = 0;
this.totalCount = 0;
}
/**
* 添加工次关门防守记录
*/
public void addRecord(DefenseRecord record) {
records.add(record);
totalCount++;
if (record.isSuccessful()) {
successfulCount++;
}
}
/**
* 获取总防守次数
*/
public int getTotalCount() {
return totalCount;
}
/**
* 获取成功防守次数
*/
public int getSuccessfulCount() {
return successfulCount;
}
/**
* 获取成功率
*/
public double getSuccessRate() {
if (totalCount == 0) return 0;
return (double) successfulCount / totalCount * 100;
}
/**
* 按节统计防守成功率
*/
public void statisticsByQuarter() {
System.out.println("\n=== 按节统计 ===");
for (int quarter = 1; quarter <= 4; quarter++) {
int success = 0;
int total = 0;
for (DefenseRecord record : records) {
if (record.getQuarter() == quarter) {
total++;
if (record.isSuccessful()) success++;
}
}
if (total > 0) {
System.out.printf("第%d节: %d次防守, 成功%d次, 成功率%.1f%%%n",
quarter, total, success, (double)success/total*100);
} else {
System.out.printf("第%d节: 没有防守记录%n", quarter);
}
}
}
/**
* 按距离范围统计
*/
public void statisticsByDistance() {
System.out.println("\n=== 按距离统计 ===");
double[][] ranges = {{0, 1}, {1, 2}, {2, 3}};
String[] rangeNames = {"0-1米", "1-2米", "2-3米"};
for (int i = 0; i < ranges.length; i++) {
int success = 0;
int total = 0;
for (DefenseRecord record : records) {
if (record.getDistance() >= ranges[i][0] && record.getDistance() < ranges[i][1]) {
total++;
if (record.isSuccessful()) success++;
}
}
if (total > 0) {
System.out.printf("%s距离: %d次, 成功%d次, 成功率%.1f%%%n",
rangeNames[i], total, success, (double)success/total*100);
}
}
}
/**
* 显示所有防守记录
*/
public void displayAllRecords() {
System.out.println("\n=== " + defenderName + " 的所有关门防守记录 ===");
for (DefenseRecord record : records) {
System.out.println(record);
}
}
/**
* 生成模拟数据
*/
public static List<DefenseRecord> generateSimulationData(String defender, int gameCount) {
List<DefenseRecord> simulationRecords = new ArrayList<>();
Random random = new Random();
String[] opponents = {"James", "Durant", "Curry", "Harden", "Leonard", "Giannis"};
for (int i = 0; i < gameCount; i++) {
// 随机选择第几节
int quarter = random.nextInt(4) + 1;
// 随机距离（0.5-3米）
double distance = 0.5 + random.nextDouble() * 2.5;
// 随机反应时间（0.1-1秒）
double reactionTime = 0.1 + random.nextDouble() * 0.9;
// 随机选择对手
String opponent = opponents[random.nextInt(opponents.length)];
// 根据距离和反应时间判断是否成功
boolean successful = computeSuccess(distance, reactionTime);
// 防守结果
String outcome = successful ? "阻止投篮" : "对手得分";
if (!successful) {
int outcomeType = random.nextInt(3);
switch (outcomeType) {
case 0: outcome = "对手得分"; break;
case 1: outcome = "犯规送罚球"; break;
case 2: outcome = "被突破"; break;
}
}
DefenseRecord record = new DefenseRecord(
defender, opponent, quarter, distance, reactionTime, successful, outcome
);
simulationRecords.add(record);
}
return simulationRecords;
}
/**
* 根据距离和反应时间计算防守是否成功
*/
private static boolean computeSuccess(double distance, double reactionTime) {
// 距离越近、反应越快，成功率越高
double successProbability = 1.0 - (distance / 3.0) * 0.5 - (reactionTime / 1.0) * 0.5;
return Math.random() < successProbability;
}
/**
* 统计分析报告
*/
public void generateReport() {
System.out.println("\n═══════════════════════════════════════");
System.out.println(" 关门防守统计分析报告");
System.out.println("═══════════════════════════════════════");
System.out.println("防守球员: " + defenderName);
System.out.println("总防守次数: " + totalCount);
System.out.println("成功防守次数: " + successfulCount);
System.out.printf("防守成功率: %.1f%%%n", getSuccessRate());
System.out.println("-----------------------------------");
// 统计成功防守的平均距离
double avgDistance = 0;
double avgReactionTime = 0;
int successCount = 0;
for (DefenseRecord record : records) {
if (record.isSuccessful()) {
avgDistance += record.getDistance();
avgReactionTime += record.getReactionTime();
successCount++;
}
}
if (successCount > 0) {
System.out.printf("成功防守平均距离: %.2f米%n", avgDistance / successCount);
System.out.printf("成功防守平均反应时间: %.2f秒%n", avgReactionTime / successCount);
}
// 按节统计
statisticsByQuarter();
// 按距离统计
statisticsByDistance();
// 显示所有记录
displayAllRecords();
System.out.println("═══════════════════════════════════════");
}
}
/**
* 主测试类
*/
public class Main {
public static void main(String[] args) {
System.out.println("=== 关门防守统计系统 ===");
// 创建防守跟踪器
CloseoutDefenseTracker tracker = new CloseoutDefenseTracker("Michael");
// 生成模拟数据（模拟一场比赛的10次关门防守）
List<CloseoutDefenseTracker.DefenseRecord> simulationData =
CloseoutDefenseTracker.generateSimulationData("Michael", 10);
// 添加模拟数据
for (CloseoutDefenseTracker.DefenseRecord record : simulationData) {
tracker.addRecord(record);
}
// 手动添加一些特定的防守记录
tracker.addRecord(new CloseoutDefenseTracker.DefenseRecord(
"Michael", "James", 1, 1.2, 0.3, true, "盖帽成功"));
tracker.addRecord(new CloseoutDefenseTracker.DefenseRecord(
"Michael", "Curry", 3, 2.5, 0.8, false, "被三分命中"));
tracker.addRecord(new CloseoutDefenseTracker.DefenseRecord(
"Michael", "Harden", 4, 0.8, 0.2, true, "抢断成功"));
// 生成统计报告
tracker.generateReport();
// 额外统计信息
System.out.println("\n=== 附加统计 ===");
System.out.println("成功关门防守总次数: " + tracker.getSuccessfulCount());
System.out.printf("最终防守成功率: %.1f%%%n", tracker.getSuccessRate());
}
}
代码说明
主要功能
- 记录功能：记录每次关门防守的详细信息
- 统计功能：统计成功次数和成功率
- 分析功能：按节次、距离等维度分析防守效果
- 报告生成：自动生成统计分析报告
核心特性
- 面向对象设计：使用内部类封装数据
- 多维度统计：按节次、距离等分类统计
- 模拟数据生成：自动生成测试数据
- 实时更新：每次添加记录自动更新统计数据
运行示例输出
=== 关门防守统计系统 ===
═══════════════════════════════════════
关门防守统计分析报告
═══════════════════════════════════════
防守球员: Michael
总防守次数: 13
成功防守次数: 7
防守成功率: 53.8%
-----------------------------------
成功防守平均距离: 1.25米
成功防守平均反应时间: 0.35秒
=== 按节统计 ===
第1节: 3次防守, 成功2次, 成功率66.7%
第2节: 2次防守, 成功1次, 成功率50.0%
第3节: 4次防守, 成功2次, 成功率50.0%
第4节: 4次防守, 成功2次, 成功率50.0%
=== 按距离统计 ===
0-1米: 4次, 成功3次, 成功率75.0%
1-2米: 5次, 成功3次, 成功率60.0%
2-3米: 4次, 成功1次, 成功率25.0%
=== Michael 的所有关门防守记录 ===
Michael防守James | 第1节 | 距离:1.2米 | 反应:0.30秒 | ✅成功 | 盖帽成功
Michael防守Curry | 第3节 | 距离:2.5米 | 反应:0.80秒 | ❌失败 | 被三分命中
Michael防守Harden | 第4节 | 距离:0.8米 | 反应:0.20秒 | ✅成功 | 抢断成功
...
═══════════════════════════════════════这个案例提供了完整的关门防守统计功能,可以记录、统计和分析防守数据，适合用于篮球比赛分析或教学演示。
