Meniu

Afirmații în Java - Tutorial Java Asert cu exemple de cod

  • Principal
  • Alte
  • Afirmații în Java - Tutorial Java Asert cu exemple de cod

assertions java java assert tutorial with code examples

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acest tutorial Java Assert explică totul despre afirmații în Java. Veți învăța să activați și să dezactivați afirmații, cum să utilizați afirmații, să afirmați exemple etc.:

În tutorialele noastre anterioare, am discutat deja excepțiile în Java. Acestea sunt erorile care sunt surprinse în timpul rulării. Similar cu excepțiile, există și alte construcții pe care le putem folosi la compilare pentru a testa corectitudinea codului. Aceste construcții se numesc „afirmații”.

În acest tutorial, vom discuta în detaliu despre afirmațiile din Java. Putem defini o afirmație ca o construcție care ne permite să testăm corectitudinea sau claritatea ipotezelor pe care le-am făcut în programul nostru Java.

=> Consultați aici Ghidul pentru începători Java.

Afirmare în Java

Ce veți învăța:

Afirmații în Java

Astfel, atunci când executăm afirmația într-un program, se presupune că este adevărat. Dacă devine fals sau eșuează, atunci JVM va lansa un AssertionError.

Folosim afirmații în timpul dezvoltării în scopuri de testare. La runtime, afirmațiile sunt dezactivate de Java.

Cum diferă afirmațiile de excepțiile normale?

Spre deosebire de excepțiile normale, afirmațiile sunt utile în principal pentru a verifica situațiile logice dintr-un program despre care avem îndoieli. De asemenea, contrar excepțiilor normale care pot fi, de asemenea, aruncate în timpul rulării, afirmațiile sunt dezactivate în timpul rulării.

Afirmațiile pot fi folosite în locurile din cod în care dezvoltatorul are control maxim, așa cum pot fi utilizate ca parametri pentru metodele private. Afirmațiile pot fi folosite și în cazurile condiționate. În mod similar, condițiile de la începutul oricărei metode pot conține afirmații.

Cu toate acestea, afirmațiile nu trebuie luate ca înlocuitor pentru mesajele de eroare. Nici afirmațiile nu ar trebui utilizate în metode publice, de exemplu, pentru a verifica argumentele. Cel mai important, nu ar trebui să folosim afirmații pe argumentele din linia de comandă în Java.

În Java, afirmațiile sunt dezactivate în mod implicit. Deci, pentru ca afirmațiile să funcționeze într-un program Java, trebuie să activăm mai întâi afirmațiile.

Activați afirmațiile în Java

Pentru a activa afirmații, trebuie să o facem din linia de comandă.

Urmează sintaxa generală pentru activarea afirmării în Java.

java –ea: arguments

sau

java –enableassertions: arguments

De exemplu, putem activa afirmații pentru o anumită clasă, după cum se arată mai jos:

java –ea TestProgram

sau

java –enableassertions TestProgram

Aici, TestProgram este o clasă pentru care trebuie activată afirmația.

Când condiția este adevărată în afirmația asertă din program și afirmațiile sunt activate, atunci programul se va executa normal. Când condiția este falsă și afirmațiile sunt activate, atunci programul lansează AssertionError și programul se oprește.

Există diverse variante pentru activarea afirmațiilor folosind linia de comandă.

# 1) java –ea

Când comanda de mai sus este dată în linia de comandă, atunci afirmațiile sunt activate în toate clasele, cu excepția claselor de sistem.

#2) java –ea Main

Comanda de mai sus permite afirmarea pentru toate clasele din programul principal.

# 3) java –ea TestClass Main

Această comandă permite afirmații pentru o singură clasă - „TestClass” în programul principal.

# 4) java –ea com.packageName ... Main

Comanda de mai sus permite afirmarea pachetului com.packageName și a subpachetelor sale din programul Principal.

#5) java –ea … Main

Activează afirmarea pachetului fără nume din directorul de lucru curent.

# 6) java –esa: argumente SAU java –enablesystemassertions: argumente

Comanda de mai sus permite afirmații pentru clasele de sistem.

Dezactivarea afirmațiilor

De asemenea, putem dezactiva afirmațiile prin linia de comandă.

Sintaxa generală pentru a dezactiva afirmațiile în Java este:

java –da arguments

SAU

java –disableassertions arguments

În mod similar pentru a dezactiva afirmațiile din clasele de sistem, utilizăm următoarea sintaxă:

java – dsa: arguments

SAU

java –disablesystemassertions:arguments

„Afirmă” cuvânt cheie în Java

Limbajul Java oferă cuvântul cheie „afirmă” care permite dezvoltatorilor să verifice ipotezele pe care le-au făcut pentru program sau starea programului.

Deci putem folosi cuvântul cheie „asert” pentru a furniza afirmații în Java pentru a verifica condițiile care altfel ar putea împiedica funcționarea corectă a programului.

Cuvântul cheie „afirmă” este utilizat din Java 1.4, dar rămâne cuvântul cheie puțin cunoscut în Java. Când folosim cuvântul cheie assert în Java, trebuie să facem acest lucru într-o declarație Assert.

Afirmați declarația în Java

În Java, declarația de afirmare începe cu cuvântul cheie „asset” urmat de o expresie booleană.

Afirmația afirmă în Java poate fi scrisă în două moduri:

  1. afirmă exprimarea;
  2. afirmă expression1: expression2;

În ambele abordări, expresiile utilizate cu cuvântul cheie Assert sunt expresiile booleene.

Luați în considerare următoarea afirmație ca exemplu.

assert value >= 10 : “greater than 10”;

Aici, declarația de afirmare verifică dacă există o condiție și dacă condiția este adevărată, se imprimă un mesaj. Astfel, putem avea și afirmații cu mesajul nostru.

Cum se folosește Assert în Java

Până acum, am discutat cuvântul cheie și declarația afirmă în Java. Acum, să luăm în considerare un exemplu pentru a demonstra cum se folosește asert în Java.

Pentru a adăuga afirmații, trebuie să adăugăm pur și simplu o afirmație asertă după cum urmează:

public void setup_connetion () { Connection conn = getConnection (); assert conn != null; }

De asemenea, putem da afirmația de mai sus diferit, așa cum se arată mai jos:

public void setup_connection () { Connection conn = getConnection (); assert conn != null: “Connection is null”; }

Ambele construcții de cod de mai sus verifică dacă conexiunea returnează o valoare non-nulă. Dacă returnează o valoare nulă, atunci JVM va arunca o eroare - AssertionError. Dar în al doilea caz, un mesaj este furnizat în declarația assert, astfel încât acest mesaj va fi utilizat pentru a construi AssertionError.

În al doilea caz cu afirmații activate, excepția va arăta astfel:

Exception in thread 'main' java.lang.AssertionError: Connection is null at line numbers…

Afirmați exemplul în Java

Să implementăm un exemplu de utilizare a afirmațiilor în Java.

ce pot face cu c ++
public class Main { public static void main(String() args) { try { System.out.println('Testing Assertions...'); assert true : 'We don't see this.'; assert false : 'Visible if assertions are ON.'; } catch (AssertionError e) { e.printStackTrace(); } } }

Ieșire

Afirmați Exemplu în Java

Rezultatul de mai sus este dat atunci când afirmațiile nu sunt activate. Dacă afirmația a fost activată, atunci va fi afișat al doilea mesaj (afirmă fals).

Acum să demonstrăm un alt exemplu . Rețineți că aici am activat afirmația în Java pe mașina noastră unde rulăm acest program.

class Main { public static void main(String args()) { String() weekends = {'Friday', 'Saturday', 'Sunday'}; assert weekends.length == 2; System.out.println('We have ' + weekends.length + ' weekend days in a week'); } }

Ieșire

clasa publică Main

Întrucât durata weekend-ului nu se potrivește cu durata specificată în declarația asert, excepția de mai sus este aruncată. Dacă afirmația a fost dezactivată, atunci programul ar fi afișat mesajul specificat în locul afirmației excepție.

De ce sunt folosite afirmațiile în Java?

Folosim afirmații în programul nostru Java pentru a ne asigura că ipotezele pe care le-am făcut în programul nostru sunt corecte.

De exemplu, dacă vrem să ne asigurăm că codul care pare a fi inaccesibil este într-adevăr inaccesibil. Sau vrem să ne asigurăm că orice variabilă are o valoare într-un interval specificat.

Când facem o astfel de presupunere, oferim afirmații pentru a ne asigura că acestea sunt într-adevăr corecte.

întrebări frecvente

Q # 1) Afirmă aruncă o excepție Java?

Răspuns: Assert aruncă de obicei „AssertionError” atunci când presupunerea făcută este greșită. AssertionError se extinde din clasa Error (care se extinde în cele din urmă de la Throwable).

Q # 2) Ce se întâmplă atunci când o afirmare eșuează în Java?

Răspuns: Dacă afirmațiile sunt activate pentru programul în care afirmația eșuează, atunci va arunca AssertionError.

Î # 3) Ce revine o afirmare în Java?

Răspuns: O declarație asert declară o condiție booleană care se așteaptă să apară într-un program. Dacă această condiție booleană este evaluată ca fiind falsă, atunci se dă un AssertionError în timpul rulării, cu condiția ca afirmarea să fie activată.

Dacă presupunerea este corectă, atunci condiția booleană va reveni adevărată.

Î # 4) Putem detecta eroarea de afirmare?

Răspuns: AssertionError aruncată de instrucțiunea assert este o excepție necontrolată care extinde clasa Error. Astfel, afirmațiile nu sunt necesare pentru a le declara în mod explicit și, de asemenea, nu este nevoie să le încercați sau să le prindeți.

Q # 5) Cum afirmați o excepție?

Răspuns: Pentru a afirma o excepție declarăm un obiect al ExpectedException după cum urmează:

public ExpectedException exception = ExpectedException. nici unul ();

Apoi, folosim metodele de așteptat () și de așteptat mesaj () în metoda Test, pentru a afirma excepția și pentru a da mesajul de excepție.

Concluzie

Cu aceasta, am încheiat acest tutorial despre afirmații în Java. Am discutat despre definiția și scopul afirmațiilor în Java. Pentru a utiliza afirmația în programul Java trebuie să le permitem mai întâi să folosească linia de comandă.

Am explorat diferitele moduri prin care putem activa afirmații la nivel de program, la nivel de pachet, la nivel de director etc. Cuvintele cheie de afirmare și declarațiile de active ne ajută să folosim aserțiile.

Am văzut că o AssertionError este dată atunci când o afirmație eșuează. Afirmațiile în Java sunt utilizate în cea mai mare parte la compilare și sunt dezactivate în mod implicit la runtime.

Mai mult, afirmațiile sunt utilizate în cea mai mare parte în cadrul JUnit din Java, în care scriem cazurile de testare pentru testarea aplicațiilor.

=> Citiți seria Easy Training Java.

Lectură recomandată

^