טיפוסים

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

;int a

מערכת ההפעלה תקצה מקום בזיכרון בגודל 4 בתים (32 סיביות) לשמירת מספר שלם (ב 32 סיביות ניתן לשמור מספר שאינו גדול מ 2³², אך כדי לשמור גם ערכים שליליים נוכל להשתמש רק במחצית, כלומר 2,147,483,648 -/+).


ישנם 8 סוגי טיפוסים בסיסים:

המרה casting

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


דוגמאות:

טיפוס בוליאני

משתנה בוליאני הוא משתנה שמקבל ערכי אמת או שקר, ולכן נוח לשימוש בתור משתנה שיקבל תוצאה של ביטוי לוגי כלשהו.
בניגוד ל ++c, הבוליאני של ג'אווה מקבל רק שני ערכים, true ו false, כשהאחרון הוא ברירת המחדל בין השניים. כאן אי אפשר לתת 0 או 1 כביטוי ל true /flase.

דוגמאות:

;boolean c

;int a = 3, b = 5

c = (a>b);      // c = false

c = (b>a);      // c = true

מזהים

מזהה = שם שהמתכנת נותן לרכיבים בתוכנית. כאן רכיבים הם למשל משתנים, פונקציות וכו'.
המזהה יכול להתחיל באות, קו תחתי או סימן דולר ($) בלבד. שאר התווים במזהה יכולים להיות תוים שונים (חוץ מתווים מיוחדים בעלי משמעות בשפה, כמו '!' למשל).

דוגמאות למזהים חוקיים:

;int noam

;()void _gadi

;char $eitan

דוגמאות למזהים לא חוקיים:

;float 777

;boolean @wisky

;()!int balise

משתנים

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

1) משתנה מקומי.

2) חבר מחלקה.

3) פרמטר לפונקציה.

ברירות מחדל:

משתנים מספריים: 0

בוליאניים: false

תווים: 0

מצביעים: null

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

ליטרלים

ליטרל הוא ערך שנכתב ישר לתוכנית.

סוגי ליטרלים

שלמים: מספר שלם שנכתב לתוכנית. למשל:

;int a

;a = 48

48 הוא הליטרל והוא יהיה מסוג int, אלא אם כן צוין אחרת במפורש.
למשל, בשביל משתנה long נוסיף סיומת L:

;a = 48L

בשביל בסיס 16 (הקסהדיצמלי) נכתוב קידומת 0x, למשל:

;a = 0x30

שקול לביטוי שנכתב למעלה.

ממשיים: מספר ממשי הנכתב לתוכנית.
טיפוסו של הליטרל הממשי יהיה double, אלא אם כן יצויין בפירוש אחרת. לכן ניסיון להצבתו כ float יגרור שגיאה ללא המרה מתאימה (אפשר להמיר אותו ע"י casting או ע"י הוספת F לסופו). למשל:

;double d

;float f

;d=23.45

;f = (float)43.43

;f= 21.12F

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

3,000,000.0 = 3E6

32.564 = 32564E-3

מחרוזות: מחרוזת הנכתבת לתוכנית.
המחרוזת תיכתב בין גרשיים. לדוגמא:

;string s

;"s = "Hello

קבועים: ערכים שלא ישתנו לאורך כל התוכנית (מקובל לכתוב אותם באותיות גדולות).
קבוע יוגדר ע"י שימוש במילה final, לדוגמא:

;final int A = 30

;final double D =25.75

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

אופרטורים

אופרטורים: תווים המסמנים פעולה לוגית או מתמטית בין כמה מספרים.

אופרטורים חשבוניים:

שם	סימן	פועל על הטיפוסים...	תיאור הפעולה
חיבור	+	שלמים, ממשיים	חיבור שני המספרים שמשני צידי האופרטור
חיסור	-	שלמים, ממשיים	חיסור המספר שמימין לאופרטור מהמספר שלשמאלו
כפל	*	שלמים, ממשיים	הכפלת שני המספרים שמשני צידי האופרטור
חילוק	/	שלמים, ממשיים	חילוק המספר שמשמאל לאופרטור במספר שלימינו
מודולו	%	שלמים	שארית החלוקה של המספר שמשמאל האופרטור במספר שלימינו
הוספה	++	שלמים	הוספת 1 לערך של משתנה
החסרה	--	שלמים	החסרת 1 מערך של משתנה

סדר קדימויות:

    רמה 1:    ()
    רמה 2:    ++,--
    רמה 3:    *,/,%
    רמה 4:    -,+
    רמה 5:    =

בביטוי מורכב יתבצע אופרטור ברמה נמוכה לפני אופרטור ברמה גבוהה.

השפעת הטיפוס על האופרטור
דוגמא:

;int a

;float b,c

;a = 10/4

;b = 10/4

;c = 10.0F/4.0F

כתוצאה נקבל את הערכים:

;a = 2; b = 2.0; c = 2.5

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

;int a,b

;a = 10

b = a++;   //a=11, b = 10

;int c,d

;c = 10

d = ++c;   //c = 11, d = 11

אופרטורים לוגיים

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

	אופרטור	משמעות
	==	שווה
	=!	שונה מ
	<	גדול
	>	קטן
	=<	גדול שווה
	=>	קטן שווה
	&&	וגם
	||	או
	!	שלילה

דוגמאות:

x == y x שווה ל y x >= y x גדול מ y, או שווה לו x != y && y != z x לא שווה ל y, וגם y לא שווה ל z x > y || x < y x קטן מ y או y קטן מ x (תוצאת הביטוי תהיה false רק אם הם שווים) ( x == y)! x שונה מ y

בניגוד ל ++C, האופרטורים הלוגיים פועלים רק על ביטויים עם ערך בוליאני, ולא על שלמים.

אופרטורי סיביות

אופרטורים שפעולתם פועלת על הסיביות של הטיפוסים השונים:

	אופרטור	משמעות
	&	AND
	!	OR
	^	XOR
	~	NOT
	>>	הזזה שמאלה (shift left)
	<<	הזזה ימינה (shift right)
	<<<	הזזה ימינה תוך מילוי אפסים

טבלאות הפעולות הלוגיות:

	AND A B תוצאה 1 0 0 1 1 1 0 0 0		OR A B תוצאה 1 0 1 1 1 1 0 0 0
	XOR A B תוצאה 1 0 1 1 1 0 0 0 0 0 1 1		NOT A תוצאה 1 0 0 1

דוגמא לביצוע פעולת OR על שני משתנים מסוג short:

;short a, b

;a= 1234

;b = 5678

נייצג את המספרים בסיביות:

a

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 0 1 0 0 1 0 1 1 0 0 1 0 0 0 0 0

b

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 0 1 1 1 0 1 0 0 0 1 1 0 1 0 0 0

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

;short c =a|b

התוצאה שתתקבל תהיה:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 0 1 1 1 1 1 1 1 0 1 1 0 1 0 0 0

כלומר:

;c = 5886

בצורה דומה תבוצענה שאר הפעולות על הסיביות של המספר:
     & תבצע פעולת AND;
     ^ תבצע פעולת XOR;
     ~ תבצע פעולת NOT בשיטת משלים ל 1.

פעולות הזזה

האופרטור >> יבצע הזזה שמאלה (בכיוון החץ) של סיביות המשתנה מספר מקומות נתון והסיביות החסרות שיתווספו יהיו 0 תמיד.
האופרטור << יבצע הזזה ימינה של סיביות המשתנה מספר מקומות נתון הסיביות החסרות שיתווספו יהיו 0 בשביל מספר חיובי ו1 בשביל מספר שלילי.
האופרטור <<< יהיה זהה לקודם אלא שתמיד יתווספו בו הסיביות 0 משמאל למספר.

דוגמא:

;short a = 1234

a

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 0 1 0 0 1 0 1 1 0 0 1 0 0 0 0 0

= a << 3

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 0 0 0 0 1 0 0 1 0 1 1 0 0 1 0 0

;a = 9872

הזזה שמאלה של המספר n פעמים שווה להכפלתו ב 2ⁿ.הזזה ימינה של המספר n פעמים שווה לחילוקו ב 2ⁿ.

אופרטורי השמה

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

;a = b = c = d

אופרטור ההשמה איננו אופרטור השוויון == !!!

ביטויי השמה מקוצרים

אפשר לקצר את זמן ההשמה ע"י כתיבת ביטוי השמה מקוצר. לדוגמא:

;a += 5

שקול לביטוי:

;a = a + 5

דרך הקיצור הזאת אפשרית לאופרטורים הבאים:

+

-

*

/

%

!

&

^

>>

<<

<<<