为什么这会在Java方法中导致错误类

所以我想知道为什么会返回错误：“无法从Compn类型对非静态方法comparen（args）进行静态引用”。显然，我无法使comparen（）方法成为静态的，因此不确定出了什么问题

//8 bit comparison. bit 7 and bit 15 are highest.
public static boolean[] comparator(boolean bit0, boolean bit1, boolean bit2,
                boolean bit3, boolean bit4, boolean bit5,
                boolean bit6, boolean bit7,
                boolean bit8, boolean bit9, boolean bit10,
                boolean bit11, boolean bit12, boolean bit13,
                boolean bit14, boolean bit15) {

    boolean[] comparatorOUT = new boolean[3]; //0 == A>B, 1 == B>A, 2 == A==B
    boolean[][] currVal =  new boolean[16][3]; // [0] = highest bit.

    class Compn {
        boolean[] comparen(boolean curr1, boolean curr2, boolean curr3, boolean b1, boolean b2) {
            boolean[] storage = new boolean[3];
            storage[0] = curr3 && (((!xor(curr1, curr2) && b1) && !(!xor(curr1, curr2) && b2)) || curr1 && !curr2);
            storage[1] = curr3 && (((!xor(curr1, curr2) && b2) && !(!xor(curr1, curr2) && b1)) || !curr1 && curr2);
            storage[2] = curr3 && (!storage[0] && !storage[1]);
            return storage;
        }   
    }
    currVal[0] = Compn.comparen(false, false, true, bit7, bit15);
    currVal[1] = Compn.comparen(currVal[0][0], currVal[0][1], currVal[0][2], bit6, bit14);
    currVal[2] = Compn.comparen(currVal[1][0], currVal[1][1], currVal[1][2], bit5, bit13);
    currVal[3] = Compn.comparen(currVal[2][0], currVal[2][1], currVal[2][2], bit4, bit12);
    currVal[4] = Compn.comparen(currVal[3][0], currVal[3][1], currVal[3][2], bit3, bit11);
    currVal[5] = Compn.comparen(currVal[4][0], currVal[4][1], currVal[4][2], bit2, bit10);
    currVal[6] = Compn.comparen(currVal[5][0], currVal[5][1], currVal[5][2], bit1, bit9);
    currVal[7] = Compn.comparen(currVal[6][0], currVal[6][1], currVal[6][2], bit0, bit8);

    comparatorOUT[0] = currVal[0][0] || currVal[1][0] || currVal[2][0] || currVal[3][0] || currVal[4][0] || currVal[5][0] || currVal[6][0] || currVal[7][0];
    comparatorOUT[1] = currVal[0][1] || currVal[1][1] || currVal[2][1] || currVal[3][1] || currVal[4][1] || currVal[5][1] || currVal[6][1] || currVal[7][1];
    comparatorOUT[2] = !comparatorOUT[0] && !comparatorOUT[1];

    return comparatorOUT;
}

---

只有当方法是静态的时，才能这样调用

Compn.comparen

你应该这样做

Compn c = new Compn();
currVal[0] = c.comparen(false, false, true, bit7, bit15);

或者将comparen更改为static

---

为什么不把Compn类放在方法之外呢？

你是对的，你不能在

Comp

中进行

比较
静态。但这也意味着你不能像静态的那样调用它

从您的示例中，根本不清楚为什么需要类
Compn
。您可以使
comparen
成为
comparator
的静态同级方法。您已经声明了一个本地类，它是内部类的一种类型，不能声明静态成员。Java有这样的限制是有原因的：声明类实际上毫无意义

将
comparen
方法移动为comparator方法的同级，然后将其设置为
静态
。它没有捕获任何本地状态，因此没有任何东西迫使您首先引入该类

如果要将
comparen
与
comparator
一起封装，则需要为这两个类分别创建一个类。这是使用Java语言特性实现目标的唯一方法。
这是因为方法
comparen
是类
Compn
的实例方法。如果不创建该类的实例，就不能调用实例方法。
为什么不能使
boolean[]compare
static？我更希望方法本身是“自给自足的”。我试图用Java设计电路，其中一个方法表示一个子电路。在子电路中定义#comparen使其更易于重用。谢谢，这很有帮助。我如何创建“兄弟”方法？请记住，我希望将所有内容封装在comparator方法中。与语法树中的同级
comparator一起声明。我的回答已经表明我牢记了你的愿望，尽管你的问题中没有提到。对不起，我真的不明白你会怎么做。你能发布一些示例代码吗？你所说的“那样做”是什么意思？将
比较器
与
比较器
并排放置？是。。。你的意思是让这两种方法都是静态的吗？