כיצד לאחסן נתונים באובייקטים של Java

עודכן לאחרונה: ינואר 2020

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

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

משתנים וסוגים פרימיטיביים

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

/ * * זו גם תגובה. המהדר מתעלם מהכל * מהראשון / * ועד "נטיית כוכבים" שמסיימת את ההערה. * * הנה "נטיית הכוכבים" שמסיימת את ההערה. * / public class IntegerTest {public static void main (String [] args) {// הנה ההצהרה על משתנה int הנקרא anInteger, // שהוא נותן ערך התחלתי של 100. int anInteger = 100; // להכריז ולאתחל מערכת שלמה.שלל.אינפנטר (anInteger); // פלטים 100 // ניתן לעשות חשבון גם עם סוגים פרימיטיביים, באמצעות // אופרטורים חשבוניים סטנדרטיים. מספר שלם = 100 + 100; System.out.println (anInteger); // פלטים 200}}

ג'אווה משתמש גם בסוגי נקודה צפה, שיכולים להכיל מספרים אמיתיים, כלומר מספרים הכוללים מקום עשרוני. הנה תוכנית לדוגמא:

class class DoubleTest {main public public static void (String [] args) {// הנה ההצהרה על משתנה כפול שנקרא aDouble. // אתה גם נותן ל- aDouble ערך התחלתי של 5.76. כפול כפול = 5.76; // להכריז ולאתחל את aDouble System.out.println (aDouble); // פלטים 5.76 // ניתן לעשות חשבון גם עם סוגי נקודות צפות. כפול = 5.76 + 1.45; System.out.println (aDouble); // תפוקות 7.21}}

נסה להפעיל את התוכניות לעיל. זכרו, עליכם לקמפל לפני שתוכלו להריץ אותם:

javac * .java java IntegerTest java DoubleTest 

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

סוגים אינטגרליים

סוּג בייט קצר Int ארוך
SIZE (ביטים) 8 16 32 64
טווח -128 עד 127 -32,768 עד 32,767 -2,147,483,648 עד 2,147,483,647 -263 עד 263-1

סוגי נקודות צפה (פורמט IEEE 754)

 
סוּג נקודה צפה עם דיוק יחיד נקודה צפה עם דיוק כפול
SIZE (ביטים) 32 64
טווח +/- 1.18x10-38 עד +/- 3.4x1038 +/- 2.23x10-308 עד +/- 1.8x10308

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

// שבר קוד // הצהרה על משתנים s מסוג מחרוזת, // ואתחול עם מחרוזת מצוטט "שלום." מחרוזת s = "שלום"; // שרשור מחרוזת ב- s עם מחרוזת מצוטטת "עולם" מחרוזת t = s + "עולם"; System.out.println (t); // פלטים שלום עולם

היקף משתנה

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

עד כה דנתי במשתנים מקומיים , המכילים נתונים זמניים שבהם אתה משתמש בשיטה. אתה מצהיר על משתנים מקומיים בשיטות, ותוכל לגשת אליהם רק מתוך שיטות אלה. אמצעי זה כי אתה יכול לשלוף משתנים מקומיים בלבד anInteger, אשר השתמשו IntegerTest, ו aDouble, אשר השתמשו DoubleTest, מן השיטה העיקרית בה הם הוכרזו ולא בשום מקום אחר.

אתה יכול להכריז על משתנים מקומיים בכל שיטה. קוד הדוגמה שלמטה מכריז על משתנה מקומי AlarmClock snooze()בשיטה:

מחלקה ציבורית AlarmClock {נודניק ציבורי בטל () {// זמן נודניק באלפיות שנייה = 5 שניות נודניק ארוך אינטרוול = 5000; System.out.println ("ZZZZZ עבור:" + snoozeInterval); }}

אתה יכול להגיע snoozeIntervalרק snooze()מהשיטה, שם הכרזתsnoozeInterval, as shown here: 

מחלקה ציבורית AlarmClockTest {main public static void (String [] args) {AlarmClock aClock = AlarmClock new (); aClock.snooze (); // זה עדיין בסדר. // שורת הקוד הבאה היא שגיאה . // אינך יכול לגשת ל- snoozeInterval מחוץ לשיטת הנודניק. snoozeInterval = 10000; }}

פרמטרים של שיטה

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

כיתת אזעקה ברמה ציבורית {נודניק חלל ציבורי (snoozeInterval ארוך) {System.out.println ("ZZZZZ עבור:" + snoozeInterval); }}
מחלקה ציבורית AlarmClockTest {main public static void (String [] args) {AlarmClock aClock = AlarmClock new (); // העבירו את מרווח הנודניק כשאתם קוראים לשיטה. aClock.snooze (10000); // נודניק במשך 10000 אלפיות השנייה. }}

משתני חבר: כיצד אובייקטים מאחסנים נתונים

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

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

היקף ומשך חיים משתנים

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

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

שקול את AlarmClockהכיתה. העביר snoozeIntervalלתוך snooze()השיטה אינו עיצוב נהדר. תאר לעצמך שתצטרך להקליד מרווח נודניק בשעון המעורר בכל פעם שאתה מכה אחר כפתור הנודניק. במקום זאת, פשוט תן לכל השעון המעורר snoozeInterval. אתה משלים את זה עם משתנה מופע AlarmClockבכיתה, כמוצג להלן:

כיתת אזעקה ברמה ציבורית {// אתה מצהיר כאן על נודניק. זה הופך אותו למשתנה מופע. // אתה גם מאותחל את זה כאן. ארוך m_snoozeInterval = 5000; // זמן נודניק באלפיות השנייה = 5 שניות. public void snooze () {// אתה עדיין יכול להגיע ל- m_snoozeInterval בשיטת AlarmClock // מכיוון שאתה נמצא במסגרת הכיתה. System.out.println ("ZZZZZ עבור:" + m_snoozeInterval); }}

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

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

מחלקה ציבורית AlarmClockTest {main public static void (String [] args) {// צור שני שעונים. לכל אחד מהם m_snoozeInterval AlarmClock aClock1 = AlarmClock חדש (); AlarmClock aClock2 = AlarmClock חדש (); // שנה aClock2 // בקרוב תראה שיש דרכים הרבה יותר טובות לעשות זאת. aClock2.m_snoozeInterval = 10000; aClock1.snooze (); // נודניק עם מרווח aClock1 aClock2.snooze (); // נודניק עם מרווח aClock2}}

נסה את התוכנית הזו ותראה aClock1שעדיין המרווח שלה הוא 5,000, ואילו aClock2המרווח שלה הוא 10,000. שוב, לכל מופע יש נתוני מופע משלו.

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

JavaWorld

כימוס

Encapsulation is one of the foundations of object-oriented programming. When using encapsulation, the user interacts with the type through the exposed behavior, not directly with the internal implementation. Through encapsulation, you hide the details of a type's implementation. In Java, encapsulation basically translates to this simple guideline: "Don't access your object's data directly; use its methods."

That is an elementary idea, but it eases our lives as programmers. Imagine, for example, that you wanted to instruct a Person object to stand up. Without encapsulation, your commands could go something like this: "Well, I guess you'd need to tighten this muscle here at the front of the leg, loosen this muscle here at the back of the leg. Hmmm -- need to bend at the waist too. Which muscles spark that movement? Need to tighten these, loosen those. Whoops! Forgot the other leg. Darn. Watch it -- don't tip over ..." You get the idea. With encapsulation, you would just need to invoke the standUp() method. Pretty easy, yes?

Some advantages to encapsulation:

  • Abstraction of detail: The user interacts with a type at a higher level. If you use the standUp() method, you no longer need to know all the muscles required to initiate that motion.
  • Isolation from changes: Changes in internal implementation don't affect the users. If a person sprains an ankle, and depends on a cane for a while, the users still invoke only the standUp() method.
  • Correctness: Users can't arbitrarily change the insides of an object. They can only complete what you allow them to do in the methods you write.

Here's a short example in which encapsulation clearly helps in a program's accuracy:

// Bad -- doesn't use encapsulation public class Person { int m_age; } public class PersonTest { public static void main(String[] args) { Person p = new Person(); p.m_age = -5; // Hey -- how can someone be minus 5 years old? } } // Better - uses encapsulation public class Person { int m_age; public void setAge(int age) { // Check to make sure age is greater than 0. I'll talk more about // if statements at another time. if (age > 0) { m_age = age; } } } public class PersonTest { public static void main(String[] args) { Person p = new Person(); p.setAge(-5); // Won't have any effect now. } } 

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

הערה על שיטות

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

כתוב את התוכנית