Java编译错误：内部类非法static声明问题求助（HackerRank场景）

错误原因 #

你写的Solution类是Result类的非静态内部类，Java语法规定：非静态内部类中不能定义静态方法（仅允许声明编译时常量），所以main方法的static修饰符触发了编译错误。

两种修复方案 #

方案1：将Solution改为静态内部类

在Solution类的定义前加上static关键字，让它变成属于Result类本身的静态内部类，这样就可以容纳静态方法了：

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {
    public static String isBalanced(String s) {
        int getLength = s.length() - 1;
        int temp = 0;
        while (temp < s.length() / 2) {
            if (s.charAt(0) == s.charAt(getLength)) {
                temp++;
                getLength--;
            } else {
                return "NO";
            }
        }
        return "YES";
    }   

    // 加上static关键字，改为静态内部类
    public static class Solution {
        public static void main(String[] args) throws Exception {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

            int t = Integer.parseInt(bufferedReader.readLine().trim());

            IntStream.range(0, t).forEach(tItr -> {
                try {
                    String s = bufferedReader.readLine();

                    String result = Result.isBalanced(s);

                    bufferedWriter.write(result);
                    bufferedWriter.newLine();
                } catch (IOException ex) {
                    throw new RuntimeException(ex);
                }
            });

            bufferedReader.close();
            bufferedWriter.close();
        }
    }
}

方案2：将Solution类移出Result类，作为顶级类

把Solution类从Result类的大括号里拿出来，让两个类都是独立的顶级类，彻底规避内部类的限制：

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {
    public static String isBalanced(String s) {
        int getLength = s.length() - 1;
        int temp = 0;
        while (temp < s.length() / 2) {
            if (s.charAt(0) == s.charAt(getLength)) {
                temp++;
                getLength--;
            } else {
                return "NO";
            }
        }
        return "YES";
    }   
}

// 移到外面作为顶级类
public class Solution {
    public static void main(String[] args) throws Exception {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        int t = Integer.parseInt(bufferedReader.readLine().trim());

        IntStream.range(0, t).forEach(tItr -> {
            try {
                String s = bufferedReader.readLine();

                String result = Result.isBalanced(s);

                bufferedWriter.write(result);
                bufferedWriter.newLine();
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        });

        bufferedReader.close();
        bufferedWriter.close();
    }
}

额外提示 #

注意你的isBalanced方法逻辑有问题——当前代码只是判断字符串首尾对称，不是正确的括号平衡判断逻辑（比如"([)]"会被误判为平衡）。如果是HackerRank的括号平衡题，应该用栈来实现：遇到左括号入栈，遇到右括号则检查栈顶是否是匹配的左括号，最后栈为空则平衡。

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