programmera.net -> java -> normal     för utskrift      info@programmera.net

Logiska operatorer

1. Logiska operatorer
2. Jämförelse
3. OCH och ELLER
4. Jämföra objekt
5. equals()

1. Logiska operatorer

I nedanstående tabell listas alla numeriska operatorer i Java. Varje operator har en prioritet, som gör att man inte behöver använda så många paranteser.

Operator Prioritet Beskrivning
!  1  Logisk ICKE (byter värde på variabeln)
<  5  Mindre än-test
>  5  Större än-test
<=  5  Mindre än eller lika med-test
>=  5  Större än eller lika med-test
==  6  Lika med-test
!=  6  Ej lika med-test
&&  10  Logsikt OCH
||  11  Logsikt ELLER

2. Jämförelse

==,!=,<,>,<=,>= kräver alla 2 operander och returnerar en boolean: 
class TestBool{
  public static void main(String[] args){
    if(true != false) System.out.println("true");
  }
}
När vi testkör vårt exempel får vi som väntat: 
[olle@dev1]$ java TestBool
true
Man kan även jämföra operander av olika typ: 
class TestLogicNum{
  public static void main(String[] args){
    int i=3;
    double d=2.2;
    if(d < i) System.out.println("true");
  }
}
Vi får: 
[olle@dev1]$ java TestLogicNum
true
I detta fall omvandlas i till typen double innan jämförelsen sker.

3. OCH och ELLER

I programmering är det mycket vanligt att man använder de logiska operationerna OCH (&&) och ELLER (||). De tar två boolean som operander och returnerar en boolean. 
class TestOR{
  public boolean print(String s){
    System.out.println(s);
    return true;
  }
  public static void main(String[] args){
    boolean b=true;
    TestBinary2 t=new TestBinary2();
    if(b || t.print("no check")) t.print("finished");
  }
}
Programmet ger följande utskrift: 
[olle@dev1]$ java TestOR
finished
Som vi ser anropas aldrig print("no check"), testet avbryts efter evalueringen av vänster operand. Logiskt OCH fungerar på liknande sätt, testet avbryts om vänster operand evalueras till false. Anledningen till detta beteende är att snabba upp exekveringen av programmet.

4. Jämföra objekt

== och != kan även användas för att jämföra objekt, men då handlar det om att jämföra själva referensen. Om referensen pekar på samma objekt, då får vi true. När det gäller objektet String bör man undvika denna typ av jämförelse. Se följande exempel: 
class CompareString{
  public static void main(String[] args){
    String s="Hej";
    if(s=="Hej")
      System.out.println("s=Hej");
    
    String t=new String("Hej");
    if(t=="Hej")
      System.out.println("t=Hej");
  }
}
Vi kör programmet: 
[olle@dev1]$ java CompareString
s=Hej
Anledningen till att första uttrycket ger true är att referensen s faktiskt pekar på samma objekt som "Hej". Kompilatorn återanvänder strängobjekten. Men när vi i andra fallet skriver new String() skapas ett nytt objekt, som inte är samma som "Hej". Detta är förvirrande och därför bör man i fallet med strängar använda equals().

5. equals()

Metoden equals() finns i alla klasser, även de som du själv skapat, eftersom det är en metod i klassen Object. I objekt fungerar equals() som ==, alltså tittar om två objektreferenser pekar ut samma objekt. Men i många andra klasser är metoden överlagrad så att den jämför innehållet i ett objekt. I exemplet nedan visas att String och Integer har överlagrat metoden: 
class TestEquals{
  public static void main(String[] args){
    String s=new String("Hej");
    if(s.equals("Hej"))
      System.out.println("s eq Hej");
    Integer i=new Integer(3);
    if(i.equals(new Integer(3)))
      System.out.println("i eq 3");
  }
}
Vi kör programmet: 
[olle@dev1]$ java TestEquals
s eq Hej
i eq 3