Java מילת מפתח כפולה

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

נקודה צפה ומחשוב: תיאור מתמטי קצר

מספרים שברים הם נקודה קבועה או נקודה צפה. ניתן לייצג את האפשרות הראשונה כשבר רגיל, כאשר המונה (המספר עצמו) והמכנה (גורם קנה המידה שלו) יהיו מספרים שלמים. לדוגמה, המספר 2.7 הוא 27 עם מקדם קנה מידה של 10, 3.14 - 314 עם פקטור של 100. עם זאת, גישה זו אינה מדויקת במיוחד מנקודת מבט חישובית, לכן, הם משתמשים לרוב בייצוג של נקודה צפה. בתחום המחשוב, אריתמטיקה של נקודה צפה היא ייצוג אריתמטי מיוחד של מספרים ממשיים כקירוב לתמיכה בהחלפה בין טווח ודיוק. הפורמט העיקרי לייצוג מספרי נקודה צפה ב-Java נקרא float. שמו בא מנקודה צפה. Float הוא 32 סיביות, מתוכם ביט אחד הוא סיביות סימנים, 8 סיביות עבור אקספוננט ו-23 סיביות עבור מובהק. הטווח שלו הוא ±3.40282347E + 38F כלומר 6-7 ספרות משמעותיות. השם כפול מגיע מ-double float. הסוג הכפול גדול פי שניים מ- float : 8 בתים לעומת 4. הוא נקרא גם מספר ממשי דיוק כפול. מתוך 64 סיביות השמורות למספר כפול, 1 הוא סיביות בסימן, 11 סיביות מיועדות למעריך ו-52 סיביות הן לסימן. Java שבר כפול מאחסן מספרים בטווח ±1.79769313486231570E + 308 כלומר 15-16 ספרות משמעותיות. כפול הוא פורמט מדויק יותר. אז אם אתה צריך לאחסן מספרים גדולים באמת, העדפה כפולה על פני ציפה היא רעיון טוב. אגב, שיטות מתמטיות כמו sqrt, sin או cos ועוד רבות אחרות מחזירות ערכים כפולים. עם זאת, עליך לשלם עבור דיוק כפול עם זיכרון.

יצירת משתנה כפול

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

double name;

כאשר שם הוא שם המשתנה.

double myPrice;  //here we create a variable called myPrice
double action; //and here -- action. 

אתה יכול גם להשתמש בקיצור כדי ליצור משתנים מרובים מסוג double :

double name1, name2, name3;

דוגמאות למילות מפתח כפולות של Java

בואו ניתן כמה דוגמאות לשימוש במילת המפתח הכפולה של Java ליצירת משתנה.

double myPrice = 5.0;
double height = 180;
double x = 7.1, y = 3.0;

כאן במשתנה myPrice יש לנו את הערך 5.0, במשתנה הגובה - 180, ב- x שמנו את הערך 7.1, ו-3.0 ב- y .

כפול כמספר שלם

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

double height = 180;
int k = 2; 
int i = 5; 
double myDouble = k*i;

למעשה, משתנה הגובה מאחסן את המספר 180.0, והמשתנה myDouble מאחסן את המספר 10.0.

אינטראקציה כפולה ושלמה

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

public class DoubleDemo {
   public static void main(String[] args) {
       int k = 2;
       double myDouble1 = 5;
       double myDouble = k*7.0;
       System.out.println(myDouble1);
       System.out.println(k*myDouble1);
       System.out.println(myDouble);
   }
}

בדוגמה זו, הפלט יהיה: למרות שהמספר myDouble1 מסומן כ-5 ולא 5.0, Java רואה את המספר הזה ככפול , כך שהוא למעשה נראה כמו 5.0. אם נכפיל int וכפול, נקבל תמיד כפול , גם אם למעשה המספר הזה הוא מספר שלם. אנו יכולים להקצות משתנים מסוג double למשתנים מסוג int . לשם כך, עליך לבצע המרה מסוג מפורש. כמובן, החלק השברי ייזרק, המספר יקוצץ למספר שלם קטן יותר.

public class DoubleDemo {
   public static void main(String[] args) {
       double x = 57.789;
       int almostX;
       almostX = (int)x;
       System.out.println(almostX);
   }
}

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

public class DoubleDemo {
   public static void main(String[] args) {
       double myDouble = 7/2;
       System.out.println(myDouble);
   }
}

התוצאה היא: הסיבה לכך היא שמכונת ה-Java מחלק תחילה שני מספרים שלמים (ומקבל 3), ולאחר מכן מאחסן את הערך הזה במשתנה מסוג double, ומקבל 3.0 כתוצאה מכך. כדי לקבל לא מספר שלם, אלא חלוקה רגילה, אתה צריך לרמות. לדוגמה, כתוב את אחד המספרים כמספר ממשי (ואז כל הביטוי מומר אוטומטית לממשי). אם נעבוד עם משתנים מסוג מספר שלם, אז ניתן להכפיל אותם ב-1.0. זה לא ישנה את הערך, אבל זה ישנה את סוג המשתנה מ- int ל- double .

public class DoubleDemo {
   public static void main(String[] args) {
       double myDouble = 7.0/2;
       int x = 5;
       int y = 2;
       System.out.println(myDouble);
       System.out.println(x*1.0/y);
   }
}

הפלט הוא: