综合java案例，中卫组合默契度如何量化？

wen java案例 2026-11-10 3

Java案例：中卫组合默契度量化模型

下面我用一个完整的Java案例,演示如何把"中卫组合默契度"这个模糊概念拆解为可计算的指标，并用面向对象的方式实现。

指标拆解思路

中卫默契度不能只看"一起出场次数"，需要多维度量化：

维度	指标	说明
稳定性	共同出场时间	一起踢的分钟数
防守协同	联合防守成功率	共同在场时的防守事件成功率
互补性	能力互补度	速度/对抗/出球等属性的互补
空间协同	站位重叠惩罚	两人活动热区重叠过多则扣分
失误联动	协同失误率	因配合失误导致的丢球
稳定性	共同出场胜率/失球	共同在场的球队表现

核心代码实现

球员属性与组合数据模型

import java.util.*;
/** 中卫球员属性（0~100） */
public class CenterBack {
    private final String name;
    private final double pace;        // 速度
    private final double strength;    // 对抗
    private final double passing;     // 出球
    private final double positioning; // 站位
    private final double aggression;  // 侵略性
    public CenterBack(String name, double pace, double strength,
                      double passing, double positioning, double aggression) {
        this.name = name;
        this.pace = pace;
        this.strength = strength;
        this.passing = passing;
        this.positioning = positioning;
        this.aggression = aggression;
    }
    // getters 省略
    public double getPace() { return pace; }
    public double getStrength() { return strength; }
    public double getPassing() { return passing; }
    public double getPositioning() { return positioning; }
    public double getAggression() { return aggression; }
    public String getName() { return name; }
}
/** 一对中卫的共同出场统计数据 */
public class PairStats {
    final int minutesTogether;      // 共同出场分钟
    final int defensiveActions;     // 共同在场防守动作数
    final int defensiveSuccess;     // 其中成功数
    final int coErrors;             // 协同失误导致丢球数
    final int goalsConceded;        // 共同在场失球
    final int matchesTogether;      // 共同出场场次
    final int winsTogether;         // 共同在场获胜场次
    final double heatmapOverlap;    // 活动热区重叠率 0~1
    // 构造器与 getters 省略
}

默契度计算引擎

public class ChemistryCalculator {
    // 各维度权重（可调参）
    private static final double W_MINUTES   = 0.20;
    private static final double W_DEFENSE   = 0.25;
    private static final double W_COMPLEMENT= 0.20;
    private static final double W_SPACE     = 0.15;
    private static final double W_ERROR     = 0.10;
    private static final double W_RESULT    = 0.10;
    public double calculate(CenterBack a, CenterBack b, PairStats s) {
        double minutesScore   = scoreMinutes(s.minutesTogether);
        double defenseScore   = scoreDefense(s);
        double complementScore= scoreComplement(a, b);
        double spaceScore     = scoreSpace(s.heatmapOverlap);
        double errorScore     = scoreError(s);
        double resultScore    = scoreResult(s);
        double total = W_MINUTES    * minutesScore
                     + W_DEFENSE    * defenseScore
                     + W_COMPLEMENT * complementScore
                     + W_SPACE      * spaceScore
                     + W_ERROR      * errorScore
                     + W_RESULT     * resultScore;
        return Math.round(total * 100) / 100.0; // 0~100
    }
    /** 出场时间：900分钟(约10场)封顶 */
    private double scoreMinutes(int minutes) {
        return Math.min(100.0, minutes / 900.0 * 100);
    }
    /** 联合防守成功率 */
    private double scoreDefense(PairStats s) {
        if (s.defensiveActions == 0) return 0;
        return (double) s.defensiveSuccess / s.defensiveActions * 100;
    }
    /**
     * 互补度：各属性差异在"适度区间"最好。
     * 差异过小=同质化，差异过大=脱节。
     * 用 1 - |diff-理想差|/理想差 建模，理想差取20分。
     */
    private double scoreComplement(CenterBack a, CenterBack b) {
        double[] diffs = {
            Math.abs(a.getPace() - b.getPace()),
            Math.abs(a.getStrength() - b.getStrength()),
            Math.abs(a.getPassing() - b.getPassing()),
            Math.abs(a.getPositioning() - b.getPositioning())
        };
        double ideal = 20.0, sum = 0;
        for (double d : diffs) {
            sum += Math.max(0, 1 - Math.abs(d - ideal) / ideal);
        }
        return sum / diffs.length * 100;
    }
    /** 热区重叠：0.5左右最佳（既有覆盖又不冲突） */
    private double scoreSpace(double overlap) {
        return Math.max(0, 1 - Math.abs(overlap - 0.5) / 0.5) * 100;
    }
    /** 协同失误：每90分钟协同失误越少越好 */
    private double scoreError(PairStats s) {
        if (s.minutesTogether == 0) return 0;
        double errPer90 = s.coErrors * 90.0 / s.minutesTogether;
        return Math.max(0, 100 - errPer90 * 50); // 每90分钟1次扣50
    }
    /** 共同出场战绩：胜率与场均失球综合 */
    private double scoreResult(PairStats s) {
        if (s.matchesTogether == 0) return 0;
        double winRate = (double) s.winsTogether / s.matchesTogether;
        double concededPerMatch = (double) s.goalsConceded / s.matchesTogether;
        double winPart = winRate * 100;
        double defPart = Math.max(0, 100 - concededPerMatch * 25); // 场均失1球扣25
        return winPart * 0.5 + defPart * 0.5;
    }
}

使用示例

public class Main {
    public static void main(String[] args) {
        CenterBack a = new CenterBack("A", 60, 85, 70, 80, 75); // 力量型
        CenterBack b = new CenterBack("B", 82, 65, 78, 85, 70); // 速度型
        PairStats s = new PairStats(
            1200,   // 共同出场分钟
            450,    // 防守动作
            380,    // 成功数
            3,      // 协同失误
            14,     // 共同失球
            15,     // 共同场次
            10,     // 胜场
            0.55    // 热区重叠
        );
        ChemistryCalculator calc = new ChemistryCalculator();
        double score = calc.calculate(a, b, s);
        System.out.printf("%s + %s 默契度: %.2f / 100%n",
                a.getName(), b.getName(), score);
        // 输出示例: A + B 默契度: 82.xx / 100
    }
}