Numeriska operatorer i Java

Hej! Idag ska vi överväga ett mycket viktigt ämne, nämligen numeriska operatorer i Java . I programmering finns siffror överallt. Om du gräver djupt och kommer ihåg gymnasiet kanske du kommer ihåg att en dator representerar all information i ett numeriskt format: kombinationer av nollor och ettor, även känd som binär kod. Det finns många numeriska operatorer i programmering, så vi ska använda exempel för att utforska de viktigaste av dem :) Låt oss börja med det enklaste: aritmetiska operatorer . Dessa är de välkända operatorerna addition ( +), subtraktion ( -), multiplikation ( *) och division ( )./

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

Konsolutgång: 1032 966 32967 30 Du har redan använt allt detta. %Till den här gruppen kan du lägga till operatorn resten eller modulo ( ).

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

Konsolutgång: 1 I det här exemplet delar vi 33 med 2. Detta ger 16, med en extra "svans" (en) som inte är delbar med 2. Denna "svans" är resultatet av operationen "återstoden från division". Java implementerar även jämförelse-/relationsoperatorer (precis som i matematik). De är förmodligen bekanta för dig från skolan också:

• lika med ( ==)
• större än ( >)
• mindre än ( <)
• större än eller lika med ( >=)
• mindre än eller lika med ( <=)
• inte lika ( !=)

Här bör du vara uppmärksam på en viktig punkt som får många nybörjare att göra misstag. Operatorn "lika med" skrivs ==inte =. =I Java är en singel tilldelningsoperatorn , som används när en variabel tilldelas ett nummer, en sträng eller värdet av en annan variabel.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

Konsolutgång: 999 Hoppsan! Detta är uppenbarligen inte det resultat vi förväntade oss. Det är en helt annan datatyp: vi förväntade oss att se en boolesk , men vi fick en siffra. Allt för att vi använde en tilldelningsoperator inom parentes istället för en jämförelse . x=y Värdet på y(999) tilldelades variabeln xoch sedan visade vi värdet på x. Här är rätt sätt att göra det:

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

Konsolutgång: false Nu har vi jämfört de två siffrorna ordentligt! :) Här är en annan funktion hos uppdragsoperatören ( =): den kan "kedjas" ihop:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

Konsolutgång: 256 Kom ihåg att tilldelningen är från höger till vänster . Detta uttryck ( x = y = z) kommer att exekveras i steg:

• y = z, det är,y = 256
• x = y, det är,x = 256

Unära operatörer.

De kallas " unary " från ordet " uno ", som betyder " en ". De fick detta namn eftersom de, till skillnad från de tidigare operatörerna, agerar på ett enda nummer, inte flera. Dessa inkluderar:

• Unär minus. Det vänder numrets tecken.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

Konsolutgång: -999 999 Vi använde den unära minusoperatorn två gånger. Som ett resultat var vårt nummer först negativt, och sedan blev det positivt igen!

• Öka (++) och minska (--)

Operatören ++ökar ett nummer med ett och --operatören minskar ett nummer med samma mängd.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

Konsolutgång: 1000 999 Den här notationen kanske är bekant för dig om du har hört talas om språket C++. Dess skapare använde detta intressanta namn för att förmedla tanken att "C++ är en förlängning av C-språket" En populär förbättrad version av Notepad kallas Notepad++ Här är en viktig punkt. Det finns två typer av inkrement- och dekrementoperatorer: postfix och prefix . x++- postfix ++x- prefix Vad är den grundläggande skillnaden mellan att sätta plus/minus före eller efter siffran? Vi kommer att se i följande exempel:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

Konsolutgång: 999 Något är fel! Vi ville öka xmed 1 och tilldela variabeln y det nya värdet. Med andra ord ska y vara 1000. Men istället får vi något annat: 999. Det verkar som om x inte ökades och att inkrementoperatorn inte fungerade? Men det fungerade. För att övertyga dig själv, prova att visa xi slutet :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

Konsolutdata: 999 1000 Faktum är att det är just därför denna operation kallas postfix: den utförs efter huvuduttrycket. Detta betyder, i vårt fall: int y = x++; y = xutförs först (och variabeln ykommer att initieras till värdet av x), och först därefter kommer x++att exekveras. Vad händer om detta inte är det beteende vi vill ha? Då måste vi använda prefixnotation :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

I det här fallet ++xbehandlas först och först efteråt är y = x; avrättade. Du bör lägga in denna skillnad i minnet direkt för att undvika att göra misstag i ett riktigt program där att använda postfix istället för prefix kan vända upp och ner på allt :)

Sammansatta operatörer

Dessutom finns det i Java så kallade sammansatta operatorer. De kombinerar två operatörer:

• Uppdrag
• Aritmetiska operatorer

Dessa inkluderar:

• +=
• -=
• *=
• /=
• %=

Låt oss överväga ett exempel:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

Konsolutgång: 1032 x += y betyder x = x + y. De två symbolerna används i följd för korthetens skull. Kombinationerna , -=och *=fungerar på liknande sätt /=.%=

Logiska operatorer

Förutom numeriska operatorer har Java även operationer som involverar booleska värden ( sant och falskt ). Dessa operationer utförs med logiska operatorer

• !- logiskt INTE . Det vänder värdet på en boolean

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

Konsolutgång: falsk

• &&- logisk OCH . Den returnerar bara sant om båda operanderna är sanna.

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

Konsolutdata: false true Resultatet av den första operationen är falskt, eftersom en av operanderna är falsk, nämligen 100 > 200. För att returnera sant &&kräver operatorn att båda operanderna är sanna (som är fallet på den andra raden).

• ||- logiskt ELLER . Den returnerar sant när minst en av operanderna är sann.

När vi använder den här operatorn ger vårt tidigare exempel ett annat resultat:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

Konsolutdata: true Uttrycket 100 > 200är fortfarande falskt, men för OR -operatorn är det helt tillräckligt att den första delen ( ) 100 > 10är sann.