Java静态main方法无法访问非静态ArrayList报错排查

main方法是静态方法，归属类本身，不归属类的实例对象。你定义的clubs、games两个ArrayList是实例成员变量，必须依托Championship类的实例对象才能访问，直接在静态上下文里调用就会触发你遇到的「静态上下文无法引用非静态变量」编译错误。

除了静态引用问题，你的代码还存在以下会导致运行/编译失败的问题：

• 变量名拼写错误：switch判断处写的是opçao，和前面定义的接收用户输入的变量option不匹配
• 类名拼写不一致：Club类的构造方法错写为Clube，Game类中声明的俱乐部成员变量类型也错写为Clube，和实际类名Club不匹配
• Scanner输入逻辑错误：读取输入时多余调用nextLine()/nextInt()，会吞掉有效用户输入
• case 3分支缺失break关键字，会发生分支穿透，执行完列结果逻辑后会直接继续执行case 4的登记结果逻辑
• case 4的迭代器逻辑完全冗余：你已经拿到了用户输入的比赛索引s，直接通过索引取对应Game对象即可，不需要额外写迭代循环
• 创建比赛的逻辑存在缺陷：通过迭代器每次取两个相邻俱乐部配对，会遗漏大量对阵组合，且迭代器调用next()前没有做剩余元素判断，俱乐部数量为奇数时会抛出NoSuchElementException
• 缺失必要导包：使用ArrayList、Iterator、Scanner类时没有导入java.util包下的对应类

面向对象规范下的推荐写法是在main方法中先创建Championship类的实例，通过该实例访问两个成员列表，完整修复后的可运行代码如下：

Championship类 #

import java.util.ArrayList;
import java.util.Scanner;

public class Championship{
    ArrayList<Club> clubs;
    ArrayList<Game> games;

    public Championship() {
        clubs = new ArrayList<>();
        games = new ArrayList<>();
    }
    
    public static void main(String[] args) {
        // 初始化类实例，即可访问实例成员变量
        Championship championship = new Championship();
        Scanner sc = new Scanner(System.in);
        int option = -1;
        
        while(option!=0){
            System.out.println("\t1- 创建俱乐部");
            System.out.println("\t2- 创建比赛");
            System.out.println("\t3- 列出比赛结果");
            System.out.println("\t4- 按索引登记比赛结果");
            System.out.println("\t0- 退出程序");
            option = sc.nextInt();
            sc.nextLine(); // 吸收nextInt遗留的换行符
            switch(option){
                case 1:
                    System.out.println("输入俱乐部名称：");
                    String n = sc.nextLine();
                    System.out.println("输入俱乐部所在城市：");
                    String c = sc.nextLine();
                    championship.clubs.add(new Club(n, c));
                    break;
                case 2:
                    // 双层循环实现所有俱乐部两两配对生成比赛，避免迭代器取值问题
                    for (int i = 0; i < championship.clubs.size(); i++) {
                        for (int j = i+1; j < championship.clubs.size(); j++) {
                            championship.games.add(new Game(
                                    championship.clubs.get(i),
                                    championship.clubs.get(j)
                            ));
                        }
                    }
                    System.out.println("已基于现有俱乐部生成所有对阵比赛");
                    break;
                case 3:
                    for(Game game : championship.games){
                        System.out.println(game.getHomeScore() + " : " + game.getAwayScore());
                    }
                    break; // 补全break防止分支穿透
                case 4:
                    System.out.println("输入比赛索引：");
                    int s = sc.nextInt();
                    sc.nextLine();
                    // 增加索引合法性校验
                    if (s < 0 || s >= championship.games.size()) {
                        System.out.println("输入的比赛索引无效");
                        break;
                    }
                    System.out.println("输入主队进球数：");
                    int homeScore = sc.nextInt();
                    sc.nextLine();
                    System.out.println("输入客队进球数：");
                    int awayScore = sc.nextInt();
                    sc.nextLine();
                    // 直接通过索引获取目标比赛，移除冗余迭代器逻辑
                    Game target = championship.games.get(s);
                    target.setResult(homeScore, awayScore);
                    break;
                case 0:
                    System.out.println("程序退出");
                    break;
                default:
                    System.out.println("无效选项，请重新输入");
            }
        }
        sc.close();
    }
}

Club类 #

public class Club {
    private String name;
    private String city;

    // 修正构造方法名，与类名保持一致
    public Club(String name, String city) {
        this.name = name;
        this.city = city;
    }

    public String getCity() {
        return city;
    }

    public String getName() {
        return name;
    }
}

Game类 #

public class Game{
    // 修正成员变量类型，与Club类名保持一致
    private Club home;
    private Club away;
    private int homeScore;
    private int awayScore;

    public Game(Club home, Club away) {
        this.home = home;
        this.away = away;
        this.homeScore = 0;
        this.awayScore = 0;
    }

    public void setResult(int homeScore, int awayScore) {
        this.homeScore = homeScore;
        this.awayScore = awayScore;
    }

    public int getHomeScore() {
        return homeScore;
    }

    public int getAwayScore() {
        return awayScore;
    }
}

如果你不想创建类实例，也可以直接给clubs、games两个成员变量添加static修饰符，将其改为静态成员变量，即可直接在main静态方法中访问。但从面向对象设计原则出发，更推荐上述创建实例的写法，代码耦合度更低、扩展性更好。

内容的提问来源于stack exchange，提问作者nuno