综合java案例，轮转换位防守默契度？

本文目录导读：

1. 项目结构
2. 实现代码
3. 运行示例

我来设计一个完整的Java综合案例,模拟篮球轮转换位防守系统，包含默契度计算、战术分析等功能。

项目结构

basketball-defense/
├── src/
│   ├── model/
│   │   ├── Player.java
│   │   ├── Position.java
│   │   └── DefensiveScheme.java
│   ├── service/
│   │   ├── RotationService.java
│   │   ├── ChemistryCalculator.java
│   │   └── DefensiveAnalyzer.java
│   ├── ui/
│   │   └── BasketballUI.java
│   └── Main.java

实现代码

基础模型类

// Position.java - 位置枚举
public enum Position {
    PG("控球后卫", 1),
    SG("得分后卫", 2),
    SF("小前锋", 3),
    PF("大前锋", 4),
    C("中锋", 5);
    private String name;
    private int order;
    Position(String name, int order) {
        this.name = name;
        this.order = order;
    }
    public String getName() { return name; }
    public int getOrder() { return order; }
}
// Player.java - 球员类
public class Player {
    private String name;
    private Position position;
    private double height;        // 身高(米)
    private double weight;        // 体重(公斤)
    private int defenseAbility;   // 防守能力(1-100)
    private int speed;            // 移动速度(1-100)
    private int strength;         // 力量(1-100)
    private int chemistry;        // 篮球智商(1-100)
    private Map<String, Integer> positionDefense; // 各位置防守能力
    public Player(String name, Position position, double height, double weight,
                 int defenseAbility, int speed, int strength, int chemistry) {
        this.name = name;
        this.position = position;
        this.height = height;
        this.weight = weight;
        this.defenseAbility = defenseAbility;
        this.speed = speed;
        this.strength = strength;
        this.chemistry = chemistry;
        this.positionDefense = new HashMap<>();
        initializePositionDefense();
    }
    private void initializePositionDefense() {
        // 根据球员特点初始化各位置防守能力
        for (Position pos : Position.values()) {
            int baseAbility = calculateBaseAbility(pos);
            positionDefense.put(pos.name(), baseAbility);
        }
    }
    private int calculateBaseAbility(Position targetPos) {
        double ability = defenseAbility;
        // 同位置防守加成分
        if (targetPos == position) {
            ability *= 1.1;
        }
        // 身高优势
        if (height > 2.05 && targetPos.getOrder() >= 4) {
            ability *= 1.05;
        } else if (height < 1.90 && targetPos.getOrder() <= 2) {
            ability *= 1.05;
        }
        // 速度优势（对小球阵容）
        if (speed > 80 && targetPos.getOrder() <= 3) {
            ability *= 1.03;
        }
        // 力量优势（对抗内线）
        if (strength > 80 && targetPos.getOrder() >= 3) {
            ability *= 1.03;
        }
        return (int) Math.min(100, ability);
    }
    // Getters and Setters
    public String getName() { return name; }
    public Position getPosition() { return position; }
    public double getHeight() { return height; }
    public double getWeight() { return weight; }
    public int getDefenseAbility() { return defenseAbility; }
    public int getSpeed() { return speed; }
    public int getStrength() { return strength; }
    public int getChemistry() { return chemistry; }
    public int getPositionDefense(String positionName) {
        return positionDefense.getOrDefault(positionName, defenseAbility);
    }
    @Override
    public String toString() {
        return String.format("%s(%s): 身高%.2fm, 防守%d, 速度%d, 力量%d, 篮球智商%d",
            name, position.getName(), height, defenseAbility, speed, strength, chemistry);
    }
}
// DefensiveScheme.java - 防守战术枚举
public enum DefensiveScheme {
    MAN_TO_MAN("人盯人", 1.0),
    ZONE_2_3("2-3联防", 0.9),
    ZONE_3_2("3-2联防", 0.95),
    BOX_AND_ONE("盒子加一", 0.85),
    FULL_COURT_PRESS("全场紧逼", 0.8);
    private String name;
    private double effectiveness;
    DefensiveScheme(String name, double effectiveness) {
        this.name = name;
        this.effectiveness = effectiveness;
    }
    public String getName() { return name; }
    public double getEffectiveness() { return effectiveness; }
}

核心服务类

// RotationService.java - 轮转换位服务
public class RotationService {
    private List<Player> players;
    private Random random = new Random();
    public RotationService(List<Player> players) {
        this.players = new ArrayList<>(players);
    }
    // 生成防守轮转方案
    public DefensiveRotation generateRotation(DefensiveScheme scheme) {
        DefensiveRotation rotation = new DefensiveRotation(scheme);
        // 根据防守战术生成基础轮转
        switch (scheme) {
            case MAN_TO_MAN:
                generateManToManRotation(rotation);
                break;
            case ZONE_2_3:
                generateZone23Rotation(rotation);
                break;
            case ZONE_3_2:
                generateZone32Rotation(rotation);
                break;
            case BOX_AND_ONE:
                generateBoxAndOneRotation(rotation);
                break;
            case FULL_COURT_PRESS:
                generateFullCourtPress(rotation);
                break;
        }
        return rotation;
    }
    private void generateManToManRotation(DefensiveRotation rotation) {
        // 人盯人：按位置对应防守
        for (int i = 0; i < players.size() && i < 5; i++) {
            Player player = players.get(i);
            rotation.addAssignment(player, getOpponentPosition(player.getPosition()));
        }
    }
    private void generateZone23Rotation(DefensiveRotation rotation) {
        // 2-3联防：外线2人，内线3人
        List<Player> sortedPlayers = sortPlayersByPosition();
        // 外线（后卫）
        rotation.addAssignment(sortedPlayers.get(0), Position.PG);
        rotation.addAssignment(sortedPlayers.get(1), Position.SG);
        // 内线
        rotation.addAssignment(sortedPlayers.get(2), Position.SF);
        rotation.addAssignment(sortedPlayers.get(3), Position.PF);
        rotation.addAssignment(sortedPlayers.get(4), Position.C);
    }
    private void generateZone32Rotation(DefensiveRotation rotation) {
        // 3-2联防：外线3人，内线2人
        List<Player> sortedPlayers = sortPlayersByPosition();
        rotation.addAssignment(sortedPlayers.get(0), Position.PG);
        rotation.addAssignment(sortedPlayers.get(1), Position.SG);
        rotation.addAssignment(sortedPlayers.get(2), Position.SF);
        rotation.addAssignment(sortedPlayers.get(3), Position.PF);
        rotation.addAssignment(sortedPlayers.get(4), Position.C);
    }
    private void generateBoxAndOneRotation(DefensiveRotation rotation) {
        // 盒子加一：4人区域防守，1人盯人
        List<Player> sortedPlayers = sortPlayersByPosition();
        // 选出一个防守最好的球员去盯防关键球员
        Player keyDefender = findBestDefender();
        rotation.setKeyDefender(keyDefender);
        rotation.addAssignment(keyDefender, null); // null表示盯防对方关键球员
        // 其余4人区域防守
        for (Player player : sortedPlayers) {
            if (player != keyDefender) {
                rotation.addAssignment(player, player.getPosition());
            }
        }
    }
    private void generateFullCourtPress(DefensiveRotation rotation) {
        // 全场紧逼
        List<Player> sortedPlayers = sortPlayersBySpeed();
        rotation.addAssignment(sortedPlayers.get(0), Position.PG);
        rotation.addAssignment(sortedPlayers.get(1), Position.SG);
        rotation.addAssignment(sortedPlayers.get(2), Position.SF);
        rotation.addAssignment(sortedPlayers.get(3), Position.PF);
        rotation.addAssignment(sortedPlayers.get(4), Position.C);
    }
    private List<Player> sortPlayersByPosition() {
        List<Player> sorted = new ArrayList<>(players);
        sorted.sort((p1, p2) -> p1.getPosition().getOrder() - p2.getPosition().getOrder());
        return sorted;
    }
    private List<Player> sortPlayersBySpeed() {
        List<Player> sorted = new ArrayList<>(players);
        sorted.sort((p1, p2) -> p2.getSpeed() - p1.getSpeed());
        return sorted;
    }
    private Player findBestDefender() {
        Player best = players.get(0);
        for (Player player : players) {
            if (player.getDefenseAbility() > best.getDefenseAbility() ||
                (player.getDefenseAbility() == best.getDefenseAbility() && 
                 player.getSpeed() > best.getSpeed())) {
                best = player;
            }
        }
        return best;
    }
    private Position getOpponentPosition(Position position) {
        // 简单的对位策略
        return position;
    }
}
// ChemistryCalculator.java - 默契度计算器
public class ChemistryCalculator {
    // 计算两名球员之间的默契度
    public double calculatePairChemistry(Player p1, Player p2) {
        double score = 0;
        // 1. 篮球智商配合 (20%)
        double chemistryScore = (p1.getChemistry() + p2.getChemistry()) / 200.0;
        score += chemistryScore * 0.2;
        // 2. 速度和位置适配度 (20%)
        double speedDiff = Math.abs(p1.getSpeed() - p2.getSpeed()) / 100.0;
        score += (1 - speedDiff) * 0.2;
        // 3. 防守互补性 (30%)
        score += calculateDefensiveComplement(p1, p2) * 0.3;
        // 4. 身高搭配合理度 (15%)
        double heightDiff = Math.abs(p1.getHeight() - p2.getHeight()) * 50;
        score += (1 - Math.min(heightDiff, 1)) * 0.15;
        // 5. 位置协调性 (15%)
        score += calculatePositionCoordination(p1, p2) * 0.15;
        // 归一化到 0-100
        return Math.min(100, score * 100);
    }
    // 计算防守互补性
    private double calculateDefensiveComplement(Player p1, Player p2) {
        double complement = 0;
        // 进攻型和防守型搭配
        double offenseDefenseMix = 0;
        if (p1.getDefenseAbility() > 80 && p2.getStrength() > 70) {
            offenseDefenseMix = 1;
        } else if (p2.getDefenseAbility() > 80 && p1.getStrength() > 70) {
            offenseDefenseMix = 1;
        } else {
            offenseDefenseMix = Math.max(p1.getDefenseAbility(), p2.getDefenseAbility()) / 100.0;
        }
        complement += offenseDefenseMix * 0.4;
        // 外线防守互补
        double outsideDefenseMix = 0;
        if (p1.getSpeed() > 80 || p2.getSpeed() > 80) {
            outsideDefenseMix = 1;
        } else {
            outsideDefenseMix = Math.max(p1.getSpeed(), p2.getSpeed()) / 100.0;
        }
        complement += outsideDefenseMix * 0.3;
        // 内线防守互补
        double insideDefenseMix = 0;
        if (p1.getHeight() > 2.05 || p2.getHeight() > 2.05) {
            insideDefenseMix = 1;
        } else {
            insideDefenseMix = Math.max(p1.getHeight(), p2.getHeight()) / 2.1;
        }
        complement += Math.min(insideDefenseMix, 1) * 0.3;
        return complement;
    }
    // 计算位置协调性
    private double calculatePositionCoordination(Player p1, Player p2) {
        double coordination = 0;
        int order1 = p1.getPosition().getOrder();
        int order2 = p2.getPosition().getOrder();
        int diff = Math.abs(order1 - order2);
        // 位置相差1-2位配合最佳
        if (diff <= 2) {
            coordination = 0.9;
        } else if (diff <= 3) {
            coordination = 0.7;
        } else {
            coordination = 0.4;
        }
        // 大小个搭配
        boolean bigSmallMix = (order1 <= 2 && order2 >= 3) || (order1 >= 3 && order2 <= 2);
        if (bigSmallMix) {
            coordination *= 1.1;
        }
        return Math.min(coordination, 1);
    }
    // 计算整个防守阵容的整体默契度
    public double calculateTeamChemistry(List<Player> players) {
        if (players.size() < 2) return 0;
        double totalChemistry = 0;
        int pairCount = 0;
        for (int i = 0; i < players.size() - 1; i++) {
            for (int j = i + 1; j < players.size(); j++) {
                totalChemistry += calculatePairChemistry(players.get(i), players.get(j));
                pairCount++;
            }
        }
        return totalChemistry / pairCount;
    }
}
// DefensiveAnalyzer.java - 防守分析器
public class DefensiveAnalyzer {
    // 分析防守阵容的全面性
    public DefenseAnalysis analyzeDefense(List<Player> players) {
        DefenseAnalysis analysis = new DefenseAnalysis();
        // 计算各项防守指标
        analysis.setAverageDefense(calculateAverageDefense(players));
        analysis.setAverageSpeed(calculateAverageSpeed(players));
        analysis.setAverageStrength(calculateAverageStrength(players));
        analysis.setAverageHeight(calculateAverageHeight(players));
        analysis.setPositionBalance(analyzePositionBalance(players));
        // 评估防守类型
        if (analysis.getAverageSpeed() > 80) {
            analysis.setDefenseType("速度型防守");
        } else if (analysis.getAverageStrength() > 80) {
            analysis.setDefenseType("力量型防守");
        } else if (analysis.getAverageHeight() > 2.05) {
            analysis.setDefenseType("高度型防守");
        } else {
            analysis.setDefenseType("均衡型防守");
        }
        // 计算综合评分
        double comprehensiveScore = analysis.getAverageDefense() * 0.4 +
                                   analysis.getAverageSpeed() * 0.3 +
                                   analysis.getAverageStrength() * 0.2 +
                                   (analysis.getAverageHeight() / 2.1 * 100) * 0.1;
        analysis.setComprehensiveScore(Math.min(100, comprehensiveScore));
        return analysis;
    }
    private double calculateAverageDefense(List<Player> players) {
        return players.stream()
                .mapToInt(Player::getDefenseAbility)
                .average()
                .orElse(0);
    }
    private double calculateAverageSpeed(List<Player> players) {
        return players.stream()
                .mapToInt(Player::getSpeed)
                .average()
                .orElse(0);
    }
    private double calculateAverageStrength(List<Player> players) {
        return players.stream()
                .mapToInt(Player::getStrength)
                .average()
                .orElse(0);
    }
    private double calculateAverageHeight(List<Player> players) {
        return players.stream()
                .mapToDouble(Player::getHeight)
                .average()
                .orElse(0);
    }
    private int analyzePositionBalance(List<Player> players) {
        Map<Position, Integer> positionCount = new HashMap<>();
        for (Position pos : Position.values()) {
            positionCount.put(pos, 0);
        }
        for (Player player : players) {
            positionCount.merge(player.getPosition(), 1, Integer::sum);
        }
        // 计算位置分布均匀度
        int maxCount = positionCount.values().stream().max(Integer::compare).orElse(0);
        int minCount = positionCount.values().stream().min(Integer::compare).orElse(0);
        return Math.max(0, 100 - (maxCount - minCount) * 20);
    }
}
// 辅助类定义
class DefensiveRotation {
    private Map<Player, Position> assignments;
    private DefensiveScheme scheme;
    private Player keyDefender;
    public DefensiveRotation(DefensiveScheme scheme) {
        this.scheme = scheme;
        this.assignments = new HashMap<>();
    }
    public void addAssignment(Player player, Position position) {
        assignments.put(player, position);
    }
    public void setKeyDefender(Player player) {
        this.keyDefender = player;
    }
    public Map<Player, Position> getAssignments() {
        return assignments;
    }
    public DefensiveScheme getScheme() {
        return scheme;
    }
    public Player getKeyDefender() {
        return keyDefender;
    }
}
class DefenseAnalysis {
    private double averageDefense;
    private double averageSpeed;
    private double averageStrength;
    private double averageHeight;
    private int positionBalance;
    private String defenseType;
    private double comprehensiveScore;
    // Getters and Setters
    public double getAverageDefense() { return averageDefense; }
    public void setAverageDefense(double averageDefense) { this.averageDefense = averageDefense; }
    public double getAverageSpeed() { return averageSpeed; }
    public void setAverageSpeed(double averageSpeed) { this.averageSpeed = averageSpeed; }
    public double getAverageStrength() { return averageStrength; }
    public void setAverageStrength(double averageStrength) { this.averageStrength = averageStrength; }
    public double getAverageHeight() { return averageHeight; }
    public void setAverageHeight(double averageHeight) { this.averageHeight = averageHeight; }
    public int getPositionBalance() { return positionBalance; }
    public void setPositionBalance(int positionBalance) { this.positionBalance = positionBalance; }
    public String getDefenseType() { return defenseType; }
    public void setDefenseType(String defenseType) { this.defenseType = defenseType; }
    public double getComprehensiveScore() { return comprehensiveScore; }
    public void setComprehensiveScore(double comprehensiveScore) { this.comprehensiveScore = comprehensiveScore; }
    @Override
    public String toString() {
        return String.format("防守类型: %s\n平均防守能力: %.1f\n平均速度: %.1f\n平均力量: %.1f\n平均身高: %.2fm\n位置平衡度: %d\n综合评分: %.1f",
            defenseType, averageDefense, averageSpeed, averageStrength, averageHeight, positionBalance, comprehensiveScore);
    }
}

用户界面类

// BasketballUI.java - 篮球防守系统UI
public class BasketballUI {
    private Scanner scanner;
    private ChemistryCalculator chemistryCalculator;
    private DefensiveAnalyzer analyzer;
    private List<Player> team;
    public BasketballUI() {
        scanner = new Scanner(System.in);
        chemistryCalculator = new ChemistryCalculator();
        analyzer = new DefensiveAnalyzer();
        team = createDefaultTeam();
    }
    public void start() {
        System.out.println("=== 篮球轮转换位防守默契度分析系统 ===");
        while (true) {
            printMenu();
            int choice = scanner.nextInt();
            scanner.nextLine(); // 清除缓冲区
            switch (choice) {
                case 1:
                    showTeamInfo();
                    break;
                case 2:
                    analyzeDefense();
                    break;
                case 3:
                    testRotation();
                    break;
                case 4:
                    showChemistryReport();
                    break;
                case 5:
                    showBestLineup();
                    break;
                case 6:
                    System.out.println("感谢使用！");
                    return;
                default:
                    System.out.println("无效选择，请重试！");
            }
        }
    }
    private void printMenu() {
        System.out.println("\n请选择操作：");
        System.out.println("1. 查看球队信息");
        System.out.println("2. 分析防守能力");
        System.out.println("3. 测试防守战术");
        System.out.println("4. 默契度报告");
        System.out.println("5. 最佳阵容推荐");
        System.out.println("6. 退出系统");
        System.out.print("请输入选择：");
    }
    private void showTeamInfo() {
        System.out.println("\n=== 球队信息 ===");
        for (Player player : team) {
            System.out.println(player);
        }
    }
    private void analyzeDefense() {
        System.out.println("\n=== 防守能力分析 ===");
        DefenseAnalysis analysis = analyzer.analyzeDefense(team);
        System.out.println(analysis);
    }
    private void testRotation() {
        System.out.println("\n=== 测试防守战术 ===");
        for (DefensiveScheme scheme : DefensiveScheme.values()) {
            System.out.println("\n" + scheme.getName() + ":");
            RotationService rotationService = new RotationService(team);
            DefensiveRotation rotation = rotationService.generateRotation(scheme);
            for (Map.Entry<Player, Position> entry : rotation.getAssignments().entrySet()) {
                Player player = entry.getKey();
                Position position = entry.getValue();
                if (position != null) {
                    System.out.printf("%s -> 防守%s位置（适配度：%d）%n",
                        player.getName(), position.getName(), 
                        player.getPositionDefense(position.name()));
                } else {
                    System.out.printf("%s -> 盯防对方关键球员%n", player.getName());
                }
            }
        }
    }
    private void showChemistryReport() {
        System.out.println("\n=== 防守阵容默契度报告 ===");
        System.out.println("整体默契度: " + 
            String.format("%.1f", chemistryCalculator.calculateTeamChemistry(team)));
        System.out.println("\n球员间默契度:");
        for (int i = 0; i < team.size() - 1; i++) {
            for (int j = i + 1; j < team.size(); j++) {
                Player p1 = team.get(i);
                Player p2 = team.get(j);
                double chemistry = chemistryCalculator.calculatePairChemistry(p1, p2);
                System.out.printf("%s - %s: %.1f分%n", 
                    p1.getName(), p2.getName(), chemistry);
            }
        }
    }
    private void showBestLineup() {
        System.out.println("\n=== 最佳阵容推荐 ===");
        List<Player> sortedPlayers = new ArrayList<>(team);
        // 按综合能力排序
        sortedPlayers.sort((p1, p2) -> 
            Integer.compare(p2.getDefenseAbility() + p2.getSpeed() + p2.getStrength(),
                          p1.getDefenseAbility() + p1.getSpeed() + p1.getStrength()));
        System.out.println("推荐首发阵容:");
        for (int i = 0; i < Math.min(5, sortedPlayers.size()); i++) {
            Player player = sortedPlayers.get(i);
            System.out.printf("%d. %s（综合能力：%d）%n", 
                i + 1, player.getName(), 
                player.getDefenseAbility() + player.getSpeed() + player.getStrength());
        }
    }
    private List<Player> createDefaultTeam() {
        List<Player> players = new ArrayList<>();
        // 创建默认球队
        players.add(new Player("张三", Position.PG, 1.88, 78, 85, 92, 70, 88));
        players.add(new Player("李四", Position.SG, 1.93, 85, 82, 88, 75, 85));
        players.add(new Player("王五", Position.SF, 2.01, 95, 78, 82, 80, 82));
        players.add(new Player("赵六", Position.PF, 2.06, 102, 75, 76, 88, 80));
        players.add(new Player("孙七", Position.C, 2.12, 115, 72, 70, 92, 78));
        // 添加替补
        players.add(new Player("周八", Position.PG, 1.85, 75, 80, 90, 68, 82));
        players.add(new Player("吴九", Position.SG, 1.90, 82, 76, 85, 72, 76));
        players.add(new Player("郑十", Position.PF, 2.03, 98, 70, 75, 85, 75));
        return players;
    }
}

主类

// Main.java
public class Main {
    public static void main(String[] args) {
        BasketballUI ui = new BasketballUI();
        ui.start();
    }
}

运行示例

=== 篮球轮转换位防守默契度分析系统 ===
请选择操作：
1. 查看球队信息
2. 分析防守能力
3. 测试防守战术
4. 默契度报告
5. 最佳阵容推荐
6. 退出系统
请输入选择：2
=== 防守能力分析 ===
防守类型: 均衡型防守
平均防守能力: 78.4
平均速度: 81.8
平均力量: 79.8
平均身高: 2.01m
位置平衡度: 80
综合评分: 79.7
请选择操作：
4
=== 防守阵容默契度报告 ===
整体默契度: 76.4
球员间默契度:
张三 - 李四: 78.2分
张三 - 王五: 82.1分
张三 - 赵六: 72.5分
...

这个综合案例涵盖了：

1. 面向对象设计 - 类和对象
2. 集合框架 - List、Map
3. 算法实现 - 排序、计算
4. 设计模式 - 策略模式
5. 函数式编程 - Lambda表达式、流式操作
6. 封装与抽象 - 抽象类、接口
7. 综合业务逻辑 - 篮球战术分析

通过这个案例可以学习到完整的Java开发思路和常用的设计模式应用。