java案例统计关门防守成功几次？

wen java案例 2026-08-26 231

本文目录导读：

java案例统计关门防守成功几次？

完整案例代码
代码说明

我来为您创建一个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秒 | ✅成功 | 抢断成功
...
═══════════════════════════════════════

这个案例提供了完整的关门防守统计功能,可以记录、统计和分析防守数据，适合用于篮球比赛分析或教学演示。

本文地址： https://bmjup.com/post/53303.html