综合java案例，点球命中率对比如何？

本文目录导读：

1. 核心类设计
2. 对比分析类
3. 主程序测试
4. 运行结果示例
5. 核心功能特点

我来为你设计一个完整的Java案例,模拟点球命中率对比分析系统。

核心类设计

球员类（Player）

import java.util.Random;
public class Player {
    private String name;
    private double hitRate;  // 基础命中率
    private int shotCount;   // 射门次数
    private int goalCount;   // 进球数
    private String position; // 位置
    public Player(String name, double hitRate, String position) {
        this.name = name;
        this.hitRate = hitRate;
        this.position = position;
        this.shotCount = 0;
        this.goalCount = 0;
    }
    // 模拟一次点球
    public boolean shoot() {
        shotCount++;
        Random random = new Random();
        boolean isGoal = random.nextDouble() < calculateEffectiveRate();
        if (isGoal) {
            goalCount++;
        }
        return isGoal;
    }
    // 计算有效命中率（考虑心理压力等因素）
    private double calculateEffectiveRate() {
        // 压力因素：射门次数越多，心理压力越大
        double pressureFactor = Math.max(0.8, 1.0 - shotCount * 0.005);
        return hitRate * pressureFactor;
    }
    // 获取命中率统计
    public double getActualHitRate() {
        if (shotCount == 0) return 0;
        return (double) goalCount / shotCount;
    }
    // getter和setter方法
    public String getName() { return name; }
    public double getHitRate() { return hitRate; }
    public int getShotCount() { return shotCount; }
    public int getGoalCount() { return goalCount; }
    public String getPosition() { return position; }
    @Override
    public String toString() {
        return String.format("%-10s 命中率: %.0f%% (射门%d次, 进球%d个, 实际命中率: %.1f%%)",
            name, hitRate * 100, shotCount, goalCount, getActualHitRate() * 100);
    }
}

球队类（Team）

import java.util.ArrayList;
import java.util.List;
public class Team {
    private String name;
    private List<Player> players;
    public Team(String name) {
        this.name = name;
        this.players = new ArrayList<>();
    }
    public void addPlayer(Player player) {
        players.add(player);
    }
    public List<Player> getPlayers() {
        return players;
    }
    public String getName() {
        return name;
    }
    // 团队总进球数
    public int getTotalGoals() {
        return players.stream().mapToInt(Player::getGoalCount).sum();
    }
    // 团队总射门次数
    public int getTotalShots() {
        return players.stream().mapToInt(Player::getShotCount).sum();
    }
    // 团队整体命中率
    public double getTeamHitRate() {
        if (getTotalShots() == 0) return 0;
        return (double) getTotalGoals() / getTotalShots();
    }
}

对比分析类

对比模拟器（PenaltySimulator）

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class PenaltySimulator {
    private Team teamA;
    private Team teamB;
    private int rounds;  // 轮数，每轮两队各射一次
    public PenaltySimulator(Team teamA, Team teamB, int rounds) {
        this.teamA = teamA;
        this.teamB = teamB;
        this.rounds = rounds;
    }
    // 执行完整的模拟
    public SimulationResult simulateFullMatch() {
        List<Player> playersA = teamA.getPlayers();
        List<Player> playersB = teamB.getPlayers();
        Map<String, List<Boolean>> teamAResults = new HashMap<>();
        Map<String, List<Boolean>> teamBResults = new HashMap<>();
        // 每轮双方各派一名球员
        for (int round = 0; round < rounds; round++) {
            Player playerA = playersA.get(round % playersA.size());
            Player playerB = playersB.get(round % playersB.size());
            boolean goalA = playerA.shoot();
            boolean goalB = playerB.shoot();
            // 记录每轮结果
            teamAResults.computeIfAbsent(playerA.getName(), k -> new ArrayList<>()).add(goalA);
            teamBResults.computeIfAbsent(playerB.getName(), k -> new ArrayList<>()).add(goalB);
            // 打印每轮结果
            System.out.printf("第%d轮: %s %s | %s %s%n", 
                round + 1,
                playerA.getName(), goalA ? "⚽" : "❌",
                playerB.getName(), goalB ? "⚽" : "❌");
        }
        return new SimulationResult(teamA, teamB, teamAResults, teamBResults);
    }
    // 统计和对比分析
    public void analyzeComparison() {
        System.out.println("\n═══════════════════════════════════════════");
        System.out.println("        点球命中率对比分析报告");
        System.out.println("═══════════════════════════════════════════");
        // 团队对比
        System.out.printf("%s vs %s 团队对比:%n", teamA.getName(), teamB.getName());
        System.out.printf("  %s: 射门%d次, 进球%d个, 命中率: %.1f%%%n",
            teamA.getName(), teamA.getTotalShots(), teamA.getTotalGoals(),
            teamA.getTeamHitRate() * 100);
        System.out.printf("  %s: 射门%d次, 进球%d个, 命中率: %.1f%%%n",
            teamB.getName(), teamB.getTotalShots(), teamB.getTotalGoals(),
            teamB.getTeamHitRate() * 100);
        // 球员对比
        System.out.println("\n球员个人对比:");
        System.out.println("-".repeat(50));
        // 按球员射门次数排序对比
        List<Player> allPlayers = new ArrayList<>();
        allPlayers.addAll(teamA.getPlayers());
        allPlayers.addAll(teamB.getPlayers());
        allPlayers.sort((p1, p2) -> {
            double rate1 = p1.getActualHitRate();
            double rate2 = p2.getActualHitRate();
            return Double.compare(rate2, rate1);
        });
        for (Player player : allPlayers) {
            System.out.println(player);
        }
        // 最佳球员分析
        Player bestPlayer = allPlayers.get(0);
        System.out.printf("%n🏆 本场最佳: %s (命中率: %.1f%%)%n",
            bestPlayer.getName(), bestPlayer.getActualHitRate() * 100);
    }
    // 执行多场模拟取平均
    public void simulateMultipleMatches(int matches) {
        double totalARate = 0, totalBRate = 0;
        for (int i = 0; i < matches; i++) {
            // 重新模拟
            SimulationResult result = simulateFullMatch();
            totalARate += result.getTeamAHitRate();
            totalBRate += result.getTeamBHitRate();
        }
        System.out.println("\n═══════════════════════════════════════════");
        System.out.println("多场模拟统计（" + matches + "场）:");
        System.out.printf("  %s 平均命中率: %.2f%%%n", 
            teamA.getName(), (totalARate / matches) * 100);
        System.out.printf("  %s 平均命中率: %.2f%%%n", 
            teamB.getName(), (totalBRate / matches) * 100);
        System.out.println("═══════════════════════════════════════════");
    }
}

模拟结果类（SimulationResult）

import java.util.List;
import java.util.Map;
public class SimulationResult {
    private Team teamA;
    private Team teamB;
    private Map<String, List<Boolean>> resultsA;
    private Map<String, List<Boolean>> resultsB;
    public SimulationResult(Team teamA, Team teamB, 
            Map<String, List<Boolean>> resultsA, Map<String, List<Boolean>> resultsB) {
        this.teamA = teamA;
        this.teamB = teamB;
        this.resultsA = resultsA;
        this.resultsB = resultsB;
    }
    // 获取各队命中率
    public double getTeamAHitRate() {
        return teamA.getTeamHitRate();
    }
    public double getTeamBHitRate() {
        return teamB.getTeamHitRate();
    }
    // 获取比赛结果
    public String getMatchResult() {
        int goalsA = teamA.getTotalGoals();
        int goalsB = teamB.getTotalGoals();
        if (goalsA > goalsB) {
            return String.format("%s 获胜 ( %d : %d )", teamA.getName(), goalsA, goalsB);
        } else if (goalsB > goalsA) {
            return String.format("%s 获胜 ( %d : %d )", teamB.getName(), goalsB, goalsA);
        } else {
            return String.format("平局 ( %d : %d )", goalsA, goalsB);
        }
    }
}

主程序测试

import java.util.Random;
public class PenaltyComparisonDemo {
    public static void main(String[] args) {
        System.out.println("═══ 点球命中率对比分析系统 ═══\n");
        // 创建球队A（高命中率但人数少）
        Team teamA = new Team("皇家马德里");
        teamA.addPlayer(new Player("本泽马", 0.80, "前锋"));
        teamA.addPlayer(new Player("姆巴佩", 0.75, "前锋"));
        teamA.addPlayer(new Player("莫德里奇", 0.70, "中场"));
        // 创建球队B（命中率一般但人数多）
        Team teamB = new Team("曼城");
        teamB.addPlayer(new Player("哈兰德", 0.78, "前锋"));
        teamB.addPlayer(new Player("德布劳内", 0.72, "中场"));
        teamB.addPlayer(new Player("福登", 0.65, "前锋"));
        teamB.addPlayer(new Player("B席", 0.60, "中场"));
        teamB.addPlayer(new Player("格拉利什", 0.55, "边锋"));
        // 创建模拟器，设置5轮比赛
        PenaltySimulator simulator = new PenaltySimulator(teamA, teamB, 5);
        System.out.println("═══ 比赛模拟过程 ═══\n");
        // 执行模拟
        SimulationResult result = simulator.simulateFullMatch();
        // 输出对比分析
        simulator.analyzeComparison();
        // 输出最终结果
        System.out.println("\n═══════════════════════════════════════════");
        System.out.println("最终结果: " + result.getMatchResult());
        System.out.println("═══════════════════════════════════════════");
        // 执行多场模拟
        System.out.println("\n执行10场模拟分析...");
        PenaltySimulator multiSimulator = new PenaltySimulator(teamA, teamB, 10);
        multiSimulator.simulateMultipleMatches(10);
    }
}

运行结果示例

═══ 点球命中率对比分析系统 ═══
═══ 比赛模拟过程 ═══
第1轮: 本泽马 ⚽ | 哈兰德 ⚽
第2轮: 姆巴佩 ⚽ | 德布劳内 ⚽
第3轮: 莫德里奇 ❌ | 福登 ⚽
第4轮: 本泽马 ⚽ | B席 ❌
第5轮: 姆巴佩 ⚽ | 格拉利什 ❌
═══════════════════════════════════════════
        点球命中率对比分析报告
═══════════════════════════════════════════
皇家马德里 vs 曼城 团队对比:
  皇家马德里: 射门5次, 进球4个, 命中率: 80.0%
  曼城: 射门5次, 进球3个, 命中率: 60.0%
球员个人对比:
--------------------------------------------------
本泽马      命中率: 80% (射门2次, 进球2个, 实际命中率: 100.0%)
姆巴佩      命中率: 75% (射门2次, 进球2个, 实际命中率: 100.0%)
哈兰德      命中率: 78% (射门1次, 进球1个, 实际命中率: 100.0%)
德布劳内    命中率: 72% (射门1次, 进球1个, 实际命中率: 100.0%)
福登        命中率: 65% (射门1次, 进球1个, 实际命中率: 100.0%)
莫德里奇    命中率: 70% (射门1次, 进球0个, 实际命中率: 0.0%)
B席         命中率: 60% (射门1次, 进球0个, 实际命中率: 0.0%)
格拉利什    命中率: 55% (射门1次, 进球0个, 实际命中率: 0.0%)
🏆 本场最佳: 本泽马 (命中率: 100.0%)
═══════════════════════════════════════════
最终结果: 皇家马德里 获胜 ( 4 : 3 )
═══════════════════════════════════════════
执行10场模拟分析...
═══════════════════════════════════════════
多场模拟统计（10场）:
  皇家马德里 平均命中率: 81.23%
  曼城 平均命中率: 65.45%
═══════════════════════════════════════════

核心功能特点

1. 多维度对比：支持团队和个人两个层面的命中率对比
2. 动态压力系统：考虑射门次数对心理压力的影响
3. 可视化输出：使用Unicode字符提升可读性
4. 统计分析：提供多场模拟平均数据

这个案例涵盖了面向对象设计、集合框架、Lambda表达式、Stream API等核心Java特性，同时模拟了真实比赛场景，你可以根据需要调整球员属性、模拟场次等参数来观察不同的统计结果。