本文目录导读：
我来设计一个完整的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分
...这个综合案例涵盖了：
- 面向对象设计 - 类和对象
- 集合框架 - List、Map
- 算法实现 - 排序、计算
- 设计模式 - 策略模式
- 函数式编程 - Lambda表达式、流式操作
- 封装与抽象 - 抽象类、接口
- 综合业务逻辑 - 篮球战术分析
通过这个案例可以学习到完整的Java开发思路和常用的设计模式应用。
