Java Reflektionsfeld bitweises Arbeiten

Question

Ich habe ein gutes Verständnis von bitweisen Operationen. Meine Frage ist fallspezifisch. Im folgenden Code von Oracle Tutorial genommen, ist es möglich, den Ausdruck zu ändern:

if ((foundMods & searchMods) == searchMods) 

An:

if (foundMods == searchMods) 

? ... weil wir keine Flagge extrahieren, testen wir nur auf Gleichheit. Recht? ... oder fehle ich etwas?

import java.lang.reflect.Field; 
import java.lang.reflect.Modifier; 
import static java.lang.System.out; 

enum Spy { BLACK , WHITE } 

public class FieldModifierSpy { 
volatile int share; 
int instance; 
class Inner {} 

public static void main(String... args) { 
try { 
    Class<?> c = Class.forName(args[0]); 
    int searchMods = 0x0; 
    for (int i = 1; i < args.length; i++) { 
    searchMods |= modifierFromString(args[i]); 
    } 

    Field[] flds = c.getDeclaredFields(); 
    out.format("Fields in Class '%s' containing modifiers: %s%n", 
      c.getName(), 
      Modifier.toString(searchMods)); 
    boolean found = false; 
    for (Field f : flds) { 
    int foundMods = f.getModifiers(); 
    // Require all of the requested modifiers to be present 
    if ((foundMods & searchMods) == searchMods) { 
     out.format("%-8s [ synthetic=%-5b enum_constant=%-5b ]%n", 
       f.getName(), f.isSynthetic(), 
       f.isEnumConstant()); 
     found = true; 
    } 
    } 

    if (!found) { 
    out.format("No matching fields%n"); 
    } 

    // production code should handle this exception more gracefully 
} catch (ClassNotFoundException x) { 
    x.printStackTrace(); 
} 
} 

private static int modifierFromString(String s) { 
int m = 0x0; 
if ("public".equals(s))   m |= Modifier.PUBLIC; 
else if ("protected".equals(s)) m |= Modifier.PROTECTED; 
else if ("private".equals(s))  m |= Modifier.PRIVATE; 
else if ("static".equals(s))  m |= Modifier.STATIC; 
else if ("final".equals(s))  m |= Modifier.FINAL; 
else if ("transient".equals(s)) m |= Modifier.TRANSIENT; 
else if ("volatile".equals(s)) m |= Modifier.VOLATILE; 
return m; 
} 
} 

Answer 1

Dieses:

if ((foundMods & searchMods) == searchMods) 

sagt: "Wenn foundMods alle Bits in searchMods enthält". Diese

:

if (foundMods == searchMods) 

wäre "wenn foundMods hat die gleichen Bits wie searchMods (und keine anderen)".

Wenn Sie wissen, dass foundMods keine anderen Bits haben, dann sind sie gleichwertig. Ansonsten sind sie definitiv anders.

Answer 2

Lassen Sie foundMods Modifier.PUBLIC | Modifikator.STATIK | Modifier.FINAL Nun lass searchMods Modifier.PUBLIC sein. foundMods & searchMods) == searchMods wird zu true ausgewertet, während foundMods == searchMods wird false sein. Also, ja, Sie vermissen etwas und nein, Sie können das erste nicht durch den letzteren Ausdruck ersetzen.

Answer 3

Kurze Antwort Nein

Mehr Antwort Ihre Annahme, dass if ((foundMods & searchMods) == searchMods) zu if (foundMods == searchMods) entspricht, ist ungültig.

Die erste if testet, ob alle einen Wert Bits im searchMods Wert auch ein Wert Bits im foundMods Wert sind.

So wenn searchMods == 0000111 und foundMods == 0011111 dann if ((foundMods & searchMods) == searchMods) ist wahr, aber if (foundMods == searchMods) ist falsch.

Bei Feldmodifikatoren searchMods kann eine Untergruppe von Modifikatoren sein, die für das aktuelle Feld (foundMods) vorhanden sind.

Answer 4

Wir extrahieren kein Flag, wir testen nur auf Gleichheit. Recht?

Nr. searchMods ist eine Sammlung aller "beleuchteten" Flags, nach denen Sie suchen möchten.Mit dem Operator & wird überprüft, ob foundMods alle "leuchtenden" Flags hat, die searchMods hat - aber es ignoriert zusätzliche Flags, die foundMods haben können, während der == Operator nicht.

Betrachten Sie das folgende Beispiel:

int searchMods = Modifier.PUBLIC | Modifier.STATIC; 
int foundMods = Modifier.PUBLIC | Modifier.STATIC | Modifier.SYNCHRONIZED; 

System.out.println((foundMods & searchMods) == searchMods); 
System.out.println(foundMods == searchMods); 

Die erste print-Anweisung true gedruckt wird, während die zweite false gedruckt wird.