? Java

Document Sample
? Java Powered By Docstoc
					                                                                 ‫סיכום לקראת מבחן טרימסטר א‬
                                                                         ‫טיפוסי משתנים ו-‪literals‬‬
     ‫‪Datatype‬‬           ‫)‪width(bits‬‬      ‫‪Min value‬‬                                ‫‪Wrapper class‬‬
                                         ‫‪Max value‬‬
‫1‬    ‫‪boolean‬‬                    ‫‪NA‬‬       ‫‪true, false‬‬                              ‫‪Boolean‬‬
‫2‬    ‫‪byte‬‬                        ‫8‬       ‫1- 72 ,72-‬                               ‫‪Byte‬‬
‫3‬    ‫‪short‬‬                      ‫61‬       ‫1 - 512 ,512-‬                            ‫‪Short‬‬
‫4‬    ‫‪char‬‬                       ‫61‬       ‫‪0x0, 0xffff [must be is single‬‬           ‫‪Character‬‬
                                         ‫]‪quotes & not double quotes‬‬
                                         ‫53556 ‪i.e from 0 to‬‬
‫‪5 int‬‬                           ‫23‬       ‫1 - 132 ,132-‬                            ‫‪Integer‬‬
‫‪6 long‬‬                          ‫46‬       ‫1 - 362 ,362-‬                            ‫‪Long‬‬
‫‪7 float‬‬                         ‫23‬       ‫;‪MIN_VALUE = 1.4e-45f‬‬                   ‫‪Float‬‬
                                         ‫;‪MAX_VALUE = 3.4028235e+38f‬‬
‫‪8 double‬‬                        ‫46‬       ‫;423-‪MIN_VALUE = 5e‬‬                     ‫‪Double‬‬
                                         ‫;803+‪MAX_VALUE = 1.7976931348623157e‬‬

       ‫‪o‬‬   ‫‪0xY is hexadecimal literal , while 0Y is octal literal‬‬
       ‫‪o‬‬   ‫‪/uxxx Unicode char‬‬

                                                                                            ‫איתחול‬
      ‫משתנים ‪ , member‬סטטיים או לא-סטטיים (משתני מופע) מאותחלים אוטומטית לערכם‬          ‫‪‬‬
                                                                        ‫הדיפולטי.‬
      ‫משתנים סטטיים מאותחלים פעם אחת ברגע שהמחלקה נטענת. משתני מופע מאותחלים‬            ‫‪‬‬
                                                            ‫בכל יצירת אוביקט חדש.‬
                                                    ‫חייבים לאתחל משתנים מקומיים‬         ‫‪‬‬
                                                     ‫חייבים לאתחל משתנים ‪final‬‬          ‫‪‬‬
    ‫מערכים של פרימיטיביים מאותחלים אוטומטית לערך ברירת המחדל, מערכים של רפרנסים‬         ‫‪‬‬
                                                      ‫מאותחלים אוטומטית ל-‪.null‬‬
                        ‫בלוק איתחול סטטי – קוד האיתחול מתבצע כאשר המחלקה נטענת‬          ‫‪‬‬
     ‫בלוק איתחול לא סטטי – מתבצע אחרי הקריאה לבנאי של מחלקת הבסיס, ולפני הקריאה‬         ‫‪‬‬
                                                         ‫לבנאי של המחלקה הנוכחית‬

                                                           ‫כאשר נוצר אוביקט, האיתחול מתבצע בסדר הבא:‬
                                                                ‫1. השדות מקבלים את ערכם הדיפולטי‬
                                                   ‫2. יש קריאה לבנאי (אבל הקוד שבו לא מבוצע עדיין)‬
                                                                ‫3. יש קריאה לבנאי של מחלקת הבסיס‬
                                             ‫4. השדות מאותחלים בעזרת ערכי איתחול או בלוק איתחול‬
                                                                                ‫5. מבוצע גוף הבנאי‬

                                                                 ‫אילוץ סוגי משתנים ‪type casting‬‬
                                                                         ‫הרחבה מותרת, צימצום אסור:‬

‫‪byte‬‬            ‫‪short‬‬
                         ‫‪int‬‬          ‫‪long‬‬           ‫‪float‬‬   ‫‪double‬‬
                ‫‪char‬‬
                                                                           ‫בכיוון הפוך דורש ‪.casting‬‬
                                                                                        ‫מחרוזות‬
  ‫מחרוזות ‪ literal‬מייצגות אוביקט ‪ String‬אחד, ונוצרות בזמן קומפילציה, בבריכת ה-‬      ‫‪‬‬
                                                                       ‫‪literals‬‬
       ‫מופעים של ‪ String‬הנוצרים בעזרת ‪ ,new‬נוצרים בזמן ריצה, והם אוביקטים שונים,‬    ‫‪‬‬
                                                       ‫מאוחסנים במקום אחר בזכרון.‬
      ‫מתודות המופעלות על אוביקט של המחלקה ‪ String‬אינן משנות את האוביקט עצמו-‬        ‫‪‬‬
                                                                       ‫‪.immutable‬‬
                                  ‫אוביקט של המחלקה ‪ StringBuffer‬כן ניתן לשינוי.‬     ‫‪‬‬
                 ‫הערה: במחלקה ‪ StringBuffer‬אין דריסה של המתודה ‪ ,equals‬לכן:‬

‫;))2‪System.out.println(sb1.equals(sb‬‬

       ‫הוא ‪ ,false‬כי המתודה ‪ equals‬העוברת בהורשה מהמחלקה ‪ Object‬בודקת שויון‬
                                                                       ‫רפרנסים.‬
 ‫בדיקת שויון בין מופעי ‪ String‬חייבת להעשות ע"י קריאה למתודה ‪ ,equals‬כי האופרטור‬     ‫‪‬‬
                                                               ‫== בודק הצבעה.‬

                                                                 ‫שליחת ארגומנטים לפונקציה‬
                                                     ‫ב-‪ ,Java‬כל הארגומנטים נשלחים ‪.by-value‬‬
                                     ‫‪ ‬עבור פרימיטיביים, נוצר העתק של ערך הפרמטר‬
 ‫‪ ‬עבור רפרנסים נוצרר העתק של הרפרנס. שינויים בתוך הפונקציה הנעשים על ‪ members‬של‬
                       ‫האוביקט, משנים אותם. שינויים הנעשים על הרפרנס עצמו, לא.‬

                                                                                        ‫מערכים‬
                                         ‫מערכים הם אוביקטים (מופעים של ‪)Object‬‬      ‫‪‬‬
                                                                        ‫הכרזה:‬      ‫‪‬‬
‫;‪int[] iA; Integer tA[]; Student[] sA‬‬

     ‫כאשר מכריזים על מספר מערכים באותה שורה, אם [ ] באים לפני שמות המשתנים, זה‬
                                                  ‫מופעל על כל המשתנים. זה אומר:‬
‫;][‪int[] iA,iB‬‬
                                         ‫‪ iA‬הוא חד-מימדי, בעוד ש-‪ iB‬הוא דו-מימדי.‬
                                                                         ‫הקצאה:‬     ‫‪‬‬
‫;]01[‪iA = new int‬‬
‫;]5[‪sA = new Student‬‬

                                                                         ‫איתחול‬     ‫‪‬‬
‫;} 5 ,5 ,5 ,5 ,5 ,5 ,5 ,5 ,5 ,5{ ][‪iA = new int‬‬
‫,)(‪sA = new Student[] { new Student(), new Student(), new Student‬‬
               ‫;} )(‪new Student(),new Student‬‬

                                                         ‫מצייני נגישות - ‪access modifiers‬‬
                                                                                         ‫מחלקות‬
                   ‫מחלקה סטנדרטית – יכולה לקבל רק ‪abstract ,final , public‬‬          ‫‪‬‬
                                   ‫מחלקות אינן יכולות להיות גם ‪ abstract‬וגם ‪final‬‬   ‫‪‬‬
       ‫‪ - abstract‬מחלקה שאין ליצור ממנה אוביקטים. יכולה להכיל מתודות מופשטות‬
‫‪ - final‬אי אפשר לרשת מחלקה כזו. כל המתודות שלה הן ‪( final‬בלי צורך לציין במפורש)‬
            ‫מחלקה מקוננת ברמה של ‪ member‬יכולות לקבל גם ‪ private‬או ‪protected‬‬         ‫‪‬‬
                                                                                  ‫איברים ‪members‬‬

                               ‫מתודה‬                                  ‫משתנה‬                 ‫מציין‬
         ‫מתודות מחלקה (שייכות למחלקה‬         ‫משתנה מחלקה (שייך למחלקה עצמה)‬              ‫‪static‬‬
                                 ‫עצמה)‬
       ‫* יכולות לגשת רק לאיברים סטטיים‬
     ‫* מתודות דורסות חייבות להיות גם כן‬
                                ‫סטטיות‬
      ‫* אין גישה ל-‪ this‬ממתודה סטטית‬
       ‫מתודה שהוגדרה כ-‪ final‬לא ניתן‬        ‫קבוע – חייב לקבל ערך במקום בו הוגדר‬           ‫‪final‬‬
                                  ‫לדרוס‬


                                                                          ‫חריגים - ‪Exceptions‬‬
                       ‫כל החריגים הם אוביקטים של המחלקה ‪ , Exception‬הנגזרת מ-‪.Throwable‬‬
                                                                                        ‫‪Runtime‬‬
                                               ‫אלה חריגים הנוצרים בזמן ריצה בגלל שגיאות תיכנות:‬
                                          ‫‪ ArithmeticException, NullPointerException‬וכו'‬

                                                                                        ‫‪checked‬‬
                       ‫כל חריג שאיננו ‪ Runtime‬הוא ‪ .checked‬חייבים לטפל בהם באופן מפורש.‬
             ‫מתודה שעלולה לזרוק חריג ‪ checked‬חייבת להכריז על כך בעזרת מילת המפתח ‪throws‬‬

                                                                   ‫הבלוק ‪try..catch..finally‬‬

                                          ‫יכולים להיות מספר ‪ ,catch‬אבל רק ‪ finally‬אחד‬           ‫‪‬‬
                                   ‫לא חייב להיות ‪ , finally‬אבל אם יש, הוא מבוצע בכל מקרה‬        ‫‪‬‬
                                          ‫הסדר בו מופיעים ‪ catch‬הוא מהספציפי לכללי יותר‬         ‫‪‬‬


                                                                                           ‫‪OOP‬‬
  ‫כל ה-‪ members‬של מחלקת בסיס עוברים בהורשה למחלקה הנגזרת. אין גישה לאיברים ‪private‬‬              ‫‪‬‬
                                                                       ‫במחלקה הנגזרת‬
                ‫ניתן להציב אוביקט של מחלקה נגזרת במשתנה של מחלקת בסיס (פולימורפיזם)‬             ‫‪‬‬
‫משתנים סטטיים משותפים לכל המחלקות באותו ענף הורשה. שינוי ערכו של משתנה סטטי במחלקת‬              ‫‪‬‬
                                                 ‫בסיס ישתקף גם במחלקה הנגזרת, ולהיפך.‬
 ‫המתודה הנקראת בזמן ריצה נקבעת באופן דינמי לפי האוביקט האמיתי. יש לבצע ‪down-casting‬‬             ‫‪‬‬
                                                                           ‫בכיוון ההפוך‬
  ‫בקריאה פולימורפית, מה שקובע הוא האוביקט שאליו מצביע רפרנס, ולא ההמחלקה שאליה הוא‬              ‫‪‬‬
                                      ‫משתייך. זה נכון למתודות לא-סטטיות, לא ‪.private‬‬
  ‫משתנים ומתודות סטטיות אינן "נדרסים". הם "מוחבאים" במחלקת הבסיס. זה אומר שבקריאה‬               ‫‪‬‬
                                          ‫פולימורפית, המחלקה של הרפרנס היא שקובעת .‬
           ‫אם המתודה ‪ , private‬ומנסים לקרוא לה באופן פולימורפי, נקבל שגיאת קומפילציה‬            ‫‪‬‬
                                                       ‫‪.method has private access‬‬
                                                            ‫מחלקה ‪ final‬אי אפשר לרשת‬            ‫‪‬‬
                                                               ‫דריסת מתודות (קריאה פולימורפית)‬

     ‫מתודה דורסת חייבת להיות בעלת אותה חתימה (אותו שם ואותה רשימת פרמטרים), וגם אותו ערך‬        ‫‪‬‬
                                                                                        ‫מוחזר‬
                                                          ‫מתודה דורסת אינה יכולה לצמצם גישה‬     ‫‪‬‬
                                    ‫ניתן לדרוס רק מתודות בעלות גישה – לא ‪ ,private‬ולא ‪final‬‬     ‫‪‬‬
                                           ‫מתודה דורסת מתודה סטטית חייבת להיות גם כן סטטית‬      ‫‪‬‬
 ‫יש להכריז על זריקת כל החריגים, במתודה דורסת (או כלל לא) - ניתן להכריז רק על זריקה של החריגים‬   ‫‪‬‬
                                        ‫שהוכרז עליהם במתודה הנדרסת (או מחלקות נגזרות שלהם)‬
                                                    ‫ניתן לשנות פרמטרים ל-‪ final‬במתודה נדרסת‬     ‫‪‬‬
                     ‫מחלקה נגזרת יכולה להשתמש במילה ‪ super‬כדי לקרוא למתודה במחלקת בסיס.‬         ‫‪‬‬


                                                                              ‫העמסת מתודות‬
    ‫למחלקה יכולות להיות מספר מתודות בעלות אותו שם, אבל רשימת פרמטרים שונה (חתימה שונה). אין‬
                                                  ‫כללים מיוחדים, רק החתימה חייבת להיות שונה.‬

                                                                                           ‫בנאים‬
                                                                         ‫אין ערך מוחזר‬      ‫‪‬‬
   ‫יכולים להיות ‪ . private, protected, public‬אם הבנאי היוא ‪ ,private‬יש שתי תוצאות:‬          ‫‪‬‬
                                                ‫- אי אפשר ליצור אוביקט מהמחלקה‬
‫- יכול להיות שאי אפשר לרשת את המחלקה. הסיבה היא שבכל בנאי של המחלקה הנגזרת, יש‬
                                    ‫קריאה בנאי ללא-ארגומנטים של מחלקת הבסיס.‬
                                   ‫בנאים לא עוברים בהורשה, אך ניתן ליצור בנאים מועמסים‬      ‫‪‬‬
     ‫ניתן להשתמש ב-‪ this‬ליצירת בנאי הקורא לבנאי אחר באותה מחלקה. הקריאה חייבת להיות‬         ‫‪‬‬
                                                                      ‫השורה הראשונה.‬
      ‫ניתן להשתמש ב-‪ super‬לקרוא באופן מפורש לבנאי של מחלקת הבסיס. חייבת להיות השורה‬         ‫‪‬‬
                                                                              ‫הראשונה.‬
         ‫אם אין קריאה מפורשת ל-‪ ,super‬אז הקומפיילר קורא לבנאי ללא-ארגומנטים של מחלקת‬        ‫‪‬‬
                                                                          ‫הבסיסקלאס.‬
                                                             ‫בנאי לא יכולה להיות ‪final‬‬      ‫‪‬‬

                                                                                    ‫מימשקים‬
                                                                       ‫‪ ‬הגדרה מופשטת.‬
                  ‫‪ ‬המתודות הן ‪ public‬ו- ‪ abstract‬כברירת מחדל. אינן יכולות להיות ‪static‬‬
                                                  ‫‪ ‬משתנים הם ‪public, static, final‬‬
                 ‫‪ ‬מחלקה המממשת מימשק, חייבת לממש את כל המתודות שלו, או להיות מוגדרת‬
                                                                         ‫כ-‪.abstract‬‬
                                                       ‫‪ ‬מימשק יכול לרשת ממימשקים אחר‬

                                                    ‫כללים להשמת רפרנסים בזמן קומפילציה‬
      ‫בזמן קומפילציה תהיה שגיאה אם בזמן השמה סוגי הרפרנסים אינם שיכים לאותה היררכיה ו/או אין‬
                                                                     ‫‪ downcasting‬לפי הצורך:‬

                                                                         ‫ללא ‪:casting‬‬
         ‫‪ ‬מחלקה יכולה להיות מופע של מחלקה ממנה היא יורשת ‪baseclass=derivedclass‬‬
          ‫‪interface=class‬‬      ‫‪ ‬מחלקה יכולה להיות מופע של מימשק שאותו היא מממשת‬



                                                                                  ‫‪:downcasting‬‬
                                                   :‫ בכיוון הפוך‬downcasting ‫יש לבצע‬      
              derivedclass= (derivedclass)baseclass




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

                                .boolean ‫, המחזיר‬instanceof ‫ניתן לבדוק בעזרת האופרטור‬    
    boolean t2=”String” instanceof Object // true

           NullPointerException ‫, מקבלים‬null ‫אם מנסים להפעיל משהו על משתנה שערכו‬         

                                                                                        :‫דוגמא‬
interface I{}
class A {}
class B extends A{}
class C extends B { }
class B1 extends A implements I{}
class C1 extends B1{}
class Test{
  public static void main(String[] args){
    A objA = new B();    //OK subclass to superclass
    //String s = (String) objA;//compile time error A to String
    String s1="abc";
    //objA = s1 instanceof String; //compile time error A to boolean
    System.out.println( objA instanceof B1);//false
    //B1 bBl = (B1) objA; //runtime error ClassCastException
    System.out.println( objA instanceof C); //false
    //C objC = (C) objA;   //runtime error ClassCastException:
    A objC1 = new C1();
    System.out.println( objC1 instanceof B1);//true
    B1 objB1 = (B1) objC1; //cast required from type A to B1
    A[] arrA;
    B[] arrB;
    arrA = new A[10];
    arrB = new B[20];
    System.out.println( arrB instanceof A[]); //true
    //arrB = arrA; //compile time error incompatible type
    //arrB = (B[])arrA; //runtime ClassCastException
    arrA = arrB; //change reference A to B
    arrB = (B[])arrA; //explicit cast required super to sub
    I i=objB1;
    //I i1=objA; //compile error
    A a=(A)i;
    B b=new B();
    b=(B)i; // runtime Class CstException
  }
}
                                                                        ‫מחלקות מקוננות‬
                                                                   ‫מחלקות פנימיות ‪members‬‬
               ‫‪ ‬מופע של מחלקה פנימית יכול להתקיים רק יחד עם מופע של המחלקה החיצונית‬
‫‪ ‬מחלקות פנימיות יכולות להגדיר רק ‪ members‬שאינם סטטיים (כי יצירת מופע של מחלקה פנימית‬
                      ‫דורשת יצירת מופע של המחלקה החיצונית) - (חוץ מ-‪)static final‬‬
                                                                                      ‫‪‬‬
                                                     ‫יצירת מופע של המחלקה הפנימית:‬    ‫‪‬‬
‫;)(‪Outer o=new Outer‬‬
‫‪Outer.Inner in=o.new‬‬      ‫;)(‪Inner‬‬
                              ‫יכול לגשת ל‪ members‬של המחלקה החיצונית, כולל ‪private‬‬     ‫‪‬‬
                        ‫ניתן לגשת לרפרנס של האוביקט של המחלקה החיצונית, בדרך הבאה:‬    ‫‪‬‬
‫‪Outer.this‬‬


                                                          ‫מחלקות פנימיים מקומיות לפונקציה‬
                                       ‫‪ ‬לא יכולות לקבל ‪ access modifiers‬או ‪static‬‬
                    ‫‪ ‬לא יכולות לגשת למשתנים מקומיים של הפונקציה, חוץ ממשתנים ‪.final‬‬
                                                     ‫‪ ‬לא יכולות להגדיר מתודות סטטיות‬
                               ‫‪ ‬לא יכולות להגדיר משתנים סטטיים (חוץ מ-‪)static final‬‬
                                                                                      ‫‪‬‬


                                                                        ‫מחלקות אנונימיות‬
                                                               ‫‪ ‬מוגדרות בתוך מתודה‬
                                           ‫‪ ‬ההגדרה, היצירה והשימוש, כולם במקום אחד‬
       ‫‪ ‬מממשות רק מימשק אחד או יורשות ממחלקה אחת, ללא שימוש במילים ‪ implements‬או‬
                                                                          ‫‪extends‬‬
                                                             ‫אינה יכולה להגדיר בנאי‬   ‫‪‬‬
                                                     ‫לא יכולה להגדיר מתודות סטטיות‬    ‫‪‬‬
                                ‫לא יכולה להגדיר משתנים סטטיים (חוץ מ-‪)static final‬‬    ‫‪‬‬


                        ‫מחלקות מקוננות סטטיות – הן בעצם מחלקות רגילות, בעלות שם מורכב יותר‬
                                         ‫‪ ‬יכולות להגדיר ‪ members‬סטטיים וגם לא סטטיים‬
                                                                       ‫‪ ‬יצירת אוביקט:‬
‫;)(‪Outer.Inner i = new Outer.Inner‬‬

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:10/1/2012
language:Hebrew
pages:6