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 (
!=
)
==
, 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 (--)
++
ø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 x
med 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 x
til 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 = x
udføres først (og variablen y
vil 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 ++x
behandles 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
+=
-=
*=
/=
%=
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.
public class Main {
public static void main(String[] args) {
System.out.println(100 > 10 || 100 > 200);
}
}
Konsoloutput: sand Udtrykket 100 > 200
er stadig falsk, men for OR- operatoren er det helt tilstrækkeligt, at den første del ( 100 > 10
) er sand.
GO TO FULL VERSION