Как использовать побитовый оператор для передачи нескольких Целочисленных значений в функцию для Java?

Вы устанавливаете целочисленные значения, чтобы быть полномочиями два так, чтобы каждое перечисляемое значение было единственным битом в двоичном представлении.

int ONE = 0x1;    //0001
int TWO = 0x2;    //0010
int THREE = 0x4;  //0100
int FOUR = 0x8;   //1000

Затем Вы используете побитовое ИЛИ для объединения значений и поразрядно И к значениям набора тестов.

int test_value = (ONE | FOUR);   //-> 1001
bool has_one = (test_value & ONE) != 0;  //-> 1001 & 0001 -> 0001 -> true

Значения, которые Вы комбинируете с | (двоичный файл ИЛИ, не логичный ИЛИ [который является ||]) не должны иметь наложения "1" с в их разрядном представлении. Например,

ONE = 0x1 =   0000 0001
TWO = 0x2 =   0000 0010
THREE = 0x3 = 0000 0011
FOUR = 0x4 =  0000 0100

Затем можно объединиться ОДИН и ДВА, например:

ONE | TWO = 0000 0011

Но Вы не можете отличить ОДИН | ДВА от ТРИ, потому что там перекрывают биты. Числа, которые Вы комбинируете, должны таким образом быть полномочиями два, такой, что они не накладываются когда OR'ed вместе. Чтобы протестировать, если число было передано в "значениях", сделайте:

if (values & ONE) {
    // ... then ONE was set
}

Чтобы лучше понять, почему и как это работает, я рекомендую читать немного на двоичном представлении и логике. Хорошим местом является Глава 3 Искусства блока.

Как был уже упомянут, рассмотрите использование перечислений вместо битовых значений.

Согласно Эффективному Java 2: "Объект 32: Используйте EnumSet вместо битовых полей"

Использование EnumSet является довольно эффективным для использования памяти и очень удобным.

Вот пример:

package enums;

import java.util.EnumSet;
import java.util.Set;

public class Example {
  public enum Values {
    ONE, TWO, THREE, FOUR, FIVE
  }

  public static void main(String[] args) {
    // should evaluate just Values.ONE
    Example.multiValueExample(EnumSet.of(Values.ONE));

    // should evalueate just values Values.ONE, Values.THREE, Values.FIVE
    Example.multiValueExample(EnumSet.of(Values.ONE, Values.THREE, Values.FIVE));

    // should evalueate just values Values.TWO , Values.FIVE
    Example.multiValueExample(EnumSet.of(Values.TWO, Values.FIVE));
  }

  public static void multiValueExample(Set<Values> values) {
    if (values.contains(Values.ONE)) {
      System.out.println("One");
    }

    // Other checks here...

    if (values.contains(Values.FIVE)) {
      System.out.println("Five");
    }
  }
}

Хорошо, если бы они - полномочия 2, Вы сделали бы что-то как метод "дисплея" в коде ниже.

Вот ссылка в Википедии по теме также, которая должна объяснить, почему Вы хотите полномочия 2.

public class Main
{
    private static final int A = 0x01;
    private static final int B = 0x02;
    private static final int C = 0x04;

    public static void main(final String[] argv)
    {
        display(A);
        display(B);
        display(C);
        display(A | A);
        display(A | B);
        display(A | C);
        display(B | A);
        display(B | B);
        display(B | C);
        display(C | A);
        display(C | B);
        display(C | C);
        display(A | A | A);
        display(A | A | B);
        display(A | A | C);
        display(A | B | A);
        display(A | B | B);
        display(A | B | C);
        display(A | C | A);
        display(A | C | B);
        display(A | C | C);
        display(B | A | A);
        display(B | A | B);
        display(B | A | C);
        display(B | B | A);
        display(B | B | B);
        display(B | B | C);
        display(B | C | A);
        display(B | C | B);
        display(B | C | C);
        display(C | A | A);
        display(C | A | B);
        display(C | A | C);
        display(C | B | A);
        display(C | B | B);
        display(C | B | C);
        display(C | C | A);
        display(C | C | B);
        display(C | C | C);
    }

    private static void display(final int val)
    {
        if((val & A) != 0)
        {
            System.out.print("A");
        }

        if((val & B) != 0)
        {
            System.out.print("B");
        }

        if((val & C) != 0)
        {
            System.out.print("C");
        }

        System.out.println();
    }
}

Во-первых, Вы не можете определить Значения тот способ сделать поразрядные сравнения. Вместо этого набор различные биты:

public static final int ONE   = 0x1;  // First bit is set
public static final int TWO   = 0x2;  // Second bit is set
public static final int THREE = 0x4;  // Third bit is set
public static final int FOUR  = 0x8;  // Fourth bit is set
public static final int FIVE  = 0x10; // Fifth bit is set

Во-вторых, необходимо, вероятно, использовать java.util. BitSet для этих видов операций:

BitSet bits = new BitSet(5);
bits.set(2);
bits.set(4);

System.out.println("these bits are set: " + bits);
// Prints "these bits are set: {2, 4}"

BitSet otherBits = new BitSet(5);
otherBits.set(3);
otherBits.set(4);

System.out.println("these bits are set: " + bits.or(otherBits));
// Prints "these bits are set: {2, 3, 4}"

Учебная глава Java по битовым операциям в

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/op3.html

Это очень кратко, но хорошо для ссылки.

Используя битовые маски были популярны когда каждый считаемый бит. Другой способ сделать это сегодня должно использовать перечисления с, более просты управлять и расшириться.

import static Example.Values.*;
import java.util.Arrays;

public class Example {
    public enum Values { ONE, TWO, THREE, FOUR, FIVE }

    public static void main(String [] args) {
        // should evaluate just Values.ONE
        multiValueExample(ONE);

        // should evaluate just values Values.ONE,  Values.THREE, Values.FIVE
        multiValueExample(ONE, THREE, FIVE);

        // should evaluate just values Values.TWO , Values.FIVE
        multiValueExample(TWO, FIVE);
    }

    public static void multiValueExample(Values... values){
        // Logic that properly evaluates
        System.out.println(Arrays.asList(values));
        for (Values value : values) {
            // do something.
        }
    }
}