Operatori numerici în Java

Bună! Astăzi vom lua în considerare un subiect foarte important, și anume, operatorii numerici în Java . În programare, numerele sunt peste tot. Dacă săpați adânc și vă amintiți de liceu, vă puteți aminti că un computer reprezintă toate informațiile într-un format numeric: combinații de zerouri și unu, cunoscute și sub numele de cod binar. Există o mulțime de operatori numerici în programare, așa că vom folosi exemple pentru a-i explora pe cei mai importanți dintre ei :) Să începem cu cei mai simpli: operatori aritmetici . Aceștia sunt binecunoscuții operatori de adunare ( +), scădere ( -), înmulțire ( *) și împărțire ( /).

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

Ieșire consolă: 1032 966 32967 30 Ați folosit deja toate acestea. La acest grup, puteți adăuga la restul sau %operatorul modulo ( ).

public class Main {

   public static void main(String[] args) {

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

Ieșirea consolă: 1 În acest exemplu, împărțim 33 la 2. Rezultă 16, cu o „coadă” suplimentară (una) care nu este divizibilă cu 2. Această „coadă” este rezultatul operației „restul din divizare”. Java implementează și operatori de comparație/relaționali (la fel ca în matematică). Probabil că îți sunt familiari și de la școală:

• egal cu ( ==)
• mai mare decât ( >)
• mai putin de ( <)
• mai mare sau egal cu ( >=)
• mai mic sau egal cu ( <=)
• nu este egal ( !=)

Aici ar trebui să acordați atenție unui punct important care îi determină pe mulți începători să facă greșeli. Operatorul „egal” este scris ==, nu =. În Java, un singur =este operatorul de atribuire , care este utilizat atunci când unei variabile i se atribuie un număr, șir sau valoarea unei alte variabile.

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

Ieșire din consolă: 999 Hopa! Evident, acesta nu este rezultatul la care ne așteptam. Este un tip de date complet diferit: ne așteptam să vedem un boolean , dar am primit un număr. Totul pentru că am folosit un operator de atribuire în paranteze în loc de o comparație . x=y Valoarea lui y(999) a fost atribuită variabilei xși apoi am afișat valoarea lui x. Iată modul corect de a face acest lucru:

public class Main {

   public static void main(String[] args) {

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

Ieșire din consolă: false Acum am comparat corect cele două numere! :) Iată o altă caracteristică a operatorului de atribuire ( =): poate fi „înlănțuit” împreună:

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

Ieșire din consolă: 256 Amintiți-vă că atribuirea este de la dreapta la stânga . Această expresie ( x = y = z) va fi executată în pași:

• y = z, acesta este,y = 256
• x = y, acesta este,x = 256

Operatori unari.

Ele sunt numite „ unare ” din cuvântul „ uno ”, care înseamnă „ unul ”. Au primit acest nume pentru că, spre deosebire de operatorii anteriori, acţionează pe un singur număr, nu pe mai multe. Acestea includ:

• Minus unar. Întoarce semnul numărului.

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

Ieșire din consolă: -999 999 Am folosit operatorul unar minus de două ori. Drept urmare, numărul nostru a fost mai întâi negativ, apoi a devenit din nou pozitiv!

• Crește (++) și scade (--)

Operatorul ++mărește un număr cu unul, iar operatorul --reduce un număr cu aceeași sumă.

public class Main {

   public static void main(String[] args) {

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

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

Ieșire din consolă: 1000 999 Această notație vă poate fi familiară dacă ați auzit de limbajul C++. Creatorii săi au folosit acest nume interesant pentru a transmite ideea că „C++ este o extensie a limbajului C” O versiune populară îmbunătățită a Notepad se numește Notepad++. Iată un punct important. Există două tipuri de operatori de creștere și decreștere: postfix și prefix . x++- postfix ++x- prefix Care este diferența fundamentală între a pune plusurile/minusurile înainte sau după număr? Vom vedea în următorul exemplu:

public class Main {

   public static void main(String[] args) {

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

Ieșire consolă: 999 Ceva nu este în regulă! Am vrut să creștem xcu 1 și să atribuim noua valoare variabilei y. Cu alte cuvinte, y ar trebui să fie 1000. Dar în schimb obținem altceva: 999. Se pare că x nu a fost crescut și că operatorul de increment nu a funcționat? Dar a funcționat. Pentru a vă convinge, încercați să afișați xla sfârșit :)

public class Main {

   public static void main(String[] args) {

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

Ieșire consolă: 999 1000 De fapt, tocmai de aceea această operație se numește postfix: se realizează după expresia principală. Aceasta înseamnă, în cazul nostru: int y = x++; y = xeste executat mai întâi (și variabila yva fi inițializată la valoarea lui x), și abia apoi va x++fi executată. Ce se întâmplă dacă acesta nu este comportamentul pe care îl dorim? Apoi trebuie să folosim notația de prefix :

public class Main {

   public static void main(String[] args) {

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

În acest caz, ++xeste procesat mai întâi și numai după aceea este y = x; executat. Ar trebui să memorați imediat această diferență pentru a evita greșelile într-un program real în care folosirea postfixului în loc de prefix ar putea întoarce totul cu susul în jos :)

Operatori compuși

În plus, în Java există așa-numiții operatori compuși. Acestea combină doi operatori:

• Misiune
• Operatori aritmetici

Acestea includ:

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

Să luăm în considerare un exemplu:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

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

Ieșire consolă: 1032 x += y înseamnă x = x + y. Cele două simboluri sunt folosite consecutiv, de dragul conciziei. Combinațiile -=, *=, /=și %=funcționează într-un mod similar.

Operatori logici

Pe lângă operatorii numerici, Java are și operații care implică valori booleene ( adevărat și fals ). Aceste operații sunt efectuate folosind operatori logici

• !- NU logic . Întoarce valoarea unui boolean

public class Main {

   public static void main(String[] args) {

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

Ieșire din consolă: fals

• &&- ŞI logic . Returnează adevărat numai dacă ambii operanzi sunt adevărati.

public class Main {

   public static void main(String[] args) {

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

Ieșire consolă: false true Rezultatul primei operații este fals, deoarece unul dintre operanzi este fals și anume 100 > 200. Pentru a returna adevărat, &&operatorul necesită ca ambii operanzi să fie adevărati (cum este cazul în a doua linie).

• ||- SAU logic . Returnează adevărat atunci când cel puțin unul dintre operanzi este adevărat.

Când folosim acest operator, exemplul nostru anterior produce un rezultat diferit:

public class Main {

   public static void main(String[] args) {

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

Ieșire din consolă: true Expresia 100 > 200este încă falsă, dar pentru operatorul SAU este suficient ca prima parte ( 100 > 10) să fie adevărată.