שימוש ב- Not Operator בתנאי אם ב- Java

1. הקדמה

בהצהרות ה- if-else של Java אנו יכולים לנקוט בפעולה מסוימת כאשר ביטוי הוא נָכוֹן, ואלטרנטיבה כשזה כן שֶׁקֶר. במדריך זה נלמד כיצד להפוך את ההיגיון באמצעות ה- לֹא מַפעִיל.

2. ה אם-אחרת שהתבדלות

נתחיל בפשטות אחרת הַצהָרָה:

בוליאני isValid = נכון; אם (isValid) {System.out.println ("תקף"); } אחר {System.out.println ("לא חוקי"); }

מה אם התוכנית שלנו צריכה רק לטפל במקרה השלילי? כיצד נכתוב מחדש את הדוגמה שלעיל?

אפשרות אחת היא פשוט להסיר את הקוד ב- אם לַחסוֹם:

בוליאני isValid = נכון; אם (isValid) {} ​​אחר {System.out.println ("לא חוקי"); }

עם זאת, ריק אם נראה כי זה יכול להיות קוד לא שלם ונראה דרך ארוכת טווח לטיפול רק במצב השלילי. אולי ננסה לבדוק אם הביטוי ההגיוני שלנו מוערך שֶׁקֶר:

בוליאני isValid = נכון; אם (isValid == false) {System.out.println ("לא חוקי"); }

הגרסה הנ"ל קלה יחסית לקריאה, אם כי קשה יותר לעשות זאת אם הביטוי ההגיוני היה מורכב יותר. לג'אווה יש אלטרנטיבה מבחינתנו, בצורה של לֹא מַפעִיל:

בוליאני isValid = נכון; אם (! isValid) {System.out.println ("לא חוקי"); }

3. ה לֹא מַפעִיל

ה לֹא מפעיל הוא מפעיל לוגי, המיוצג ב- Java על ידי ה- ! סֵמֶל. זהו מפעיל אוחיד שלוקח ערך בוליאני כאופראנד שלו. ה לֹא המפעיל עובד על ידי היפוך (או שלילת) מערך האופראנד שלו.

3.1. החלת ה- לֹא מפעיל לערך בוליאני

כאשר הוא מוחל על ערך בוליאני, ה- לֹא מפעיל פונה נָכוֹן ל שֶׁקֶר ו שֶׁקֶר ל נָכוֹן.

לדוגמה:

System.out.println (! True); // מדפיס שקר System.out.println (! false); // מדפיס System.out.println נכון (!! false); // מדפיס שקר

3.2. החלת ה- לֹא מפעיל ביטוי בוליאני

מאז לֹא הוא מפעיל unary, כשאתה רוצה לֹא התוצאה של ביטוי, אתה צריך להקיף את הביטוי בסוגריים כדי לקבל את התשובה הנכונה. הביטוי בסוגריים מוערך תחילה ואז ה לֹא המפעיל הופך את התוצאה שלה.

לדוגמה:

ספירת int = 2; System.out.println (! (ספירה> 2)); // מדפיס System.out.println אמיתי (! (ספירה <= 2)); // מדפיס שקר
בוליאני x = נכון; בוליאני y = שקר; System.out.println (! (X && y)); // מדפיס System.out.println אמיתי (! (x || y)); // מדפיס שקר 

עלינו לציין שכאשר מבטלים ביטוי, חוקי דה מורגן נכנסים לפעולה. במילים אחרות, כל מונח בביטוי נשלל והמפעיל הפוך. זה יכול לעזור לנו לפשט ביטויים קשים יותר לקריאה.

לדוגמה:

! (x && y) זהה ל-! x || ! y! (x || y) זהה ל-! x &&! y! (a <3 && b == 10) זהה ל-> = 3 || ב! = 10 

4. כמה מלכודות נפוצות

משתמש ב לֹא לפעמים יכול המפעיל לסכן את הקריאות של הקוד שלנו. שליליות יכולות להיות קשות יותר להבנה מאשר חיוביות. בואו נסתכל על כמה דוגמאות.

4.1. שלילי כפול

בגלל ה לֹא אופרטור הוא אופרטור שלילה, המשתמש בו עם משתנים או פונקציות שיש להם שם שלילי, עלול לגרום לקושי לקריאה. הדבר דומה לשפות טבעיות, שם שליליות כפולות נחשבות לרוב כקשות להבנה.

לדוגמה:

אם (product.isActive ()) {...}

קורא טוב יותר מ

אם (! product.isNotActive ()) {...}

אמנם ה- API שלנו לא יכול לספק הוא פעיל בשיטה, אנו יכולים ליצור אחת שתעזור לקריאות.

4.2. תנאים מורכבים

ה לֹא לעתים יכול המפעיל להקשות ולהבין ביטוי מורכב כבר יותר. כשזה קורה, אנו יכולים לפשט את הקוד על ידי היפוך התנאי או על ידי חילוץ שיטות. בואו נסתכל על כמה דוגמאות לתנאים שהורכבו על ידי לֹא ואיך נוכל לפשט אותם על ידי ביטול התנאי:

if (! true) // Complex if (false) // Simplified if (! myDate.onOrAfter (anotherDate)) // Complex if (myDate.before (anotherDate)) // פשוט אם (! (a> = b)) // מורכב אם (a = 10 || סה"כ> = 1000)) // מורכב אם (ספירה <10 && סה"כ <1000) // פשוט

5. מסקנה

במאמר זה דנו ב לֹא מפעיל וכיצד ניתן להשתמש בו עם ערכים בוליאניים, ביטויים ו- אחרת הצהרות.

בדקנו גם כמה מלכודות נפוצות, הנגרמות על ידי כתיבת ביטויים הפוכים וכיצד לתקן אותן.

כמו תמיד קוד המקור לדוגמאות המשמשות במאמר זה זמין באתר GitHub.


$config[zx-auto] not found$config[zx-overlay] not found