Numeriske operatorer i Java

Hej! I dag vil vi overveje et meget vigtigt emne, nemlig numeriske operatorer i Java . I programmering er tal overalt. Hvis du graver dybt og husker gymnasiet, kan du huske, at en computer repræsenterer al information i et numerisk format: kombinationer af nuller og enere, også kendt som binær kode. Der er masser af numeriske operatorer i programmering, så vi vil bruge eksempler til at udforske de vigtigste af dem :) Lad os starte med det enkleste: aritmetiske operatorer . Disse er de velkendte operatorer for addition ( +), subtraktion ( -), multiplikation ( *) og 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);
   }
}

Konsoludgang: 1032 966 32967 30 Du har allerede brugt alt dette. Til denne gruppe kan du tilføje resten eller modulo ( %) operatoren.

public class Main {

   public static void main(String[] args) {

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

Konsoloutput: 1 I dette eksempel dividerer vi 33 med 2. Dette giver 16, med en ekstra "hale" (en), der ikke er delelig med 2. Denne "hale" er resultatet af "resten fra division"-operationen. Java implementerer også sammenlignings-/relationsoperatorer (ligesom i matematik). De er sikkert også kendte for dig fra skolen:

• lig med ( ==)
• større end ( >)
• mindre end ( <)
• større end eller lig med ( >=)
• mindre end eller lig med ( <=)
• ikke ens ( !=)

Her bør du være opmærksom på et vigtigt punkt, der får mange begyndere til at lave fejl. Operatoren "lig med" er skrevet ==, ikke =. =I Java er en enkelt tildelingsoperatoren , som bruges, når en variabel er tildelt et tal, en streng eller værdien af ​​en anden 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
   }
}

Konsoludgang: 999 Ups! Dette er åbenbart ikke det resultat, vi forventede. Det er en helt anden datatype: vi forventede at se en boolsk , men vi fik et tal. Alt sammen fordi vi brugte en tildelingsoperator i parentes i stedet for en sammenligning . x=y Værdien af y​​(999) blev tildelt variablen x, og derefter viste vi værdien af x. Her er den rigtige måde at gøre det på:

public class Main {

   public static void main(String[] args) {

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

Konsol output: false Nu har vi sammenlignet de to tal korrekt! :) Her er en anden funktion af opgaveoperatøren ( =): den kan "kædes" sammen:

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);
   }
}

Konsol output: 256 Husk tildeling er fra højre mod venstre . Dette udtryk ( x = y = z) vil blive udført i trin:

• y = z, det er,y = 256
• x = y, det er,x = 256

Unære operatører.

De kaldes " unær " fra ordet " uno ", som betyder " en ". De fik dette navn, fordi de i modsætning til de tidligere operatører handler på et enkelt nummer, ikke flere. Disse omfatter:

• Unær minus. Det vender nummerets tegn.

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);
   }
}

Konsoludgang: -999 999 Vi brugte den unære minusoperator to gange. Som følge heraf var vores tal først negativt, og så blev det positivt igen!

• Forøg (++) og formindsk (--)

Operatøren ++øger et tal med én, og operatøren --reducerer et tal med det samme beløb.

public class Main {

   public static void main(String[] args) {

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

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

Konsol output: 1000 999 Denne notation kan være bekendt for dig, hvis du har hørt om C++ sproget. Dets skabere brugte dette interessante navn til at formidle ideen om, at "C++ er en udvidelse af C-sproget" En populær, forbedret version af Notesblok kaldes Notepad++ Her er en vigtig pointe. Der er to typer inkrement- og dekrementoperatorer: postfix og præfiks . x++- postfix ++x- præfiks Hvad er den grundlæggende forskel mellem at sætte plusser/minusser før eller efter tallet? Vi vil se i følgende eksempel:

public class Main {

   public static void main(String[] args) {

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

Konsoludgang: 999 Der er noget galt! Vi ønskede at øge xmed 1 og tildele den nye værdi til variablen y. Med andre ord skal y være 1000. Men i stedet får vi noget andet: 999. Det ser ud til, at x ikke er blevet øget, og at inkrementoperatoren ikke virkede? Men det virkede. For at overbevise dig selv, prøv at vise xtil sidst :)

public class Main {

   public static void main(String[] args) {

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

Konsoloutput: 999 1000 Faktisk er det netop derfor, denne operation kaldes postfix: den udføres efter hovedudtrykket. Dette betyder, i vores tilfælde: int y = x++; y = xudføres først (og variablen yvil blive initialiseret til værdien af x​​), og først derefter vil x++blive udført. Hvad hvis dette ikke er den adfærd, vi ønsker? Så skal vi bruge præfiksnotation :

public class Main {

   public static void main(String[] args) {

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

I dette tilfælde ++xbehandles først og først bagefter er y = x; henrettet. Du bør begå denne forskel til hukommelsen med det samme for at undgå at lave fejl i et rigtigt program, hvor brug af postfix i stedet for præfiks kunne vende op og ned på alt :)

Sammensatte operatører

Derudover er der i Java såkaldte sammensatte operatorer. De kombinerer to operatører:

• Opgave
• Aritmetiske operatorer

Disse omfatter:

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

Lad os overveje et eksempel:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

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

Konsoludgang: 1032 x += y betyder x = x + y. De to symboler bruges fortløbende for korthedens skyld. Kombinationerne -=, *=, /=og %=fungerer på samme måde.

Logiske operatører

Ud over numeriske operatorer har Java også operationer, der involverer booleske værdier ( sand og falsk ). Disse operationer udføres ved hjælp af logiske operatorer

• !- logisk IKKE . Det vender værdien af ​​en boolean

public class Main {

   public static void main(String[] args) {

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

Konsoloutput: falsk

• &&- logisk OG . Den returnerer kun sand, hvis begge operander er sande.

public class Main {

   public static void main(String[] args) {

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

Konsoloutput: falsk sand Resultatet af den første operation er falsk, fordi en af ​​operanderne er falsk, nemlig 100 > 200. For at returnere sand, &&kræver operatoren, at begge operander er sande (som det er tilfældet i anden linje).

• ||- logisk ELLER . Den returnerer sand, når mindst en af ​​operanderne er sand.

Når vi bruger denne operator, giver vores tidligere eksempel et andet resultat:

public class Main {

   public static void main(String[] args) {

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

Konsoloutput: sand Udtrykket 100 > 200er stadig falsk, men for OR- operatoren er det helt tilstrækkeligt, at den første del ( 100 > 10) er sand.