Numeriske operatorer i Java

Hei! I dag skal vi vurdere et veldig viktig emne, nemlig numeriske operatorer i Java . I programmering er tall overalt. Hvis du graver dypt og husker videregående, kan du huske at en datamaskin representerer all informasjon i et numerisk format: kombinasjoner av nuller og enere, også kjent som binær kode. Det er mange numeriske operatorer i programmering, så vi skal bruke eksempler for å utforske de viktigste av dem :) La oss starte med det enkleste: aritmetiske operatorer . Dette er de velkjente operatorene addisjon ( +), subtraksjon ( -), multiplikasjon ( *) og divisjon ( )./

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

Konsollutgang: 1032 966 32967 30 Du har allerede brukt alt dette. Til denne gruppen kan du legge til resten eller modulo ( %) operatoren.

public class Main {

   public static void main(String[] args) {

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

Konsollutgang: 1 I dette eksemplet deler vi 33 med 2. Dette gir 16, med en ekstra "hale" (en) som ikke er delelig med 2. Denne "halen" er resultatet av operasjonen "resten fra divisjon". Java implementerer også sammenlignings-/relasjonsoperatorer (akkurat som i matematikk). De er sikkert kjent for deg fra skolen også:

• lik ( ==)
• større enn ( >)
• mindre enn ( <)
• større enn eller lik ( >=)
• mindre enn eller lik ( <=)
• ikke lik ( !=)

Her bør du ta hensyn til ett viktig punkt som får mange nybegynnere til å gjøre feil. Operatoren "lik" er skrevet ==, ikke =. =I Java er en singel tilordningsoperatøren , som brukes når en variabel tildeles et tall, en streng eller verdien til en annen 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
   }
}

Konsollutgang: 999 Oops! Dette er åpenbart ikke resultatet vi forventet. Det er en helt annen datatype: vi forventet å se en boolsk , men vi fikk et tall. Alt fordi vi brukte en tilordningsoperator i parentes i stedet for en sammenligning . x=y Verdien av y(999) ble tildelt variabelen x, og deretter viste vi verdien av x. Her er den riktige måten å gjøre det på:

public class Main {

   public static void main(String[] args) {

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

Konsoll utgang: usant Nå har vi sammenlignet de to tallene riktig! :) Her er en annen funksjon ved oppdragsoperatøren ( =): den kan "lenkes" 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);
   }
}

Konsoll utgang: 256 Husk tildeling er fra høyre til venstre . Dette uttrykket ( x = y = z) vil bli utført i trinn:

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

Unære operatører.

De kalles " unær " fra ordet " uno ", som betyr " en ". De fikk dette navnet fordi de, i motsetning til de tidligere operatørene, handler på et enkelt nummer, ikke flere. Disse inkluderer:

• Unært minus. Den snur tallets 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);
   }
}

Konsollutgang: -999 999 Vi brukte den unære minusoperatoren to ganger. Som et resultat var tallet vårt først negativt, og så ble det positivt igjen!

• Øk (++) og reduser (--)

Operatøren ++øker et tall med én, og operatøren --reduserer et tall med samme beløp.

public class Main {

   public static void main(String[] args) {

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

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

Konsollutgang: 1000 999 Denne notasjonen kan være kjent for deg hvis du har hørt om C++-språket. Skaperne brukte dette interessante navnet for å formidle ideen om at "C++ er en utvidelse av C-språket" En populær forbedret versjon av Notepad kalles Notepad++ Her er et viktig poeng. Det finnes to typer inkrement- og dekrementoperatorer: postfix og prefix . x++- postfix ++x- prefiks Hva er den grunnleggende forskjellen mellom å sette pluss/minus foran eller etter 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);
   }
}

Konsollutgang: 999 Noe er feil! Vi ønsket å øke xmed 1 og tilordne den nye verdien til variabelen y. Med andre ord skal y være 1000. Men i stedet får vi noe annet: 999. Det virker som om x ikke ble økt og at inkrementoperatoren ikke fungerte? Men det fungerte. For å overbevise deg selv, prøv å vise xpå slutten :)

public class Main {

   public static void main(String[] args) {

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

Konsollutgang: 999 1000 Faktisk er det nettopp derfor denne operasjonen kalles postfix: den utføres etter hoveduttrykket. Dette betyr, i vårt tilfelle: int y = x++; y = xutføres først (og variabelen yvil bli initialisert til verdien av x), og først deretter vil x++bli utført. Hva om dette ikke er oppførselen vi ønsker? Da må vi bruke prefiksnotasjon :

public class Main {

   public static void main(String[] args) {

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

I dette tilfellet ++xbehandles først og først etterpå er y = x; henrettet. Du bør legge inn denne forskjellen i minnet med en gang for å unngå å gjøre feil i et ekte program der bruk av postfix i stedet for prefiks kan snu alt på hodet :)

Sammensatte operatører

I tillegg er det i Java såkalte sammensatte operatorer. De kombinerer to operatører:

• Oppdrag
• Aritmetiske operatorer

Disse inkluderer:

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

La oss vurdere et eksempel:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

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

Konsollutgang: 1032 x += y betyr x = x + y. De to symbolene brukes fortløpende for korthets skyld. Kombinasjonene -=, *=, /=og %=fungerer på lignende måte.

Logiske operatører

I tillegg til numeriske operatorer har Java også operasjoner som involverer boolske verdier ( sann og usann ). Disse operasjonene utføres ved hjelp av logiske operatorer

• !- logisk IKKE . Det snur verdien av en boolsk

public class Main {

   public static void main(String[] args) {

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

Konsollutgang: usann

• &&- logisk OG . Den returnerer bare sant hvis begge operandene er sanne.

public class Main {

   public static void main(String[] args) {

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

Konsollutgang: usann sann Resultatet av den første operasjonen er usann, fordi en av operandene er falsk, nemlig 100 > 200. For å returnere sant, &&krever operatøren at begge operandene er sanne (som tilfellet er på den andre linjen).

• ||- logisk ELLER . Den returnerer sann når minst én av operandene er sann.

Når vi bruker denne operatoren, gir vårt forrige eksempel et annet resultat:

public class Main {

   public static void main(String[] args) {

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

Konsollutdata: true Uttrykket 100 > 200er fortsatt usant, men for OR- operatoren er det helt tilstrekkelig at den første delen ( 100 > 10) er sann.