Care sunt unele exemple din viața reală să înțeleagă rolul-cheie al afirmații?
Afirmațiile (cu titlu de susțin cuvinte cheie) a fost adăugat în Java 1.4. Acestea sunt utilizate pentru a verifica corectitudinea unui invariant în cod. Ei n-ar fi declanșat în codul de producție, și indică o eroare sau abuz de o cale de cod. Ele pot fi activate la run-time prin -ea
opțiune java
comanda, dar nu sunt activate implicit.
Un exemplu:
public Foo acquireFoo(int id) {
Foo result = null;
if (id > 50) {
result = fooService.read(id);
} else {
result = new Foo(id);
}
assert result != null;
return result;
}
Las's presupune că ar trebui să scrie un program pentru a controla o putere nucleară-plantă. Este destul de evident că, chiar și cea mai mică greșeală ar putea avea rezultate catastrofale, prin urmare, codul trebuie bug-free (presupunând că JVM este bug-free, de dragul argumentului).
Java nu este un verificabile limbă, ceea ce înseamnă: nu se poate calcula că rezultatul de operare va fi perfect. Principalul motiv pentru acest lucru sunt indicii: ele pot punctul de oriunde sau nicăieri, prin urmare, acestea nu pot fi calculate pentru a fi de această valoare exactă, cel puțin nu într-un interval rezonabil de cod. Având în vedere această problemă, nu există nici o modalitate de a dovedi că codul este corect la un întreg. Dar ce poți să faci este să dovedească faptul că cel puțin găsi orice bug atunci când se întâmplă.
Această idee se bazează pe Design-prin-Contract (DbC), paradigma: mai întâi să definiți (cu precizie matematică) ce metodă ar trebui să facă, și apoi verificați acest lucru prin testarea timpul efectiv de execuție. Exemplu:
// Calculates the sum of a (int) + b (int) and returns the result (int).
int sum(int a, int b) {
return a + b;
}
În timp ce acest lucru este destul de evident pentru a lucra bine, majoritatea programatorilor nu va vedea bug ascunse în interiorul acestui o (indiciu: Ariane V-a prăbușit din cauza unei similar bug). Acum DbC definește pe care trebuie să always verificați de intrare și de ieșire de o funcție pentru a verifica dacă acesta a lucrat corect. Java poate face acest lucru prin afirmații:
// Calculates the sum of a (int) + b (int) and returns the result (int).
int sum(int a, int b) {
assert (Integer.MAX_VALUE - a >= b) : "Value of " + a + " + " + b + " is too large to add.";
final int result = a + b;
assert (result - a == b) : "Sum of " + a + " + " + b + " returned wrong sum " + result;
return result;
}
Acest lucru ar trebui să funcționeze acum greș niciodată, te va observa. Veți ști că există o problemă în codul tău, știi unde este și știi ce a cauzat-o (similar cu Excepții). Și ceea ce este chiar mai important: ai oprit de executare chiar atunci când se întâmplă să prevină orice altă cod pentru a lucra cu valori greșite și ar putea provoca daune de orice control.
Java Excepții sunt un concept similar, dar ei nu reușesc să verifice totul. Dacă vrei chiar mai multe controale (la costul de viteza de executie) trebuie să utilizeze afirmații. Făcând astfel, vă va umfla codul dvs., dar puteți în sfârșit să livreze un produs de la o surprinzător de scurt timpul de dezvoltare (mai devreme de a repara un bug, reducerea costurilor). Și în plus: dacă există orice bug-uri în interiorul codului, va detecta. Nu există nici un fel de bug alunecarea-prin și de a provoca probleme mai târziu.
Acest lucru încă nu este o garanție pentru bug-cod gratuit, dar este mult mai aproape de asta, decât de obicei programe.
Afirmațiile sunt de o dezvoltare-faza de instrument pentru a prinde bug-uri în cod. Ei're proiectat pentru a fi ușor de îndepărtat, astfel încât ele să't există în codul de producție. Astfel de afirmații nu fac parte din "soluție" pe care le livra la client. Ei're verificări interne pentru a se asigura că ipotezele te're face sunt corecte. Cel mai comun exemplu este de a testa pentru nulă. Multe metode sunt scrise astfel:
void doSomething(Widget widget) {
if (widget != null) {
widget.someMethod(); // ...
... // do more stuff with this widget
}
}
De foarte multe ori într-o metodă de genul asta, widget-ul ar trebui să pur și simplu nu fie null. Deci, dacă-l's nul, nu's un bug în codul de undeva de care aveți nevoie pentru a urmări în jos. Dar codul de mai sus nu vă va spune acest lucru. Deci, într-un bine-intentionate efort pentru a scrie "sigur" codul, te're ascunde, de asemenea, un bug. L's mult mai bine să scrie cod de genul:
/**
* @param Widget widget Should never be null
*/
void doSomething(Widget widget) {
assert widget != null;
widget.someMethod(); // ...
... // do more stuff with this widget
}
În acest fel, veți fi sigur de a prinde acest bug devreme. (It's, de asemenea, util să se precizeze în contract că acest parametru nu ar trebui să fie nulă.) Fi sigur de a transforma afirmațiile pe când testați codul timpul de dezvoltare. (Și convinge colegii dvs. pentru a face acest lucru, este de multe ori dificil, care mi se pare foarte enervant.)
Acum, unii dintre colegii dumneavoastră va obiecta la acest cod, argumentând că ar trebui să pună în continuare în nul verificați pentru a preveni o excepție în producție. În acest caz, afirmația este încă util. Poti scrie asa:
void doSomething(Widget widget) {
assert widget != null;
if (widget != null) {
widget.someMethod(); // ...
... // do more stuff with this widget
}
}
În acest fel, colegii tăi vor fi fericiți că cec nul este acolo pentru codul de producție, dar în perioada de dezvoltare, ai're nu se mai ascund bug-ul atunci când widget este nul.
Aici's un exemplu din lumea reală: am scris odată o metodă care a comparat două valori arbitrare pentru egalitate, în cazul în care oricare valoare ar fi zero:
/**
* Compare two values using equals(), after checking for null.
* @param thisValue (may be null)
* @param otherValue (may be null)
* @return True if they are both null or if equals() returns true
*/
public static boolean compare(final Object thisValue, final Object otherValue) {
boolean result;
if (thisValue == null) {
result = otherValue == null;
} else {
result = thisValue.equals(otherValue);
}
return result;
}
Acest cod de delegați activitatea este egal cu () metoda în cazul în care thisValue nu este null. Dar se presupune
este egal cu()metoda corect îndeplinește contractul de
equals()` de manipulare în mod corespunzător un parametru nule.
Un coleg de obiectat la codul meu, spunându-mi că multe dintre clasele noastre au buggy este egal cu()
metode care don'testul t pentru null, așa că ar trebui să pune cecul în această metodă. L's discutabil dacă acest lucru este înțelept, sau dacă ar trebui să-forța de eroare, astfel încât să putem fața locului și să o repari, dar m-am lăsat pe colegul meu și a pus într-o verificare nul, pe care am'am marcat cu un comentariu:
public static boolean compare(final Object thisValue, final Object otherValue) {
boolean result;
if (thisValue == null) {
result = otherValue == null;
} else {
result = otherValue != null && thisValue.equals(otherValue); // questionable null check
}
return result;
}
La verificare suplimentara, pentru alte != nul, este necesar doar dacă
este egal cu()` metoda nu reușește să caute null cum prevede contractul.
Mai degrabă decât se angajeze într-o dezbatere sterilă cu colegul meu despre înțelepciunea de a lăsa buggy codul de ședere în codul nostru de bază, pur și simplu am pus două afirmații în cod. Aceste afirmații vor să-mi spuneți, în timpul fazei de dezvoltare, dacă unul dintre cursurile noastre nu reușește să pună în aplicare este egal cu()
în mod corespunzător, așa că am poate repara:
public static boolean compare(final Object thisValue, final Object otherValue) {
boolean result;
if (thisValue == null) {
result = otherValue == null;
assert otherValue == null || otherValue.equals(null) == false;
} else {
result = otherValue != null && thisValue.equals(otherValue);
assert thisValue.equals(null) == false;
}
return result;
}
Cele mai importante puncte pentru a păstra în minte sunt urmatoarele:
Afirmațiile sunt de dezvoltare-faza de instrumente numai.
Punctul de a face o afirmație este să știi dacă nu's un bug, nu doar în cod, dar în cod de bază. (Afirmațiile aici este, de fapt steagul bug-uri în alte clase.)
Chiar dacă colegul meu a fost încrezător că cursurile noastre au fost în mod corespunzător în scris, afirmațiile aici ar fi încă utilă. Noi clase va fi de adăugat că ar putea eșua pentru a testa pentru nulă, și această metodă poate steag aceste bug-uri pentru noi.
În dezvoltare, ar trebui să rândul său, întotdeauna afirmații, chiar dacă codul'am scris nu't folosi afirmații. Mi IDE este setat la întotdeauna face acest lucru în mod implicit pentru orice executabil nou.
Afirmațiile don't schimba comportamentul codul în producție, astfel încât colegul meu este fericit că cec nul este acolo, și că această metodă va executa în mod corespunzător, chiar dacă este egal cu()
metoda este buggy. Am'm fericită că mă va prinde orice buggy `este egal cu () metoda în dezvoltare.
De asemenea, ar trebui să testați afirmare politică de a pune într-o temporar afirmația că nu va reuși, astfel încât să puteți fi sigur că vă sunt notificate, fie prin fișier jurnal sau un stack trace în fluxul de ieșire.
O mulțime de răspunsuri bune, explicând ce afirma
cuvinte cheie, dar câteva răspunde la întrebarea, "atunci când ar trebui să-și afirme` cuvinte cheie fi folosite în viața reală?"
Răspunsul: aproape niciodată.
Afirmații, ca și concept, sunt minunate. Bun cod are o mulțime de dacă (...) arunca ... declarațiile (și rudele lor ca Obiecte.requireNonNull " și " Matematica.addExact
). Cu toate acestea, anumite decizii de design au limitat mult utilitatea afirma
cuvinte cheie în sine.
Ideea de conducere spatele afirma
cheie este prematur de optimizare, iar principala caracteristică este posibilitatea de a transforma cu ușurință de pe toate verificările. În fapt, afirma
controalele sunt dezactivate în mod implicit.
Cu toate acestea, este extrem de important ca invariant controalele continua să fie făcut în producție. Acest lucru este perfect pentru testul de acoperire este imposibil, și tot codul de producție va avea bug-uri care afirmații ar trebui să ajute pentru a diagnostica și de a o atenua.
Prin urmare, utilizarea de dacă (...) arunca ...
ar trebui să fie de preferat, doar cât este necesar pentru verificarea valorilor parametrilor de metode publice și pentru a arunca cu IllegalArgumentException`.
Ocazional, s-ar putea fi tentat să scrie un invariant a verifica că nu ia un nedorit lungă perioadă de timp pentru a procesa (și este numit de multe ori suficient pentru ca acesta să conteze). Cu toate acestea, astfel de controale vor încetini de testare, care este, de asemenea, nedorite. Astfel de consumatoare de timp controale sunt, de obicei scris ca unitate de teste. Cu toate acestea, uneori poate face sens pentru a utiliza afirma
pentru acest motiv.
A nu se folosi afirma
pur și simplu pentru că este mai curată și mai frumoasă decât dacă (...) arunca ...(si o spun cu mare durere, pentru că îmi place curat și frumos). Dacă tu chiar nu se poate ajuta singur, și puteți controla modul în care este lansată aplicația, atunci nu ezitați să utilizați
afirmadar **activați întotdeauna afirmații în producție.** Desigur, acest lucru este ceea ce am tendința de a face. Sunt presiuni pentru o lombok adnotare, care va provoca
afirmasă acționeze mai mult ca
dacă (...) arunca ...`. Votez pentru ea aici.
(Rant: JVM devs au fost o grămadă de groaznic, prematur optimizarea programatori. Asta este ce ai auzit despre atât de multe probleme de securitate în Java plugin și JVM. Ei au refuzat să includă verificări de bază și afirmațiile cuprinse în codul de producție, și vom continua să plătească prețul.)
Aici's cel mai comun caz de utilizare. Să presupunem că ai're de comutare într-o enumerare valoare:
switch (fruit) {
case apple:
// do something
break;
case pear:
// do something
break;
case banana:
// do something
break;
}
Atâta timp cât voi ocupa de fiecare caz,'re bine. Dar într-o zi, cineva va adăuga fig ta enum și uitați să adăugați-l la switch. Aceasta produce un bug care poate obține complicat pentru a prinde, pentru că efectele câștigat't fi simțit până după tine'am plecat de la switch. Dar dacă ai scrie comutator de genul asta, puteți să-l prinde imediat:
switch (fruit) {
case apple:
// do something
break;
case pear:
// do something
break;
case banana:
// do something
break;
default:
assert false : "Missing enum value: " + fruit;
}
Afirmațiile sunt utilizate pentru a verifica post-condiții și "ar trebui să nu reușesc" pre-condiții. Codul corect ar trebui să nu reușesc o afirmație; atunci când se declanșează, acestea ar trebui să indice o problemă (să sperăm că într-un loc care este aproape de locul unde efectiv locus de problema).
Un exemplu de afirmație ar putea fi pentru a verifica faptul că un anumit grup de metode este numit în ordinea corectă (de exemplu, că hasNext()
este numit înainte de următoarea()într-un
Iterator`).
Ce înseamnă a afirma cuvinte cheie în Java face?
Să's se uite la bytecode compilat.
Vom concluziona că:
public class Assert {
public static void main(String[] args) {
assert System.currentTimeMillis() == 0L;
}
}
generează aproape exact același bytecode ca:
public class Assert {
static final boolean $assertionsDisabled =
!Assert.class.desiredAssertionStatus();
public static void main(String[] args) {
if (!$assertionsDisabled) {
if (System.currentTimeMillis() != 0L) {
throw new AssertionError();
}
}
}
}
unde se Afirme.clasa.desiredAssertionStatus () "este" adevărat "când" - ea` este trecut pe linia de comandă, și false în caz contrar.
Vom folosi Sistemul.currentTimeMillis()pentru a se asigura că nu va't obține optimizat departe (
afirma adevărat;` a făcut).
Sintetic câmp este generat astfel încât Java are nevoie doar să se Afirme.clasa.desiredAssertionStatus()` o dată la timpul de încărcare, și apoi cache rezultatul de acolo. Vezi de asemenea și: https://stackoverflow.com/questions/5223268/what-is-the-meaning-of-static-synthetic
Putem verifica asta cu:
javac Assert.java
javap -c -constants -private -verbose Assert.class
Cu Oracle JDK 1.8.0_45, o sinteză static domeniu a fost generat (a se vedea, de asemenea,: https://stackoverflow.com/questions/5223268/what-is-the-meaning-of-static-synthetic):
static final boolean $assertionsDisabled;
descriptor: Z
flags: ACC_STATIC, ACC_FINAL, ACC_SYNTHETIC
împreună cu o inițializare statică:
0: ldc #6 // class Assert
2: invokevirtual #7 // Method java/lang Class.desiredAssertionStatus:()Z
5: ifne 12
8: iconst_1
9: goto 13
12: iconst_0
13: putstatic #2 // Field $assertionsDisabled:Z
16: return
și principala metodă este:
0: getstatic #2 // Field $assertionsDisabled:Z
3: ifne 22
6: invokestatic #3 // Method java/lang/System.currentTimeMillis:()J
9: lconst_0
10: lcmp
11: ifeq 22
14: new #4 // class java/lang/AssertionError
17: dup
18: invokespecial #5 // Method java/lang/AssertionError."<init>":()V
21: athrow
22: return
Putem concluziona că:
afirma
: ea este un Java limba conceptafirma
ar putea fi imitat destul de bine cu proprietăți sistem -Mocf.mine.afirma=true
pentru a înlocui -ea
pe linia de comandă, și o arunca noi AssertionError()`.O afirmație permite detectarea defectelor în cod. Puteți apela la afirmații de testare și depanare, lăsându-le stinge atunci când programul este în producție.
De ce afirmi ceva atunci când știi că este adevărat? Este adevărat numai atunci când totul este de lucru în mod corespunzător. Dacă programul are un defect, acesta nu ar putea fi de fapt adevărat. Detectarea asta mai devreme în procesul vă permite să știți ceva este în neregulă.
O afirma
declarație conține această declarație, împreună cu un opțional "String" mesaj.
Sintaxa pentru o afirma declarație are două forme:
assert boolean_expression;
assert boolean_expression: error_message;
Iată câteva reguli de bază care guvernează în cazul în care afirmațiile ar trebui să fie utilizate și în cazul în care acestea nu ar trebui să fie utilizate. Afirmațiile ar trebui să fie utilizate pentru:
Validarea parametrilor de intrare de o metodă privat. NU pentru metodele publice. "public" metode ar trebui să arunce regulate și excepții, atunci când a trecut de rău parametri.
Oriunde în program pentru a se asigura validitatea unui fapt care este aproape cu siguranță adevărat.
De exemplu, dacă sunteți sigur că acesta va fi doar 1 sau 2, puteți folosi o afirmație ca aceasta:
...
if (i == 1) {
...
}
else if (i == 2) {
...
} else {
assert false : "cannot happen. i is " + i;
}
...
Afirmațiile nu trebuie fi utilizate pentru:
Validarea parametrilor de intrare de o metodă publică. Din afirmații nu pot fi întotdeauna executate, regulat excepție mecanism ar trebui să fie utilizate.
Validarea constrângerile pe ceva care este introdus de utilizator. La fel ca mai sus.
Nu ar trebui să fie utilizate pentru efecte secundare.
De exemplu, aceasta nu este o utilizare corectă, pentru că aici afirmația este folosit pentru sale de efect secundar de asteptare a `doSomething () metodă.
public boolean doSomething() {
...
}
public void someMethod() {
assert doSomething();
}
Singurul caz în care aceasta ar putea fi justificată este atunci când sunteți încercarea de a afla dacă este sau nu afirmațiile sunt activate în cod:
boolean enabled = false;
assert enabled = true;
if (enabled) {
System.out.println("Assertions are enabled");
} else {
System.out.println("Assertions are disabled");
}
În plus față de toate marile răspunsuri oferite aici, oficial Java SE 7 ghid de programare are o destul de concis manual folosind afirma
; cu mai multe spot-on exemple de când l's un bun (și, mai important, de rău) ideea de a folosi afirmații, și cum l's diferite de aruncare excepții.
Afirma este foarte util atunci când în curs de dezvoltare. Utilizați-l atunci când ceva nu se poate se întâmple în cazul în care codul este de lucru corect. L's ușor de utilizat, și poate rămâne în cod pentru totdeauna, pentru că acesta va fi oprit în viața reală.
Dacă nu există nici o șansă că această condiție poate apărea în viața reală, atunci trebuie să-l ocupe.
Îmi place, dar nu't știu cum să-l activați în Eclipsă/Android/ADT . Se pare a fi, chiar și atunci când depanare. (Exista un thread pe aceasta, dar ea se referă la 'Java vm', care nu apar în ADT Rula de Configurare).
Aici's o afirmație am scris într-un server pentru o Hibernare/SQL proiect. O entitate de fasole avut două eficient-proprietăți boolean, numit isActive și isDefault. Fiecare ar putea avea o valoare de "Y" sau "N" sau nul, care a fost tratată ca "N". Vrem să vă asigurați că browser-ul client este limitată la aceste trei valori. Deci, din punctul meu setteri pentru aceste două proprietăți, am adăugat această afirmație:
assert new HashSet<String>(Arrays.asList("Y", "N", null)).contains(value) : value;
Observați următoarele.
Această afirmație este pentru faza de dezvoltare numai. Dacă clientul trimite un rău valoare, ne va prinde atât de devreme și de a-l repara, cu mult înainte de a ajunge la producție. Afirmațiile sunt pentru defectele pe care le poate prinde mai devreme.
Această afirmație este lentă și ineficientă. Ca's bine. Afirmațiile sunt gratuite pentru a fi lent. Am don't de îngrijire pentru ei're de dezvoltare-doar instrumente. Asta nu't încetini producția de cod pentru afirmațiile va fi dezactivat. (Nu's un dezacord cu privire la acest punct, pe care am'o s-o mai târziu.) Acest lucru duce la următorul punct.
Această afirmație nu are efecte secundare. Am putea-am testat valoarea mea împotriva unui unmodifiable static final de Set, dar că ar fi rămas în producție, în cazul în care ar obișnui niciodată.
Această afirmație există pentru a verifica funcționarea corectă a clientului. Deci, până când vom ajunge la producție, vom fi sigur de faptul că clientul este de operare în mod corespunzător, astfel încât să putem transforma în condiții de siguranță afirmația off.
Unii oameni întreabă: Dacă afirmația este't de necesar în procesul de producție, de ce nu le-a luat când te - 're face? Pentru că tu'll încă nevoie de ele atunci când veți începe de lucru pe urmatoarea versiune.
Unii oameni au susținut că nu ar trebui să folosească afirmații, pentru că niciodată nu poți fi sigur că toate bug-uri au dispărut, astfel încât aveți nevoie pentru a le menține în jurul valorii de, chiar și în producție. Și așa nu's nici un punct în utilizarea afirma declarație, deoarece singurul avantaj de a susține este că puteți să le dezactivați. Prin urmare, potrivit acestei gândiri, tu ar trebui să (aproape) nu folosiți niciodată afirmă. Nu sunt de acord. L's cu siguranță adevărat că, dacă un test aparține în producție, nu ar trebui să utilizați o afirme. Dar acest test nu nu fac parte din producție. Aceasta este pentru a prinde un bug care'nu s-ar mai putea ajunge la producție, astfel încât acesta poate fi în condiții de siguranță oprit atunci când te're făcut.
BTW, am putea fi scris astfel:
assert value == null || value.equals("Y") || value.equals("N") : value;
Acest lucru este bine pentru doar trei valori, dar dacă numărul de valori posibile devine mai mare, HashSet versiune devine mai convenabil. Am ales HashSet versiune pentru a face punctul meu de vedere despre eficiența.
Afirmație sunt de fapt folosite pentru a depana aplicația sau este folosit ca înlocuitor de manipulare excepție pentru unele aplicații pentru a verifica validitatea cererii.
Afirmația lucrează la timp a alerga. Un exemplu simplu, care poate explica întregul concept foarte simplu, este aici - Ce afirma cheie face în Java? (WikiAnswers).
Afirmațiile sunt dezactivate în mod implicit. Pentru a le permite acestora trebuie să rulați programul cu -ea
opțiuni (granularitatea pot fi variate). De exemplu, java -ea AssertionsDemo
.
Există două formate pentru utilizarea afirmații:
afirme 1==2; // Acest lucru va ridica o AssertionError
.afirme 1==2: "nici un fel.. 1 nu este egal cu 2";
Acest lucru va ridica o AssertionError cu mesajul dat afișat prea și este astfel mai bine. Deși real sintaxa este `afirma expr1:expr2 unde expr2 pot fi orice expresie întoarce o valoare, eu am folosit mai multe ori doar pentru a imprima un mesaj.Să recapitulăm (și acest lucru este adevărat în multe limbi, nu doar Java):
"afirma" este utilizat în principal ca un depanare ajutor de către dezvoltatorii de software în timpul procesului de depanare. Afirma-mesaje nu ar trebui să apară. Multe limbi oferi o compilare-timp opțiune care va provoca toate "afirmă" pentru a fi ignorat, pentru utilizare în generarea de "producție" cod.
"excepții" sunt o modalitate la îndemână să se ocupe de toate tipurile de condiții de eroare, dacă este sau nu reprezintă erori logice, pentru că, dacă tu a alerga într-o eroare, condiție care nu puteți continua, puteți pur și simplu "arunca-le în sus, în aer," de la oriunde vă aflați, așteaptă cineva acolo pentru a fi gata pentru a "prins" le. Controlul este transferat într-un singur pas, direct din cod care a aruncat o excepție, direct la catcher's mitt. (Și catcher poate vedea complet backtrace de apeluri care au avut loc.)
De asemenea, apelanții de la care subrutină don't trebuie să verificați pentru a vedea dacă subrutina reușit: "dacă ne-am're aici, acum, trebuie să fi reușit, pentru că altfel nu ar fi aruncat o excepție și nu ne-ar't fi aici, acum!" Această strategie simplă face-cod de proiectare și depanare mult, mult mai ușor.
Excepții convenabil permite fatal error condiții pentru a fi ceea ce sunt: "excepții de la regulă." Si, pentru ca acestea să fie gestionate de un cod-calea, care este, de asemenea, "o excepție de la regula ... "minge!"
Afirmațiile sunt verificări care poate fi oprit. Ei're rar folosit. De ce?
Deci, ceea ce's a plecat? Scump controale pentru condiții foarte temperatura să fie adevărat. Un exemplu bun ar fi invarianților de o structură de date ca RB-copac. De fapt, în ConcurrentHashMap
de JDK8, există câteva astfel de semnificative afirmă pentru TreeNodes
.
Uneori, verificarea nu este foarte scump, dar, în același timp, te're destul de sigur, l'll pass. În codul meu, acolo's, de exemplu,
assert Sets.newHashSet(userIds).size() == userIds.size();
în cazul în care nu'm destul de sigur că lista pe care am creat doar are elemente unice, dar am vrut să documenteze și să verificați-l.
De fapt, "afirma adevărat" va trece și "afirma false" va eșua. Las's se uită la cum va funcționa:
public static void main(String[] args)
{
String s1 = "Hello";
assert checkInteger(s1);
}
private static boolean checkInteger(String s)
{
try {
Integer.parseInt(s);
return true;
}
catch(Exception e)
{
return false;
}
}
susțin
este un cuvânt cheie. Acesta a fost introdus în JDK 1.4. Sunt două tipuri de `afirma e
afirma
declarațiiafirma
declarații.În mod implicit toate afirma
declarații nu va fi executat. Dacă o afirma
declarație primește fals, atunci acesta se va ridica automat o afirmație de eroare.