tomron87/hebrew-wikipedia-sentences-corpus huggingface dataset:
השיר מתואר גם כהזמנה "לקום ולרקוד", לא משנה מה אנשים אומרים.
דוד צרוניאן, ראש המשלחת של ארמניה, מסביר עוד, "[השיר] נוגע בעניין חשוב מאוד, אבל בצורה עליזה ושובבה.
אנו מקווים לעורר אנשים בכל העולם לאמץ את ה-Jako הפנימי שלהם ולהצטרף לריקוד המעצים הזה של חופש!".
השיר הארמני לאירוויזיון 2024 נבחר באופן פנימי על ידי AMPTV (חברת הטלוויזיה הפומבית של ארמניה).
בינואר 2024, דווח כי הצמד נבחר לייצג את ארמניה.
ב-9 במרץ 2024, רשות השידור אישרה רשמית שהצמד ייצג את ארמניה באירוויזיון 2024, כאשר השיר, "Jako", נחשף ב-13 במרץ.
ארמניה שובצה לחלקו הראשון של חצי הגמר השני, שנערך ב-9 במאי.
ארמניה הופיעה שמינית, אחרי דנמרק ולפני לטביה.
השיר מוקם במקום ה-3 בחצי הגמר, ועל כן עלה לגמר.
בגמר התחרות ארמניה הופיעה כשיר מספר 19, אחרי פורטוגל ולפני קפריסין.
בסיום הערב הגיעה ארמניה למקום ה-8, עם 183 נקודות.
+תאריכי יציאה ופורמטים של "Jako"אזורתאריךפורמטיםחברת תקליטיםהערותעולם 29 בספטמבר 2023הורדה דיגיטלית הזרמת מוזיקהג'יגולי PIAS רקורדינגססינגל
Java Platform, Enterprise Edition או Java EE (בעבר הייתה ידועה בשם J2EE) היא פלטפורמת Java של חברת אורקל לפיתוח תוכנות ארגוניות.
הפלטפורמה מספקת ממשקי תכנות יישומים (API) וסביבת הרצה (runtime environment) המשמשים לפיתוח והרצה של network services ,web services ויישומי רשת מורכבים אחרים, הבנויים בארכיטקטורת שרת–לקוח רב-שכבתית, ומאופיינים בסילומיות (scalability), אמינות ואבטחת מידע.
Java Enterprise Edition מרחיבה את ה-Java Standard Edition, על ידי הוספת ממשקי תכנות יישומים התומכים במיפוי אובייקטי-רלציוני (עבודה עם בסיסי נתונים), ארכיטקטורות מבוזרות ורב-שכבתיות, web services ועוד.
הפלטפורמה מבוססת על רכיבי תוכנה מודולריים אשר רצים על גבי שרת יישומים.
תוכנה עבור Java EE מפותחת בעיקר בשפת התכנות Java ומשתמשת ב-XML לצורכי קונפיגורציה.
הגרסה הנוכחית (נכון לחודש אפריל 2014) נקראת Java EE 7.
Java EE מוגדרת על ידי המפרט (specification) שלה.
כמו במקרה של מפרטים אחרים של ה-Java Community Process, מפתחים צריכים לעמוד בדרישות תאימות מסוימות על מנת שיוכלו להצהיר על המוצרים שלהם כתואמי Java EE.
Java EE כוללת מפרטים לממשקי תכנות יישומים (APIs), כדוגמת XML ,web services ,JMS ,e-mail ,RMI ,JDBC ועוד, ומגדירה כיצד לתאם ביניהם.
כמו כן, Java EE כוללת גם כמה מפרטים לרכיבים הייחודיים לפלטפורמה זו; ביניהם נכללים JavaServer Pages ,servlets ,Connectors ,Enterprise JavaBeans וכמה טכנולוגיות ל-web services.
כל אלה מאפשרים לפתח תוכנות enterprise פורטביליות וסילוּמיוֹת, הניתנות לאינטגרציה עם מערכות מורשת.
שרת יישומים של Java EE יודע לטפל בטרנזקציות, אבטחת מידע, סילומיות, מקביליות וניהול של הרכיבים הפרוסים עליו, וזאת על מנת לאפשר למפתחים להתרכז בלוגיקה העסקית של הרכיבים במקום במשימות תשתית ואינטגרציה (שילוב מערכות).
שרתים נפוצים מבוססי Java EE
ג'רונימו - מפותח על ידי קרן התוכנה אפאצ'י.
JBoss - פותח על ידי JBoss וכיום מפותח על ידי Red Hat.
WebLogic של חברת BEA אשר כיום בבעלותה של אורקל.
GlasshFish - תוכנה חופשית שפותחה במקור על ידי חברת סאן מיקרוסיסטמס וכיום מתוחזקת על ידי אורקל.
Java Platform, Micro Edition או Java ME (בעבר Java 2 Platform, Micro Edition או J2ME) היא מפרט המגדיר חלק מפלטפורמת Java המיועד לספק אוסף של ממשקי ג'אווה לפיתוח תוכנות במכשירים שונים כדוגמת טלפונים חכמים.
ב- Java מורצת התוכנה על מכונה וירטואלית.
היתרון העיקרי של ריצה על מכונה וירטואלית הוא שניתן לכתוב את הקוד ללא תלות במערכת ההפעלה שעליה הוא עומד לרוץ (Cross-platform).
על מנת לאפשר התאמה של קוד Java למכשירים ניידים, נכתבו מספר גרסאות של JVM עבור מכשירים אלו.
ריבוי המכשירים, ריבוי מערכות ההפעלה, וסוגי מעבדים שונים יצרו מוטיבציה לפיתוח על בסיס מכונה וירטואלית בתחום זה.
השם הכולל שניתן למכונה הווירטואלית של Java עבור מכשירים ניידים הוא Java ME (נקראה בעבר J2ME).
למרות שלכאורה בכתיבה ב- Java אין תלות במערכת ההפעלה, המציאות במכשירים ניידים לא תמיד תואמת עיקרון זה.
לעיתים יש צורך להתייחס למאפינים הספציפיים של המכשיר עליו ירוץ הקוד, בעיקר בהיבטים של גודל המסך ויכולותיו.
כדי לפשט את כתיבת המכונה הווירטואלית למגוון של טלפונים ומערכות קטנות, היא חולקה לשתי שכבות לוגיות.
השכבה הנמוכה יותר נקראת CDC או CLDC.
אלו שני סוגים שונים של השכבה הנמוכה שיפורטו בהמשך.
שכבה זו משתנה בהתאם לחומרה הספציפית ולמערכת ההפעלה של המכשיר הנייד, ויש לפתח אותה עבור כל מכשיר נייד.
מעליה נמצאת שכבת האפליקציה, המממשת את ה-API המסופק על ידי Java Virtual Machine.
שכבת האפליקציה אחראית למשל על טיפול בתפריט ובמסך, כאשר היא מסתמכת על שכבת ה-CDC/CLDC לתקשורת עם החומרה ומערכת ההפעלה של המכשיר.
שכבת ה-CDC (או בשמה המלא: Connected Device Configuration) היא התשתית למערכות שהן יחסית עתירות משאבי זיכרון ועיבוד, ואילו שכבת ה-CLDC (הנקראת Connected Limited Device Configuration) מיועדת למערכות מוגבלות משאבים, ומאפשרת פונקציונליות פחותה.
בנוסף, קיימים מספר וריאנטים של שכבת האפליקציה.
הגרסה הנפוצה ביותר היא ה-MIDP.
גרסה זו מפותחת בעזרת תשתית CLDC, שהיא מוגבלת יותר, ובהתאם מכילה חלק קטן יותר של ה-API הסטנדרטי.
לעומתה, Personal Java ו-Java TV הן גרסאות חזקות יותר של שכבת האפליקציה, המשתמשות בשכבת CDC.
לכן, הן תומכות בממשק מורחב יותר, הדומה יותר לממשק Java הסטנדרטי.
לדוגמה, Personal Java כוללת תמיכה ב-AWT, ממשק המשמש ליצירה של גרפיקה מבוססת חלונות וממשק משתמש באופן פשוט.
כדי לעזור ליצרניות המכשירים הניידים בהתאמה ל-Java, חברת Sun מספקת שירותי מימוש Java לטלפונים וסביבות פיתוח עבור J2ME.
אפליקציית Java הכתובה עבור MIDP נקראת Midlet.
ב- MIDP נתמכות הפונקציות העיקריות הבאות הבאות:
הפעלה ראשונית, המתנה (למשל בעת קבלת שיחה) וסיום האפליקציה.
קבלת אובייקט המסך, ושימוש באובייקטים גרפיים על מנת להציג עליו תפריטים או גרפיקה.
מערכת טעינה חכמה, המאפשרת אריזת אפליקציות בקובץ Jar (קובץ ארוז רגיל של Java) ויצירת קובץ תיאור של האפליקציה, המאפשר למכשיר לוודא האם האפליקציה נתמכת לפני הטעינה עצמה.
קובץ התיאור נקרא קובץ Jad.
במקביל להתפתחות של הטלפונים באירופה ובארצות הברית על ידי נוקיה, מוטורולה וסימנס, התפתחה ביפן תרבות משחקי טלפון.
מגמה זו הובילה לפיתוח מימוש שונה ל- J2ME הנקרא DoJa.
בניגוד ל- MIDP, גרסה זו הותאמה במיוחד למשחקים ופותחה על ידי חברת DoCoMo, המפעילה הגדולה ביפן.
הדרישה לתמיכה חזקה יותר באפליקציות בידוריות ובמשחקים התרחבה גם לשאר העולם, ובעקבותיה יצאו הרחבות ומימושים נוספים.
המימוש העיקרי הוא גרסה חדשה של MIDP, בשם MIDP 2.0. גרסה זו מרחיבה את התמיכה במשחקים ובאנימציה.
בנוסף, גרסה זו מרכיבה את ממשקי התקשורת עם הרשת.
נכון ל-2009, הגרסה הבאה, הנקראת MIDP 3.0, עדיין נמצאת בפיתוח.
JavaScript (בעברית: ג'אווה סקריפט, בקיצור: JS) היא שפת תכנות המשמשת לפיתוח אתרי אינטרנט ואפליקציות.
היא גם אחת מהטכנולוגיות הבסיסיות שיוצרות את האינטרנט, יחד עם HTML ו־CSS.
נכון ל־2023, 98.7% מהאתרים משתמשים ב־JavaScript בצד הלקוח של האתר שלהם, לעיתים קרובות תוך שימוש בספריות חיצוניות לשם כך.
לכל הדפדפנים הגדולים יש מנועי הרצה להריץ קוד JavaScript על המכשירים של המשתמשים.
JavaScript היא שפת תכנות עילית, לעיתים מתקמפלת בדיוק בזמן, שמממשת את תקן ECMAScript.
יש בה טיפוסיות דינאמית, תכנות מונחה עצמים מבוסס תבניות (Prototye) ופונקציות שהן חלק טבעי מהשפה .
יש בה מספר פרדיגמות, ביניהן תכנות מונחה אירועים, תכנות פונקציונלי ותכנות אימפרטיבי.
יש בה ממשקים (APIs) לעבודה עם טקסט, תאריכים, ביטויים רגולריים, מבני נתונים סטנדרטיים ו־Document Object Model (DOM).
תקן ECMAScript ש־JavaScript מממשת אינו כולל ממשקי פלט וקלט כמו ממשקי תקשורת, או גרפיקה.
בפועל, דפדפנים או סביבות הרצה שונות מספקות ל־JavaScript ממשקים עבור יכולות אלה.
על בסיס סביבת הריצה של הדפדפנים, נבנו סביבות להרצה של ג'אווה סקריפט במחשבים אישיים ובשרתים (Node.js, Deno.js, Bun).
אף על פי ש־Java ו־JavaScript דומות בשם וב, שתי השפות הן נפרדות ושונות מהותית אחת מהשנייה.
נכון לשנת 2023, JavaScript היא שפת התכנות הפופולרית ביותר בעולם בקרב מפתחים.
בנוסף לכתיבת תסריטים בצד הלקוח (בדפדפן), מאפשרת JavaScript כתיבת תסריטים גם בצד השרת, לתפעול בשרת אינטרנט.
התחביר של שפת ActionScript, שמיוחדת לפלאש, נגזר משפה זו.
קיימת גרסה תקנית של השפה הקרויה ECMAScript.
חברת מיקרוסופט פיתחה שפה מתחרה להפעלה בדפדפן בשם VBScript, אך גרסה זו לא תפסה.
בנוסף יצאה מיקרוסופט עם גרסה משלה של שפת JavaScript, והיא קרויה JScript.
דבר זה גרם בעיות רבות בקרב מפתחי האינטרנט, אך בסופו של דבר גם מיקרוסופט אימצה את התקן המקובל של השפה בגרסאות החדשות של אינטרנט אקספלורר ויותר מכך במיקרוסופט אדג'.
השפה היא שפה שעוברת תהליך אינטרפרטציה (פירוש) ולא קומפילציה (הידור).
משמעות הדבר שקוד המקור לא צריך לעבור תהליך של קימפול (הידור) לשפת ביניים ואז להריץ אותו, אלא המפרש (interpreter) קורא שורה שורה או מקבץ של שורות (למשל תחום הכרזה של פונקציה) ומריץ אותן ישירות.
העברת פרמטרים לפונקציה בשפה משתנה בין טיפוסים פרימטיבים לאובייקטים.
טיפוסים פרמיטיביים עוברים by value.
כלומר, המפרש מעביר לפונקציה העתק של האובייקט ולא את האובייקט המקורי.
טיפוסים מורכבים או אובייקטים עוברים by reference כלומר המפרש מעביר רפרנס (מעין מצביע) לערך ואינו יוצר העתק שלו.
השפה תומכת בתחביר הסטנדרטי של שפת C, מבחינת אופרטורים, מבני בקרה ופקודות, ומבדילה בין אותיות גדולות לקטנות (case-sensitive).
כמו ברוב שפות התסריט טיפוסי השפה מקושרים לערכים ולא למשתנים, טיפוס משתנה X יכול להפוך במהלך הריצה ממספר למחרוזת לפי ההשמה.
השפה מבוססת "תכנות מונחה דגמי אב" (Prototypes), שהוא סוג (לא נפוץ) של תכנות מונחה־עצמים.
השפה בעיקרה היא שפה מבוססת אובייקטים (אפילו טיפוס בוליאני [Boolean] הוא למעשה אובייקט).
האובייקטים בשפה הם מערכים אסוציאטיביים.
תכנות מונחה עצמים אפשרי על ידי הגדרת מחלקה החל מגרסה ES6, או באמצעות יצירת אובייקט והצמדת מאפיינים אליו (בגרסה ES5 ומטה).
כל מאפיין באובייקט יכול לתפקד כמשתנה או פונקציה.
ישנם שלושה סוגי אובייקטים: אובייקטים של השפה כמו משתנים (כמו אובייקט תאריכי Date ואובייקט מחרוזתי), אובייקטים של הדפדפן (כמו אובייקטי window ו־document), ואובייקטים שיוצר המשתמש.
אובייקטים של הדפדפן אינם נתמכים בגרסאות הערות בסביבת ריצה שאינה דפדפן (כגון nodeJS) אלא אם כן משתמשים בספריות או חבילות מסוימות הנועדו לתת לקוד עוד פונקציות כדי לבנות אפליקציות לשולחן העבודה, אפליקציות לטלפון, משחקים מסובכים (משחקי תלת-מימד לדוגמה), סימולציות ועוד.
השפה תומכת בהרחבת מתודות של אובייקטים טבעיים בשפה כמו מחרוזות או Date באמצעות Prototyping.
השפה היא גם שפה מונחית־אירועים (Events), כך שמהלך ריצת התוכנית מבוסס על אירועים שמתרחשים בזמן ביצועה.
לכל אובייקט קיים אוסף אירועים הייחודי לו, והדרך הנפוצה היא לכרוך פונקציות של המשתמש עם אירוע של אובייקט מובנה.
להלן רשימה חלקית של האירועים:
תיאוראירועבעת טעינהonloadבעת לחיצהonclickבעת סגירת דףonabortבעת סגירת חלוןOnunloadבעת יציאה מפוקוסOnblurבעת שינוי אובייקטonchangeבעת בחירהonselectבעת שליחת טופסonsubmitבעת שגיאהonerrorבעת מעבר עכברonmouseoverבעת עזיבת סימן העכבר את האובייקטonmouseoutבעת הוספת קלטoninput
פונקציה בשפה היא אזרחית ממחלקה ראשונה, ולמעשה כל פונקציה היא אובייקט בעצמה.
השפה מאפשרת השמה של פונקציות למשתנים, העברה של פונקציה כארגומנט, והגדרת פונקציות אנונימיות.
השפה מתממשקת באופן טבעי עם ממשק DOM, המייצג מסמכי HTML ו־XML תוך שימוש במתודולוגיה של תכנות מונחה־עצמים.
לשפה תמיכה מובנית בביטוי רגולרי.
להלן תוכנית בשפת JavaScript לבדיקת ראשוניות של מספרים.
בתחילה נוספים לדף האינטרנט תגיות HTML בסיסיות – שדה קלט (input) וכפתור (button), שלחיצה עליו מפעילה את הפונקציה checkPrime לבדיקת ראשוניות של הקלט, ומציגה למשתמש את הפלט.
לאחר מכן מוגדרות שתי פונקציות, getFactor – פונקציית עזר שמקבלת מספר ומחפשת מחלק טבעי שלו שגדול מ-1, ו־checkPrime – הפונקציה הראשית שבודקת את הקלט שמועבר לה ומחזירה תוצאה.
הסימן "//" מציין הערות שמסבירות את הקוד למתכנת.
בלוקים מוזחים להקל על הבנת מבנה הקוד.
מאחר ש-JavaScript היא שפת צד לקוח שמריצה פקודות על גבי המכשיר של המשתמש, נוצרו ניסיונות רבים לגנבת מידע אישי על ידי שימוש ב־XSS.
בעקבות זאת, נוצרו כלים שמשמשים לאבטחה נגד XSS וקוד זדוני כמו התוסף noscript, וגם הדפדפנים עצמם פיתחו מנגוני הגנה נגד התקפות אפשריות.
בדפדפנים ישנים ופחות מאובטחים, ניתן להזריק ולהריץ קוד שלא מוזכר כלל בקוד מקור, בכל דף אינטרנט שמופיע בדפדפן.
ב־JavaScript manipulation מכניסים את פקודות הסקריפט בשורת הכתובת של הדפדפן, ולרוב הוא מיועד להשפיע על ה־DOM.
בדוגמה זו נקפיץ באמצעות הפקודה alert תיבת הודעה עם העוגיות ששמורות בדפדפן לדף זה.
על מנת להגן מפני התקפות הינדוס חברתי, השימוש בשיטה זו נחסם בדפדפנים המודרניים.
כך לדוגמה, במוזילה פיירפוקס החל מגרסה 6, קוד שהוזרק בשיטה זו לא יתייחס לתוכן הדף, ומשכך, לא יתאפשר לו להשפיע על ה־DOM.
בגוגל כרום ובאינטרנט אקספלורר מגרסה 9 ומעלה, כאשר מדביקים כתובות כאלה בשורת הכתובת, הפרוטוקול (JavaScript:) מושמט מהכתובת המודבקת, ובכך מנטרל את השפעתו של הקוד.
הדבקת הקוד מהדוגמה הקודמת בשורת הכתובת ידביק את הקוד הבא –
עם זאת, במרבית הדפדפנים המתקדמים קיימים כלי פיתוח ייעודיים, בהם ניתן לבצע JavaScript manipulation בהיקף נרחב.
בזכות הפופולריות שלה, JavaScript זכתה להרבה ספריות ומהדרים, מלבד השימוש כשפת תכנות וחישוב ובניית קוד פשוט להרצה בדפדפן [הנקרא ונילה], המאפשרים לבנות בעזרתה יישומים שונים.
רוב היישומים נבנים ב־Node.js אך לפעמים מהודרים לקוד JavaScript רגיל על מנת להריץ אותם בדפדפנים.
לעבודה קלה עם ה-DOM מוכרת הספרייה jQuery.
לבניית אפליקציות למכשירים המריצים אנדרואיד ו־iOS מוכרות הספריות ReactNative, ו־NativeScript שמהדרות קוד המתבסס על React ו־Angular בהתאמה לקוד הנקרא נייטיבי, כלומר אפליקציות הנראות כאילו נכתבו בשפות הנייטיביות לכל פלטפורמה, Java עבור אנדרואיד, ו־Objective-C עבור iOS.
לעומתן מוכרת גם הספרייה ionic שמהדרת את ה-JavaScript לאפליקצייות היברידיות, הממנפות את הקוד לבניית תוכנות הנראות רגילות אך למעשה מבוססות web גם בזמן הריצה.
תוכנות אלה עדיין מקבלות גישה לכלים השמורים ליישומונים נייטיביים כמו שימוש במצלמה.
ספריות אלה לרוב מבוססות על תחביר הדומה ל-HTML.
לבניית שרתי אינטרנט הפועלים בצורה א-סינכרונית ומבוססים על ניתוב, מוכרת הספרייה Express.js.
ספרייה זו אינה מבוססת על HTML כברירת מחדל, אלא רק על JavaScript לבניית API מבוסס JSON לדוגמה, אך למעשה היא יכולה להגיש כל דבר, החל מקבצים וכלה ב־HTML בו מוזרק מידע.
היא עושה שימוש בפרוטוקלי HTTP על מנת להעביר מידע מהלקוח ובחזרה.
לבניית תוכנות למחשבים עם מערכת הפעלה Windows, macOs, או לינוקס מוכרת הספרייה Electron שמאחורי הקלעים מתקינה סביבת ריצה ייעודית הנקראת כרומיום (שהיא גם הליבה של גוגל כרום) ומציגה דפי אינטרנט בתוכנות מחשב רגילות המקבלות גם גישה לפונקציות השמורות לתוכנות בלבד כמו שליטה מלאה על הקבצים ואפשרות התקנה.
ניתן לכתוב JavaScript ישירות בתוך תגית script ב־HTML, אולם גישה נפוצה יותר היא לייבא סקריפט מתוך קובץ נפרד, באמצעות הפרמטר src (קיצור של source) בתגית script.
כאשר filename.js הוא קובץ ה אליו מפנים.
קובץ ה־ מכיל את כל הפקודות המופיעות בתוך התגית <script> ושהדפדפן יריץ.
כמו כן, קובץ JavaScipt יכול לייבא קבצים נוספים שאינם מוצהרים במסמך ה־HTML בצורתו ההתחלתית.
בדוגמה זו, ארבע שורות אלה, הכלולות באחד הסקריפטים הקיימים בדף, יוצרות אלמנט script חדש, המייבא את הקובץ "filename.js", ומוסיפות אותו למסמך ה־HTML (לסוף אלמנט ה־head של המסמך).
JavaServer Pages (בראשי תיבות: JSP) היא טכנולוגיית צד-שרת מבוססת Java המאפשרת יצירה של דפי HTML, XML וקבצים אחרים, בתשובה לבקשות HTTP.
טכנולוגיה זאת, מבית סאן מיקרוסיסטמס, מאפשרת לקוד Java ופעולות מוגדרות לשנות וליצור דפים בתשובה לכל בקשה.
התחביר של JSP כולל תגי XML נוספים, הנקראים פעולות JSP, המאפשרות לקרוא לפעולות של השפה.
בנוסף, הטכנולוגיה מאפשרת יצירה של ספריות תגי JSP, שיכולות להשתלב עם תגי XML רגילים.
ספריות התגים מאפשרות ליצור יישומי צד-שרת שאינן כבולות לשרת Web ומערכת הפעלה מסוימים.
דפי JSP מהודרים על ידי מהדר JSP לכדי Java Servlets.
מהדר ה־JSP יכול ליצור את ה־Servlets כבר בשפת הביניים של Java או בשפת Java ממש, שתהודר בתורה על ידי מהדר Java רגיל.
Servlet (סֶרְוְלֶט; לפי מונחי האקדמיה ללשון העברית: שָׁרָתִית) היא טכנולוגיית צד-שרת מבוססת Java, המהווה את אחד מממשקי תכנות היישומים של Java Enterprise Edition.
המפרט של Java Servlet מגדיר את האופן שבו רכיב תוכנה הכתוב בשפת ג'אווה ורץ בצד השרת, יכול להגיב לבקשות המגיעות מצד הלקוח (לדוגמה, בקשות HTTP מסוג GET ו-POST).
סרוולטים הם מחלקות Java, אשר עקרונית יכולות לתקשר על גבי כל פרוטוקול שרת–לקוח, אבל השימוש הנפוץ ביותר ב-Servlets הוא עם פרוטוקול ה-HTTP.
לפיכך, המילה "Servlet" לבדה בדרך כלל משמשת בהקשר ל-"HTTP Servlet".
סרוולט הוא אובייקט המקבל בקשה (request) ויוצר תגובה (response) על סמך אותה בקשה.
Servlets רצים על גבי שרת HTTP והם מהווים את המקבילה של ג'אווה לטכנולוגיות אחרות לתוכן ווב דינמי, כדוגמת PHP ו-ASP.NET.
בדרך כלל, התוכן שנוצר על ידי Servlets הם דפי HTML, אבל אלה יכולים להיות גם נתונים בצורות אחרות, כמו JSON ,XML, ועוד.
Servlets יכולים לשמור מידע אודות המצב (state) בתוך משתני session, על פני טרנזקציות שרת רבות, על ידי שימוש ב-cookies או ב-URL rewriting.
כדי לפרוס Servlet, נדרש שימוש ב-Web container (נקרא גם Servlet container) – רכיב בשרת HTTP המשמש לאינטראקציה עם ה-Servlets.
רכיב זה אחראי על ניהול מחזור החיים של servlets, ממפה בין כתובת URL ל-Servlet ספציפי, ומוודא שהבקשה הנכנסת ב-URL היא בעלת הרשאות גישה מתאימות.
ממשק תכנות היישומים Servlet המוכל ב-package בשם javax.servlet, מגדיר את האינטראקציות המצופות בין web container ל-servlet.
סרוולטים ניתנים ליצירה באופן אוטומטי מתוך (JavaServer Pages (JSP, על ידי ה-JavaServer Pages compiler.
ההבדל בין Servlets ל-JSP הוא בכך שב-Servlets משבצים קוד HTML בתוך קוד Java, ואילו ב-JSP זה הפוך, שם קוד Java משובץ בתוך קוד HTML.
אף על פי שהשימוש הישיר ב-Servlets לצורך יצירת קוד HTML הפך לנדיר, תשתית התוכנה JavaServer Faces שהיא high-level יותר לעומת Servlets ומשמשת ליצירת יישומי רשת על פי מודל ה-MVC, עדיין משתמשת מפורשות בטכנולוגיית ה-Servlet לצורך טיפול שהוא יותר low-level בבקשות ותגובות.
צורת שימוש ישנה יותר ב-Servlets, היא בצימוד לשימוש ב-JSP בתבנית הנקראת Model 2, שגם היא סוג של תבנית העיצוב MVC.
השימושים הנפוצים ב-Servletes הם לצורך:
עיבוד או אחסון נתונים שנשלחו (submitted) מתוך טופס HTML.
לספק תוכן דינמי כדוגמת התוצאה של שאילתה על בסיס נתונים.
ניהול מידע אודות המצב (state), שבאופן טבעי אינו קיים בפרוטוקול ה-HTTP שהוא כשלעצמו stateless protocol.
לדוגמה: שימור תוכן "עגלת הקניות" של מבקר באתר קניות באינטרנט, בזמן שהוא מדפדף בין דפי האתר.
Java Virtual Machine (בקיצור JVM) היא מכונה וירטואלית המפרשת ומריצה Java Bytecode.
לרוב, קוד זה מופק על ידי מהדר לשפת Java, אם כי ה-JVM יכולה לשמש גם כפלטפורמת היעד של מהדרים לשפות אחרות.
ה-JVM היא תוכנת מחשב ככל תוכנה אחרת, והיא משמשת כמעין שכבת-מיפוי בין מערכת ההפעלה לבין תוכניות הרצות על גביה.
בגרסאות המוקדמות של שפת Java, הייתה זו חברת Sun שפיתחה את ה-JVM.
בהמשך, ולאחר שמפרט ה-JVM הוגדר במדויק, חברות רבות יישמו גרסאות משלהן, אך כולן חייבות לעמוד בסדרת מבדקים (Java TCK) כדי להחשב כמימוש תקני של ה-JVM.
בנובמבר 2006, הכריזה חברת Sun כי ה-Java Platform, לרבות ה-JVM של Sun (הנקראת HotSpot), יוצעו גם תחת רישוי GPL v2. החברה הודיעה כי תמשיך להשתמש בסימן הרשום של Java (הנמצא בבעלותה) כדי להסמיך מימושים של ה-JVM התואמים באופן מלא למפרט המפורסם.
השימוש במכונה וירטואלית הוא ממאפייני היסוד של פלטפורמת Java, והוא מאפשר לתוכניות שנכתבו בשפת Java ועברו הידור באמצעות המהדר של השפה, לרוץ על מגוון רחב של פלטפורמות חומרה ומערכות הפעלה.
תכונה זו באה לידי ביטוי בסיסמתה של Java: "Write once, run anywhere" ("כתוב פעם אחת, הרץ בכל מקום"), אם כי ל-Java תכונה חזקה יותר של רב-פלטפורמיות: "הדר פעם אחת, הרץ בכל מקום".
בזכות תכונות אלה, במשולב עם השירותים הרבים שמספקת שפת Java, יש המסווגים את ה-JVM גם כתווכה.
החל מ-Java SE 5.0, שינויים במפרט ה-JVM מפותחים תחת ה-Java Community Process כ-JSR 924. מפרט ה-JVM מפורסם כספר הידוע בשם "Blue Book", ובמבוא מצוין כך (תרגום):
תוכניות המיועדות לרוץ על גבי JVM מהודרות תחילה ל-Java Bytecode, שהוא סט פקודות המכונה של ה-JVM.
פלט המהדר נשמר בפורמט בינארי מתוקנן, שבדרך כלל מסופק כקובץ .
כל מחלקה בתוכנית מהודרת לקובץ אחד, ובמקרים מסוימים אף ליותר (מחלקות פנימיות).
תוכנית תכלול בדרך כלל קובצי רבים.
כדי להקל על הפצת התוכנית, ניתן לארוז את הקבצים בקובץ jar..
קבצים אלה משמשים כקלט ל-JVM, ורצים על גביה.
בזמן הריצה, ה-JVM מפרשת או מהדרת במקום (באמצעות מהדר JIT) את הקלט לסט הפקודות המתאים של המעבד עליו רצה בפועל ה-JVM.
ברוב המימושים המודרניים של ה-JVM, נעשה שימוש נרחב בהידור במקום כדי להאיץ את מהירות הריצה של התוכנית.
ה-Java Virtual Machine מבוססת על ארכיטקטורה של מכונת מחסנית.
מאידך, מהדרי JIT מהדרים לרוב את ה-Bytecode לשפת מכונה מבוססת רגיסטרים.
לכל תהליכון (Thread) יש מחסנית ואוגר פקודה משלו.
ל-JVM יש פקודות לקבוצות המשימות הבאות:
יצירה, תפעול ותמרון של אובייקטים
פקודות ה-JVM, דהיינו, שפת המכונה שלה, מפורשות באותו האופן בכל פלטפורמות החומרה.
עם זאת, בכל פלטפורמה נדרש מיפוי שונה של פקודות אלה לפקודות המעבד הרלוונטי, ומשימה זו מוטלת על מיישמי ה-JVM בפלטפורמה.
בנוסף, ה-JVM נדרשת למפות באופן יעיל את ליבת ממשק תכנות היישומים של Java לממשק תכנות היישומים המתאים במערכת ההפעלה.
ה-JVM מאמתת את ה-Bytecode קודם להרצתו.
כלומר, רק סדרות תקינות של הוראות Bytecode יוכלו לרוץ.
לדוגמה, הוראת JUMP (הסתעפות) יכולה לכוון רק להוראה הנמצאת באותה הפונקציה.
לשימוש במאמת יש תופעת לוואי מבורכת: למרות שה-JVM מבוססת על ארכיקטורה של מחסנית, אין פגיעה בביצועים גם כאשר נעשה שימוש בהידור JIT על גבי פלטפורמות חומרה בארכיטקטורת רגיסטרים.
נוסף על כך, אימות הקוד מבטיח גם שלא יהיה ניתן להשתמש בתבניות ביטים שרירותיות ככתובות זיכרון.
בשיטה זו, אין צורך להשתמש ב-MMU כדי להגן על הזיכרון בפני השחתה שרירותית.
מכאן, שה-JVM מאפשרת יישום יעיל של זיכרון מוגן בפלטפורמות חומרה החסרות MMU.
הארכיטקטורה של מכונה וירטואלית מאפשרת פיקוח הדוק על הפעולות שקוד תוכנית מורשה לבצע.
ב-Java Virtual Machine נעשה שימוש בתכונה זו כדי לאפשר את הרצתו של קוד לא-בטוח הנטען מרחוק לתוך ה-JVM.
יישום נפוץ של תכונה זו מתבצע באמצעות Applet הנטען ל-JVM בפרוטוקול HTTP מאתר מרוחק, ומשולב בדפדפן.
ה-Applet רץ בארגז חול המונע מהיישום להזיק למחשבו של המשתמש.
מפרסם הקוד יכול לחתום דיגטילית על ה-Applet ובכך לאפשר לו, לאחר אישור המשתמש, לגשת למשאבים מקומיים במחשב, כגון מערכת הקבצים.
אחד מהמנגנונים המרכזיים שמספקת ה-JVM הוא ניהול זיכרון ממוכן (ידוע גם בשם "איסוף זבל").
מנגנון זה אחראי לרשום ולאתר במרחב הזיכרון שהוקצה לתוכנה אובייקטים שאינם בשימוש, ולתבוע בחזרה את המקום שתפסו.
הניהול הממוכן של הזיכרון מקל באופן משמעותי על התכנות בשפת Java ומגביר מאוד את אמינות היישומים.
להלן ה-Bytecode של תוכנית פשוטה ב-Java המדפיסה .
Jazz (בעברית: ג'אז) הוא אלבומם השביעי של להקת הרוק קווין שיצא בשנת 1978. אלבום זה הורכב משילוב של סגנונות מוזיקליים: דיסקו-פאנק ("Fun it"), סגנון בידורי ("Dreamer's Ball"), הבי מטאל ("Dead On Time"), רוק כבד ("Fat Bottomed Girls").
למרות שמו, האלבום אינו כולל מוזיקת ג'אז למעט קטע בשיר "Dreamer's Ball".(למעשה אחד הפירושים למלה jazz באנגלית הוא התלהבות) האלבום הגיע למקום השישי במצעד מכירות התקליטים בארצות הברית.
הלהקה התכוונה להפיץ את האלבום בצירוף כרזה המתארת מרוץ אופניים בו משתתפות רק נשים עירומות אשר בוים לצורך קידום המכירות שלו, אך הדבר לא יצא לפועל בארצות הברית.
ניתן היה להזמין את הכרזות דרך הדואר וגרסה מוקטנת של הכרזה הופצה באחד מאלבומי האוסף שיצאו לאור אחרי מותו של פרדי מרקיורי בשנת 1991.
ברשימת ה"תודות" בתקליט, ישנה תודה ל"הרעם באדיבותו של אלוהים" (הרעם עצמו נמצא בשיר "Dead On Time").
עיצוב עטיפת האלבום הוצע על ידי רוג'ר טיילור לאחר שראה עיצוב דומה על חומת ברלין.
כל השירה מבוצעת על ידי פרדי מרקיורי, למעט:
קולות ליווי מבוצעים על ידי קווין, למעט:
פעמונה ב-'Don't Stop Me Now': טיילור
כל הכלים (תופים, בס, גיטרות ומראקה) וכמו כן כל הקולות ב-'More Of That Jazz': טיילור
גיטרות אקוסטיות: מיי, למעט השיר "Seven Days" (דיקון)
Java 3D הוא ממשק תכנות יישומים לגרפיקת תלת-ממד בשפת התכנות Java.
הממשק פותח על ידי חברת סאן מיקרוסיסטמס.
בניגוד לפתרונות דומים, Java 3D אינו רק מעטפת לממשקי תכנות יישומים אחרים אלא ממשק מונחה-עצמים טהור ורב-פלטפורמי.
בעזרת Java 3D ניתן להציג נתונים מדעיים, תמונות רפואיות, אנמיציות, משחקים ועוד.
ניתן גם לייבא מודלים תלת־ממדיים בפורמטים שונים (כגון 3DS,OBJ, OpenFlight, VRML ועוד) לתוכנית Java3D.
Java 3D נשען על OpenGL או על DirectX כאשר ברירת המחדל היא OpenGL, לכן הוא נחשב כשפה עילית עבור הטלות ובניית אובייקטים תלת־ממדיים.
ל-Java 3D יש מנוע ממוטב המחשב את ההטלות ואת סדר ההטלות של האובייקטים למסך המחשב (תהליך הנקרא rendering) אך אפשר גם לשלוט בסדר הרינדור אך זה פחות מומלץ.
כל האובייקטים הגאומטריים חיים בעולם ווירטואלי.
ל- Java 3D יש מחלקה הנקראת VirutalUniverse שבעזרתו היא קושרת את כל האובייקטים, והעולם הווירטואלי מוטל על גבי צג המחשב.
Java 3D מבוסס על מבני נתונים הנקרא גרף התרחשות (scene graph).
זהו מבנה נתונים מכוון אשר פתוח, זאת אומרת אין אפשרות לחזור לצומת.
כל צומת בגרף היא עצם.
הגרף, בצורה כללית מתחלק לשני חלקים עיקריים:
ענף התוכן (content branch graph) - ענף הכולל מחלקות הקשורות לתוכן העולם הווירטואלי.
ענף הראייה (view branch graph) - ענף הכולל מחלקות שקשורות לאוריינטציה וזוויות המסתכל.
כמו כן ישנם מחלקות בענף זה הקשורות להתקנים חיצוניים.
כיום Java3D אינה חלק מ-JAVA 6 וצריך להתקינה בנפרד.
Java Web Start (בראשי תיבות: JWS) היא טכנולוגיה אשר פותחה על ידי חברת סאן מיקרוסיסטמס המאפשרת הפעלת אפליקציית Java באתר אינטרנט באמצעות הדפדפן.
בניגוד ל-JWS, Applet לא רץ בתוך הדפדפן, ולאפליקציה יש פחות הגבלות מאשר Applet.
כל אפליקציית Java יכולה לרוץ באמצעות JWS כל עוד שרת האינטרנט שמציע את האפליקציה יכול לעבוד עם הטכנולוגיה הזאת וקובצי ה-JAR השונים שמרכיבים את האפליקציה נמצאים בשרת.
צריך לכתוב קובץ קונפיגורציה מיוחד עבור JWS שאומר ל-JWS לטעון את התוכנית.
קובץ הקונפיגורציה משתמש ב-Java Network Launching Protocol (JNLP), הרחבה של קובץ XML שכולל בתוכו פרטים על האפליקציה כגון: המחלקה הראשית וקובצי ה-JAR.
על מנת ליצור אפליקציה שתרוץ תחת JWS, יש לבצע את הפעולות הבאות:
המתכנת אוסף את כל הקוד שכתב (יחד עם קבצים חיצוניים כגון תמונה או קול) לקובץ JAR אחד יחד עם קובץ JNLP, שזהו חלק מ-JWS.
צריך קישור בדף האינטרנט לקובץ.
המשתמש טוען את דף האינטרנט ולוחץ על הקישור לקובץ שנוצר בפעולה מספר 1.
סביבת הריצה של Java (JRE) מתקינה ומריצה את האפליקציה.
התוכנית נשמרת בזיכרון המחשב כך שאין צורך להתקין אותה שוב.
JavaFX הוא שם כולל לחבילת תוכנה ליצירת יישומי אינטרנט עשירים, מערכות סלולריות, טלוויזיה ומערכות מולטימדיה לרכבים.
גרסת אלפא של JavaFX שוחררה במהלך ועידת JavaOne בסן פרנסיסקו, במאי 2007, כמשפחת מוצרים שבמרכזה שפת תסריט מבוססת ג'אווה - JavaFX Script.
שנה אחר, במאי 2008, הושקה הגרסה הרשמית הראשונה בפברואר 2009 הושקה JavaFX Mobile, שכבת תוכנה שמיועדת לטלפונים ניידים, שבה אפשר להריץ תוכניות שנכתבו ב-JavaFX.
החל ב-JavaFX 2.0 בוטלה התמיכה בה.
החל מאוגוסט 2012 JavaFX נתמכת בלינוקס.
JavaFX משולבת עם JRE כך שאפשר לכלול בתוך תוכנית JavaFX גם מחלקות שנכתבו ב-Java.
JavaFX כללה גם תמיכה ב-JavaFX Script, שפת סקריפט דקלרטיבית מונחית עצמים, המאפשרת בניית ממשקי משתמש עשירים המבוססים על Swing.
JavaFX Script התמקדה בחוויית המשתמש, ובמיוחד ביכולות אנימציה מתקדמות וכשפה קלה יותר לשימוש ביחס לשפות אחרות.
JavaServer Faces (ראשי תיבות: JSF) הוא מפרט לפיתוח ממשקי משתמש עבור יישומי רשת הכתובים בשפת Java.
אף על פי ש-JSF בנויה על גבי טכנולוגיית ה-JSP, היא מציעה למפתח מודל השונה מ-JSP ומ-Servlets, של בקשה ותגובה (HTTP Request/Response).
העיקרון המנחה ב-JSF הוא שימוש ברכיבי תוכנה (components) בתוך דפי היישום.
רכיבים אלו מקושרים לאובייקטים בשרת ושומרים על ערכם בצורה אוטומטית.
עיקרון זה חוסך הרבה קוד Java בדפים ובכך מאפשר הפרדה בין שכבת התצוגה (view) לשכבת הבקר (controller) ושכבת הלוגיקה העסקית (business logic).
כך נשמר מודל MVC ועל כן פיתוח היישום פשוט יותר.
ל-JSF ישנם מימושים רבים, אך המימוש הנפוץ ביותר נכון לתחילת העשור השני של המאה ה-21 הוא של חברת אורקל, שירש את המימוש של סאן.
פלטפורמת התוכנה ג'אווה היא מכלול מוצרי תוכנה ומפרטים של חברת סאן מיקרוסיסטמס (כיום חברת בת של חברת אורקל), אשר ביחד מרכיבים מערכת לפיתוח יישומים ולפריסתם על גבי פלטפורמות שונות (cross-platform).
ג'אווה נמצאת בשימוש במגוון רחב של פלטפורמות מחשוב, החל במערכות משובצות מחשב וטלפונים סלולריים וכלה בשרתים ומחשבי-על.
כתיבה בשפת התכנות Java היא הדרך העיקרית ליצירת קוד שיעבור הידור ל-Java bytecode, שפת ביניים הניתנת להרצה על גבי כל פלטפורמה שקיים עבורה מימוש של המכונה הווירטואלית של ג'אווה - JVM.
קיימים גם מהדרי bytecode עבור שפות אחרות, כגון Ada, JavaScript, Python ו-Ruby.
כמו כן פותחו גם כמה שפות חדשות המיועדות לרוץ על גבי ה-Java Virtual Machine, כגון: Scala, Clojure ו-Groovy.
התחביר של שפת Java הושפע רבות מהשפות C ו-++C, אבל עקרונות התכנות מונחה-עצמים ב-Java מבוססים על השפות Smalltalk ו-Objective-C.
בג'אווה לא נעשה שימוש במבנים ברמה הנמוכה (low-level) כגון מצביעים, ויש לה מודל זיכרון פשוט מאוד שבו כל אובייקט מוקצה על גבי ה-Heap, וכל המשתנים של טיפוסים מורכבים הם references.
ניהול הזיכרון מבוצע באמצעות איסוף זבל אוטומטי על ידי ה-JVM.
בשנת 2006 הפכה סאן מיקרוסיסטמס את מרבית המימוש של ג'אווה לזמין תחת הרישיון הציבורי הכללי של גנו, אם כי ישנם עדיין חלקים המופצים כקבצים בינאריים שהודרו מראש בעקבות בעיות זכויות יוצרים.
הפלטפורמה של ג'אווה אינה ספציפית לסוג מעבד או מערכת הפעלה מסוימים.
הפלטפורמה מורכבת ממנוע להרצת תוכניות (אשר נקרא מכונה וירטואלית), מהדר, וקבוצה של ספריות תוכנה הממומשות עבור מגוון סוגי חומרה ומערכות הפעלה שונות, כך שתוכניות ג'אווה תוכלנה לרוץ באופן זהה בכל סביבה .
הפלטפורמה מורכבת מכמה תוכנות, שכל אחת מהן מספקת חלק מהיכולות הכוללות של הפלטפורמה.
לדוגמה, המהדר של ג'אווה, אשר ממיר קוד מקור של ג'אווה ל-Java bytecode (שפת ביניים עבור המכונה הווירטואלית של ג'אווה - JVM), מסופק כחלק מה-Java Development Kit.
סביבת ההרצה של ג'אווה (Java Runtime Environment) משלימה את ה-JVM עם מהדר ה-just-in-time שממיר בזמן ריצה (on the fly) את קוד הביניים bytecode לשפת מכונה (native code).
כמו כן מסופקות ספריות נרחבות שמכילות רכיבים נוספים, חלקם זמינים רק עבור מהדורות מסוימות.
הרכיבים החיוניים בפלטפורמה הם: המהדר לשפת Java, הספריות, וסביבת ההרצה (JRE) שבה קוד הביניים Java bytecod "רץ" בהתאם לכללים המוכתבים על ידי המפרט של המכונה הווירטואלית.
נכון לחודש ספטמבר 2020, הגרסה העדכנית של פלטפורמת ג'אווה היא 15.0.0 או 15 (שני המספרים מציינים את אותה הגרסה).
גרסה 15 היא גרסת המוצר ו-15.0.0 היא גרסת הפיתוח.
המכונה הווירטואלית של ג'אווה – (Java Virtual Machine (JVM
לבהּ של הפלטפורמה של ג'אווה היא "מכונה וירטואלית" אשר מריצה תוכניות Java bytecode, ה-bytecode זהה לכל סוגי החומרה ומערכות ההפעלה שהוא רץ תחתן.
במכונה הווירטואלית של ג'אווה (JVM) ישנו אשר מתרגם בזמן ריצה את ה-Java bytecode להוראות מעבד בשפת מכונה (native code), ושומר את ה-native code בזיכרון המטמון (cache) למשך זמן הריצה של התוכנית.
השימוש ב-bytecode כשפת ביניים מאפשר לתוכניות לרוץ על גבי כל פלטפורמה שקיים עבורה מימוש של המכונה הווירטואלית.
בזכות השימוש במהדר JIT, לאחר עיכוב קצר לצורך טעינה של התוכניות, וכשהן "מתחממות" לאחר שכל הקוד שלהן או רובו עבר הידור JIT, תוכניות Java נוטות לרוץ בערך באותה המהירות כמו תוכניות native שעברו הידור מקדים לשפת מכונה.
מאז גרסה 1.2 של ה-JRE, מימוש ה-JVM של סאן כולל מהדר just-in-time במקום מפרש.
הקוד של ה-JVM שמריצה את התוכניות הללו תלוי בפלטפורמה - קיים מימוש שונה של ה-JVM עבור כל מערכת הפעלה שתומכת בג'אווה.
מרבית מערכות ההפעלה המודרניות מספקות גופי קוד גדולים הניתנים לשימוש חוזר, על מנת להקל על עבודת המתכנת.
בדרך כלל הקוד הזה מסופק בצורה של ספריות הניתנות לטעינה דינאמית, שיישומים יכולים לקרוא להן בזמן ריצה.
כיוון שהפלטפורמה של ג'אווה אינה תלויה במערכת הפעלה מסוימת, יישומי ג'אווה אינם יכולים להסתמך על שום ספרייה של מערכת ההפעלה שנכתבה מראש.
במקום זאת, הפלטפורמה של ג'אווה מספקת קבוצה מקיפה של ספריות סטנדרטיות משלה, שנקראות class libraries, אשר מכילות את רוב הפונקציות הניתנות לשימוש חוזר, שבדרך כלל ניתן למצוא במערכות הפעלה מודרניות.
מרבית הספריות של ג'אווה ממומשות בשפת ג'אווה גם כן.
לדוגמה, הספרייה Swing מציירת את ממשק המשתמש ומטפלת באירועים בעצמה, ובכך מבטלת הרבה מההבדלים הקטנים הקיימים בדרך שבה פלטפורמות שונות מטפלות אפילו ברכיבים דומים.
ה-class libraries משרתות שלוש מטרות בפלטפורמה של ג'אווה.
הראשונה, כמו במקרה של ספריות קוד סטנדרטיות אחרות - הספריות של ג'אווה מספקות למתכנת קבוצת פונקציות מוכרות היטב, לצורך ביצוע של משימות נפוצות, כגון תחזוקה של רשימות פריטים או ביצוע ניתוח מחרוזות (parsing) מורכב.
המטרה השנייה של ספריות ג'אווה היא לספק ממשק אבסטרקטי עבור משימות שבדרך כלל תלויות מאוד בחומרה ובמערכת ההפעלה.
משימות כגון גישה לרשת וגישה לקבצים בדרך כלל "מסובכות" עם המימושים הייחודיים של כל פלטפורמה.
הספריות java.net ו-java.io מממשות שכבת אבסטרקציה בקוד native למערכת ההפעלה, ולאחר מכן מספקות ממשק סטנדרטי עבור יישומי ג'אווה, לצורך ביצוען של המשימות הללו.
ולבסוף, כאשר פלטפורמת בסיס מסוימת אינה תומכת בכל התכונות שיישום ג'אווה מצפה להן, הספריות של ג'אווה פועלות כדי לכסות בצורה אלגנטית על הרכיבים החסרים, באמצעות אמולציה על מנת לספק תחליף, או לפחות על ידי מתן דרך עקבית לבדוק האם תכונה מסוימת קיימת או לא.
מהדורות ג'אווה - Java Editions
מהדורה (edition) של Java platform היא חבילת תוכנות מקושרות של סאן, המאפשרות פיתוח והרצה של תוכניות שנכתבות בשפת התכנות Java.
(Java SE (Standard Edition - מיועדת לשימוש כללי על גבי מחשבים אישיים, שרתים ומכשירים דומים.
(Java EE (Enterprise Edition - מורכבת מ-Java SE בצירוף ממשקי תכנות יישומים השימושיים לפיתוח תוכנות enterprise בארכיטקטורת שרת-לקוח רב-שכבתית.
(Java ME (Micro Edition - מפרט של כמה קבוצות שונות של ספריות (נקראות profiles), עבור מכשירים בעלי שטח אחסון, תצוגה וכוח מוגבלים.
משמשת בעיקר לפיתוח יישומים למכשירים ניידים, מחשבי כף יד, ממירי טלוויזיה דיגיטליים ומדפסות.
Java Card - טכנולוגיה המאפשרת לתוכניות קטנות מבוססות ג'אווה (applets) לרוץ בצורה בטוחה על גבי כרטיסים חכמים ומכשירים דומים בעלי זיכרון מצומצם.
המילה Java לבדה בדרך כלל מתייחסת לשפת התכנות Java אשר תוכננה לשימוש עם הפלטפורמה של Java.
בדרך כלל שפות תכנות אינן נכללות בתחום המושג "פלטפורמה", אבל שפת התכנות Java נחשבת לאחד מרכיבי הליבה בפלטפורמת Java.
לפיכך, השפה וסביבת ההרצה (runtime) בדרך כלל נחשבות ליחידה אחת.
עם זאת, קיימים גם מהדרים ומפרשים עבור ה-JVM, אשר פותחו על ידי חברות צד שלישי.
חלקם מיועדים עבור שפות קיימות, בעוד שאחרים הם עבור הרחבות לשפת Java.
BeanShell – שפת סקריפטים קלה לג'אווה.
ערכת הפיתוח של ג'אווה (JDK) היא מוצר של סאן המיועד עבור מפתחי ג'אווה.
מאז הופעתה של ג'אווה, ה-JDK הייתה ערכת פיתוח התוכנה (Software Development Kit, SDK) הנפוצה ביותר עבור ג'אווה.
ה-JDK כוללת מהדר לשפת Java, עותק מלא של סביבת ההרצה של ג'אווה (JRE), והרבה כלי פיתוח חשובים נוספים.
הפלטפורמה של ג'אווה ושפת ג'אווה החלו את דרכן כמיזם פנימי בחברת סאן מיקרוסיסטמס בדצמבר 1990, במטרה ליצור אלטרנטיבה לשפות התכנות C ו-++C.
המהנדס פטריק נוטון היה מתוסכל ממצבם של ממשקי תכנות היישומים של סאן בשפות C ו-++C.
בזמן ששקל לעזוב לחברת NeXT, נוטון קיבל הזדמנות לעבוד על יצירת טכנולוגיה חדשה, וכך החל ה"פרויקט החשאי" (Stealth Project).
זמן קצר לאחר מכן, שמו של "הפרויקט החשאי" שונה ל"הפרויקט הירוק" (Green Project), עם ג'יימס גוסלינג ומייק שרידן שהצטרפו אל נוטון.
ביחד עם מהנדסים נוספים, הם החלו את עבודתם בעיר מנלו פארק שבקליפורניה.
הם ניסו לפתח טכנולוגיה חדשה לתכנות הדור הבא של מכשירים חכמים (smart appliances), שסאן ציפתה שיפתחו עבורה הזדמנויות חדשות.
בהתחלה, הצוות שקל להשתמש ב-++C, אבל הרעיון נדחה ממספר סיבות.
כיוון שהם פיתחו מערכות משובצות מחשב בעלות משאבים מצומצמים, הם החליטו ש-++C תדרוש יותר מדי זיכרון ושהמורכבות שלה תוביל לשגיאות פיתוח.
מכיוון שב-++C אין איסוף זבל, על המתכנת לדאוג לנהל את זיכרון המערכת בעצמו, וזוהי משימה לא פשוטה שלעיתים קרובות גוררת שגיאות.
לצוות הפיתוח הפריע גם שב-++C חסרות יכולות כגון אלמנטים ניידים (portable facilities) לצורכי אבטחה, תכנות מבוזר ושימוש בתהליכונים.
ולבסוף, הם רצו פלטפורמה שניתן יהיה להעביר אותה בין כל סוגי המכשירים.
ביל ג'וי חזה שֹפה חדשה המשלבת בין השפות Mesa ו-C.
במאמר תחת הכותרת Further ("הלאה"), הוא הציע לסאן שהמהנדסים שלה יפתחו סביבה מונחית-עצמים המבוססת על ++C.
בהתחלה גוסלינג ניסה לשנות ולהרחיב את ++C (מה שהוא קרא לו "-- ++ ++C"), אבל עד מהרה זנח את הרעיון לטובת יצירת שפה חדשה, שהוא קרא לה Oak (עץ אלון), על שם העץ שעמד מחוץ למשרד שלו.
בקיץ של שנת 1992, המפתחים כבר יכלו להציג חלקים מהפלטפורמה החדשה, שכללה את מערכת ההפעלה Green, שפת Oak, ספריות תוכנה וחומרה.
הניסיון הראשון שלהם, שהוצג ב-3 בספטמבר 1992, התמקד בבניית מחשב כף יד (PDA) שנקרא Star7, שכלל ממשק משתמש גרפי וסוכן חכם בשם Duke שתפקידו לסייע למשתמש.
בחודש נובמבר של אותה שנה, Green Project התפצל מסאן מיקרוסיסטמס והפך לחברת בת שלה בשם firstperson.
בשלב זה הצוות עבר לפאלו אלטו, קליפורניה.
הצוות של firstperson שאף לבנות מכשירים אינטראקטיביים מאוד, וכאשר חברת טיים וורנר פרסמה מכרז לקבלת הצעה עבור ממיר טלוויזיה דיגיטלי (set-top box), חברת firstperson שינתה את המטרה שלה והגיבה עם הצעה עבור פלטפורמה לממיר דיגיטלי.
עם זאת, תעשיית הכבלים הרגישה שהפלטפורמה של firstperson נתנה יותר מדי שליטה למשתמש, ו-firstperson הפסידו במכרז לטובת חברת Silicon Graphics.
עסקה נוספת עם חברת 3DO עבור ממירים דיגיטליים נכשלה אף היא.
לאחר שלא הצליחה ליצור עניין בקרב תעשיית הטלוויזיה, חברת firstperson אוחדה חזרה עם סאן מיקרוסיסטמס.
בחודש יוני 1994, לאחר שלושה ימים של סיעור מוחות עם ג'ון גייג', המדען הראשי של סאן, גוסלינג, ג'וי, נוטון, וויין רוסינג ואריק שמידט, הצוות תכנן את הפלטפורמה מחדש, והפעם ייעד אותה עבור ה-World Wide Web.
הם הרגישו שעם התפתחותם של דפדפנים גרפיים כמו מוזאיק, האינטרנט היה בדרכו להפוך למדיום אינטראקטיבי מאוד, כפי שהם צפו קודם לכן שהטלוויזיה בכבלים תהפוך להיות.
כאַב טיפוס, נוטון פיתח דפדפן קטן בשם WebRunner (הקרוי על שם הסרט בלייד ראנר).
מאוחר יותר שמו של הדפדפן שונה ל-HotJava.
באותה שנה, שמה של השפה Oak שונה ל-Java, לאחר שהתגלה כי השם Oak כבר היה תפוס כסימן מסחרי על ידי חברת Oak Technology.
ב-9 בינואר 1996, סאן מיקרוסיסטמס יסדה את קבוצת JavaSoft שמטרתה להמשיך בפיתוח הטכנולוגיה.
על פי אורקל, סביבת ההרצה של ג'אווה (Java Runtime Environment - JRE) נמצאת בלמעלה מ-850 מיליון מחשבים אישיים.
מיקרוסופט הפסיקה לספק את ה-JRE עם מערכות ההפעלה שלה אחרי שסאן מיקרוסיסטמס תבעה אותה על כך שהוסיפה מחלקות ייעודיות עבור Windows לתוך סביבת ההרצה של ג'אווה שהיא סיפקה, ועל כך שהפכה את המחלקות החדשות הללו לזמינות דרך שפת התכנות ++J.
כיום משתמש המעוניין להריץ יישומי ג'אווה ב-Windows צריך להוריד ולהתקין בחינם את סביבת ההרצה של ג'אווה מהאתר של אורקל.
סביבת ההרצה של ג'אווה מסופקת ביחד עם מערכת ההפעלה Mac OS X של אפל, והפצות רבות של לינוקס כוללות את חבילת התוכנות החופשיות GNU Classpath, אשר תואמות חלקית למפרט הרשמי של ג'אווה, ומספר הולך וגדל של הפצות כוללות את חבילת IcedTea התואמת ברובה למפרט הרשמי.
מבין יישומי ג'אווה הנמצאים בשימוש נפוץ יחסית במחשבים אישיים נכללות סביבות הפיתוח המשולבות IntelliJ IDEA ,NetBeans ,Eclipse מבית JetBrains והתוכנות לשיתוף קבצים LimeWire ו-Vuze.
ג'אווה משמשת גם בתוכנה המתמטית MATLAB, הן עבור יצירת ממשק המשתמש והן בליבת המערכת.
כמו כן ג'אווה משמשת ליצירת ממשקי משתמש חוצי-פלטפורמות (cross-platform) עבור יישומי שיתוף פעולה כגון Lotus Notes.
Java ME הפכה לפופולרית במכשירים ניידים, שם היא מתחרה בסימביאן, BREW ו-NET Compact Framework..
ריבוי היצרנים של טלפונים סלולריים הוביל לצורך בסט סטנדרטים מאוחד, כך שתוכניות תוכלנה לרוץ על גבי טלפונים של יצרנים שונים.
לצורך כך נוצר ה-MIDP – Mobile Information Device Profile – מפרט עבור השימוש בג'אווה במכשירים עם מערכות משובצות מחשב כגון טלפונים סלולריים ומחשבי כף יד.
הסטנדרט הראשון היה MIDP 1, אשר תוכנן עבור מכשירים בעלי מסך קטן, ללא גישה לאודיו ולתוכניות המוגבלות לגודל של עד 32KB.
המפרט החדש יותר, MIDP 2, מאפשר גישה לאודיו ותוכניות בגודל של עד 64KB.
כיוון שיכולות הטלפונים משתפרות מהר יותר מקצב עדכון הסטנדרטים, חלק מיצרני הטלפונים מורידים חלק מהמגבלות המוטלות על ידי הסטנדרטים, לדוגמה, את מגבלת הגודל המקסימלי של תוכניות.
מערכת ההפעלה אנדרואיד של גוגל משתמשת בשפת ג'אווה, אבל לא בספריות של ג'אווה, לפיכך פלטפורמת האנדרואיד אינה יכולה להקרא ג'אווה.
אנדרואיד מריצה את הקוד על גבי המכונה הווירטואלית Dalvik במקום ה-JVM.
שימוש במערכות ארגוניות ובשרתי רשת
מאז הצגת ה-Enterprise Edition בשנת 1998, הפלטפורמה של ג'אווה הפכה לאחד מהיסודות המרכזיים בפיתוח טכנולוגיות מידע בתחום ה-enterprise (מערכות תוכנה המיועדות לשימוש בארגונים גדולים), משתי סיבות:
באמצעות החיבור בין ג'אווה לשרתי רשת, הפלטפורמה של ג'אווה הפכה לפלטפורמה המובילה לאינטגרציה בין ה-web למערכות enterprise אחוריות (backend systems).
זה אפשר לחברות להעביר חלקים מהעסק שלהן או את כולו לסביבת האינטרנט, באמצעות שימוש בסביבות אינטראקטיביות מקוונות (כגון אתרי אינטרנט דינאמיים), אשר מאפשרות ללקוח גישה ישירה לתהליך העסקי (לדוגמה, אתרי אינטרנט בנקאיים, מערכות אונליין להזמנת כרטיסי טיסה וכו').
מגמה זו המשיכה להתפתח מההתחלה מבוססת-הווב:
הפלטפורמה של ג'אווה הבשילה לכדי שימוש כתשתית לפיתוח אינטגרציה ארגונית, שבה מערכות מורשת נפתחות אל העולם החיצון באמצעות בניית גשרים על הפלטפורמה של ג'אווה.
מה שתרם למגמה זו היא התמיכה של הפלטפורמה של ג'אווה בסטנדרטים של Enterprise Application Integration כגון העברת מסרים (messaging), ו-Web services.
ג'אווה הפכה לפלטפורמת הפיתוח הסטנדרטית במחלקות טכנולוגיית המידע של חברות רבות, אשר מבצעות את מרבית או את כל הפיתוח העסקי שלהן בג'אווה.
פיתוח מסוג כזה בדרך כלל מתייחס ליצירת כלים ספציפיים לחברה (לדוגמה, מערכת להזמנת כרטיסי טיסה).
הבחירה בפלטפורמה של ג'אווה מוּנעת לעיתים קרובות על ידי השאיפה לנצל תשתית קיימת בג'אווה, לצורך יצירת כלים חכמים המקושרים ביניהם.
הפלטפורמה של ג'אווה הפכה לפלטפורמת הפיתוח העיקרית עבור הרבה כלי תוכנה ופלטפורמות המיוצרים על ידי חברות צד-שלישי (כמוצרים מסחריים או בקוד פתוח או כשילוב בין השניים).
חברות משתמשות במוצרים אלה ככלים הניתנים לקונפיגורציה (configurable), להבדיל ממוצרים הדורשים תכנות (programmable).
דוגמאות מקטגוריה זו כוללות שרתי רשת, שרתי יישומים, מסדי נתונים, enterprise service buses, כלים ל-Business Process Management ומערכות לניהול תוכן.
שימושי Enterprise בג'אווה הפכו גם לגורם המרכזי לעניין שמגלה קהילת הקוד הפתוח בפלטפורמה.
עניין זה הוביל ליצירת מספר גדול של תוכנות, הכוללות ספריות של פונקציות פשוטות, תשתיות פיתוח כגון: Spring Framework, Apache Wicket, Dojo Toolkit, Hibernate, ומימושים בקוד פתוח של סטנדרטים וכלים כגון: אפאצ'י טומקט, GlassFish, Mule, Apache ServiceMix.
בימים המוקדמים של ג'אווה (לפני המימוש של המכונה הווירטואלית HotSpot בגרסה 1.3 של ג'אווה בשנת 2000), נמתחה ביקורת על הביצועים שלה.
נכון לשנת 2012, באופן כללי אין יותר בסיס לביקורת זו.
הודגם כי ג'אווה רצה במהירות דומה לקוד native (בשפת מכונה) שעבר אופטימיזציות.
מדידות ביצועים של מימושים מודרניים של ה-JVM הראו כי זוהי אחת מפלטפורמות השפה המהירות ביותר הזמינות כיום – בדרך כלל איטית רק במעט לעומת ++C/C.
הביצועים של ג'אווה השתפרו משמעותית לעומת הגרסאות המוקדמות.
בכמה מבחנים הודגם כי הביצועים של מהדרי JIT דומים למדי לביצועים שמתקבלים ממהדרים לשפת מכונה.
את ה-Java bytecode ניתן לפרש בזמן ריצה על ידי מכונה וירטואלית, או שניתן להדר אותו בזמן הטעינה או בזמן הריצה לקוד native שרץ ישירות על גבי החומרה של המחשב.
פירוש הוא איטי מביצוע של קוד native, והידור בזמן הטעינה או בזמן הריצה מביא לירידה התחלתית בביצועים לצורך ביצוע ההידור.
כל המימושים המודרניים של ה-JVM נוקטים בגישת ההידור, וכך לאחר זמן ראשוני לצורך אתחול, הביצועים הם שווי ערך לאלה של קוד native.
הצלחתהּ של Java ושל גישת ה-"כְּתוֹב פעם אחת, הָרֶץ בכל מקום" (write once, run anywhere) שלה, הובילו למיזמים דומים נוספים, שהבולט שבהם הוא פלטפורמת NET.
(דוט-נט) של מיקרוסופט, שהופיעה בשנת 2002 ומשלבת הרבה מההיבטים המוצלחים של Java.
דוט-נט בצורתה השלמה (במימוש של מיקרוסופט) הייתה זמינה במקור רק עבור פלטפורמות Windows, בעוד ש-Java זמינה במלואה עבור פלטפורמות שונות רבות.
דוט-נט נבנתה במטרה לתמוך במגוון שפות תכנות, בעוד שהפלטפורמה של Java נבנתה בהתחלה במטרה לתמוך רק בשפת Java, אם כי מאז פותחו עוד הרבה שפות ל-JVM.
דוט-נט כללה במקור שפה דמוית-ג'אווה שנקראה #Visual J (ויז'ואל ג'יי שארפ; לפני כן היא נקראה ++J), שאינה תואמת את המפרט של Java.
ספריית הקוד של #Visual J תואמת בעיקר לגרסה 1.1 הישנה של ה-JDK.
מסיבות אלה, השפה הזאת מהווה יותר שפת-מעבר מ-Java לפלטפורמת הדוט-נט, מאשר שפת דוט-נט מדרגה ראשונה.
העבודה על #Visual J הופסקה עם השחרור של Microsoft Visual Studio 2008. מיקרוסופט המשיכה לתמוך בגרסה הקיימת של #Visual J שהופצה עם Visual Studio 2005 עד לשנת 2015.
זוהי פלטפורמת ג'אווה המשמשת ליצירת יישומים חוצי-פלטפורמות המיועדים לשימוש כללי.
Java SE מורכבת מהמכונה הווירטואלית של ג'אווה (JVM) אשר נדרשת להרצת תוכניות ג'אווה, ביחד עם קבוצת ספריות תוכנה הנדרשות כדי לאפשר לתוכניות אלה להשתמש במערכות קבצים, ממשקים גרפיים, גישה לרשת, וכדומה.
ה-"SE" משמש כדי להבחין בין הפלטפורמה ה"סטנדרטית" לבין הפלטפורמות Java EE ו-Java ME.
במקור, ה-"2" נועד כדי להדגיש את השינויים הגדולים שהוצגו בגרסה 1.2, אבל השימוש בו הופסק בגרסה 1.6.
JAVA ONE הוא כנס שנתי של משתמשי ומפתחי שפת התכנות Java ושל תוכנות שכתובות בה.
בכנס מתאגדים מפתחי ומשתמשי הג'אווה ודנים בפיתוחי הטכנולוגיה העדכניים.
הכנס אורגן על ידי חברת סאן מיקרוסיסטמס, ולאחר רכישתה על ידי חברת אורקל.
בשנת 1996 החלה מסורת ההתכנסות הכוללת מצגות ממוקדות, תערוכות ומיצגים.
הכנס נערך בעיר סן פרנסיסקו, בדרך כלל בין הימים שני לחמישי, ועלות ההשתתפות נעה בין 1,795$ ל-1,995$.
במשך היום ההרצאות עוסקות בנושאים טכניים בעיקר ובערבים מתקיימים דיוני "Birds of a feather" – דיונים הנערכים במסגרת הכנס, אך לא כוללים סדר יום מאורגן מראש.
דיונים אלה מאפשרים למשתתפים לעסוק בתחומים המעניינים אתם ולהתמקד באספקטים מסוימים של טכנולוגיית הג'אווה שלא דנו בהם בדיונים הפורמליים בכנס.
בשנת 1999 גון גייג' עמד בראש כנס ההאקאתון.
באותו אירוע הוצב אתגר בפני הנוכחים אשר התבקשו לכתוב תוכנה המאפשרת תקשורת ג'אווה בין מכשיר הפאלם לאינטרנט בעזרת מסוף אינפרא אדום.
בשפת התכנות ג'אווה, JavaBeans (ג'אווה בינז, באנגלית bean: פול קפה או שעועית) הם רכיבי תוכנה הניתנים לשימוש חוזר.
אלו הן מחלקות הנכתבות בשפת ג'אווה ומשמשות כדי לכמס הרבה אובייקטים בתוך אובייקט אחד (ה-bean), כך שניתן יהיה להעביר אותם ממקום למקום כאובייקט bean אחד, במקום הרבה אובייקטים בודדים.
על מנת לתפקד כ-JavaBean, המחלקה חייבת להיבנות לפי מספר קונבנציות (מוסכמות) הנוגעות למתן השמות למתודות, יצירת מופעים והתנהגות.
קונבנציות אלו מאפשרות יצירת כלים אשר יכולים להשתמש ב-JavaBeans, להחליף ביניהם, לחבר ביניהם וכדומה.
JavaBean היא מחלקת ג'אווה העונה על שלוש הדרישות הבאות:
האובייקט ניתן לסריאליזציה (המחלקה מממשת את הממשק Serializable).
זה מאפשר ליישומים חיצוניים ולתשתיות תוכנה (frameworks) לשמור, לאחסן ולשחזר את המצב של ה-bean בצורה אמינה, ללא תלות במכונה הווירטואלית והפלטפורמה.
למחלקה יש בנאי שאינו מקבל ארגומנטים (no arguments constructor).
דבר זה מאפשר יצירה והפעלה פשוטים של מופעים של המחלקה באמצעות תשתיות תוכנה.
קיימת גישה למשתני המחלקה (properties) באמצעות מתודות get ו-set (מתודות mutator).
למתודות אלה ניתנים שמות העונים על קונבנציה סטנדרטית למתן שמות.
לדוגמה, עבור משתנה מחלקה בשם name ייווצרו המתודות getName ו-setName.
למשתני מחלקה מטיפוס boolean, מתודת ה-get מוחלפת במתודה המתחילה ב-is.
לדוגמה, עבור משתנה מחלקה בשם empty מטיפוס boolean תהיה קיימת המתודה isEmpty.
השמות עבור מתודות set אינם משתנים עבור משתנים בוליאניים.
מתודות set חייבות לקבל רק ארגומנט אחד.
כללים אלה מאפשרים בדיקה ועדכון אוטומטיים פשוטים של מצב ה-bean באמצעות תשתיות תוכנה, שרבות מהן כוללות מנגנונים משלהן לעדכון משתני מחלקה מטיפוסים שונים.
בשפת התכנות Java, אנוטציה היא סוג של מנגנון תחבירי להוספת metadata לקוד המקור.
ניתן להוסיף אנוטציות למחלקות, מתודות, משתנים, פרמטרים ו-packages.
שלא כמו תגיות Javadoc, אנוטציות ג'אווה יכולות להיות רפלקטיביות בכך שניתן לשלב אותן בקובצי class הנוצרים על ידי המהדר, והן ניתנות לאחסון על ידי המכונה הווירטואלית של ג'אווה (JVM), כך שניתן יהיה לאחזר אותן בזמן ריצה.
תמיכה באנוטציות התווספה החל מגרסה 1.5 של ה-JDK.
השימוש באנוטציות נפוץ בתשתיות תוכנה (כדוגמת Spring ,Hibernate ו-EJB) כאמצעי נוח להוספת פונקציונליות למחלקות ומתודות המוגדרות על ידי המשתמש.
ללא שימוש באנוטציות, על מנת ליישם פונקציונליות נוספת של תשתית התוכנה, יש להצהיר עליה במקור חיצוני (כדוגמת קובץ XML לקונפיגורציה), או לתכנת זאת באמצעות קריאות API ייעודיות.
האנוטציות כשלעצמן הן לא מתודות והן לא יעשו שום עבודה.
במקום זאת, האובייקט של המחלקה מועבר בזמן ריצה למימוש של תשתית התוכנה, שם האנוטציות נקראות ומביאות לביצוע הפונקציונליות הנוספת.
בג'אווה קיימת קבוצת אנוטציות שהמהדר שומר כחלק מהסינטקס של השפה.
כמו כן ישנה קבוצת אנוטציות שמורות המשמשות לסימון של אנוטציות אחרות, על מנת לציין היכן ומתי ניתן להשתמש בהן .
מעבר לאנוטציות אלה, המשתמש חופשי להגדיר אנוטציות כרצונו.
ג'אווה מגדירה קבוצת אנוטציות שמורות המובנות בתוך השפה:
אנוטציות אשר מיושמות על קוד ג'אווה:
Override@ - בודקת שהמתודה המסומנת על ידי האנוטציה דורסת מתודה אחרת.
גורמת לשגיאת קומפילציה אם המתודה לא נמצאת באחת מהמחלקות שיורשים ממנה או באחד מהממשקים שהמחלקה מממשת.
Deprecated@ - מציינת שהמתודה מיושנת.
גורמת לאזהרת קומפילציה אם משתמשים במתודה.
SuppressWarnings@ - מורה למהדר להשתיק את אזהרות זמן ההידור אשר מצוינות בפרמטרים של האנוטציה.
אנוטציות אשר מיושמות על אנוטציות אחרות:
Retention@ - מציינת כיצד האנוטציה המסומנת תישמר: רק בקוד המקור, תעבור הידור לתוך המחלקה, או תהיה זמינה בזמן ריצה באמצעות reflection.
Documented@ - מסמנת אנוטציה אחרת לצורך הכלה בתיעוד.
Target@ - מציינת על אילו אלמנטים של ג'אווה ניתן ליישם את האנוטציה המסומנת.
Inherited@ - מציינת שהאנוטציה האחרת תעבור בירושה למחלקות שיורשות מהמחלקה המסומנת על ידי האנוטציה (כברירת מחדל, אנוטציות אינן עוברות בירושה למחלקות היורשות).
הדוגמה הבאה מציגה את השימוש באנוטציה המובנית Override@ (דריסה).
אנוטציה זו מורה למהדר לחפש במחלקות האב (אחת מהמחלקות שהמחלקה הנוכחית יורשת ממנה) אחר מתודות תואמות.
בדוגמה זו, תיווצר שגיאת קומפילציה מכיוון שהמתודה ()gettype במחלקה Cat אינה באמת דורסת את המתודה ()getType שבמחלקת Animal ממנה היא יורשת, אלא במקום זאת מצהירה על מתודה חדשה, וזאת מכיוון ששמות המתודות אינם מאויתים באופן זהה.
// @Workaround הצהרה על אנוטציה חדשה בשם
אנוטציות יכולות להכיל רשימה אופציונלית של זוגות מסוג מפתח-ערך (key-value):
דוגמה לשימוש באנוטציות לצורך סימון של אנוטציות אחרות, על מנת לפרט היכן ומתי ניתן להשתמש בהן:
בדוגמה זו האנוטציות Retention@ ו-Target@ מיושמות על האנוטציה Scalable@ בעת ההצהרה עליה.
"Je ne sais quoi" (בעברית: "אני לא יודעת מה") הוא השיר שייצג את איסלנד באירוויזיון 2010. השיר בוצע על ידי הרה ביורק.
השיר, שנבחר ב-Söngvakeppnin 2010, שהוא הקדם-אירוויזיון האיסלנדי המסורתי, נכתב והולחן על ידי הרה ביורק ואוליגור סמרי.
בתחרות עצמה הגיע השיר למקום השלישי בחצי הגמר השני ולמקום ה-19 בגמר.
Je l'aime à mourir הוא שיר בסגנון צרפתי של הזמר הצרפתי פרנסיס קברל.
השיר הפך לשיר המוכר ביותר של קברל כיוון שהוקלטו לו גרסאות כיסוי רבות.
בנוסף לגרסאות הכיסוי הרבות, יצא לשיר מגוון של רמיקסים, סימפולים, וקאברים שונים.
השיר זכה להצלחה הרבה ביותר בעיקר ברחבי צרפת, שם נכון להיום מכר השיר למעלה מ-500,000 עותקים.
השיר הוא השיר הנמכר ביותר של קברל בצרפת, ואחד מהשירים הנמכרים ביותר בכל הקריירה שלו.
בשנת 1980 קברל הוציא גרסה נוספת לשיר והכריז כי הגרסה תצא כסינגל רשמי, אך לא תתווסף לאף אלבום אולפן חדש, או גרסה מחודשת לאלבום אולפן ישן.
בשנת 1998, להקת "סגסוגת" הקליטה את השיר מחדש, והוא התווסף אל אלבום האולפן שלהם "Musics".
גרסת הכיסוי של הלהקה זכתה לאהדה רבה מצד המבקרים ומצד מעריצי הלהקה.
לגרסה שלהם לא יצא וידאו קליפ, אך בשנת 2016 הועלתה ליוטיוב גרסה של מתופף המנגן את השיר לצלילי הגרסה של הלהקה.
הבי-סייד המקורי שהיה עם השיר הוא שירו השני של קברל "Les chemins de traverse".
Je l'aime à mourir הוקלט בתור הסינגל הראשון והיחיד מתוך אלבום ההופעה הרביעי של שאקירה, Live from Paris.
האלבום מאגד כמה וכמה הופעות של הזמרת אשר התקיימו בעיר פריז שבצרפת.
גרסתה של שאקירה יצאה לאור ב-29 בנובמבר 2011. שאקירה הודיעה ברשתות החברתיות כי עתיד לצאת אלבום הופעה נוסף, וכי עתיד לצאת סינגל שהוא בעצם גרסת קאבר לשיר ישן.
בנוסף, פרסמה שאקירה את עטיפת הגרסה שלה בפייסבוק.
גרסת הכיסוי של שאקירה זכתה להצלחה עולמית כאשר בשיאה הצליחה להגיע לצמרות שני מצעדים, ובנוסף להיכנס לעשיריות פותחות נוספות.
ההצלחה הרבה שזכתה לה שאקירה עם השיר התרכזה בעיקר בצרפת עצמה, שם הגיע השיר עד מהרה למקום הראשון.
דבר זה הפך אותה לאחד האמנים הלטיניים היחידים שהצליחו להביא שיר בצרפת למקום הראשון.
ב-22 בדצמבר 2011, לקראת סוף אותה שנה העלתה שאקירה לערוץ ה-Vevo שלה את הווידאו קליפ שיצא לשיר.
הווידאו קליפ הוא בעצם קטע של הופעה מתוך "Live from Paris", בהופעה היה ניתן לראות את שאקירה שרה את השיר, ביחד עם הקהל, כשהיא לובשת שמלה כחולה ארוכה שמשתרעת על הבמה.
ההופעה שהעלתה שאקירה לערוצה במהרה זכתה לאהדה רבה מצד מעריציה ומבקריה ונכון ל-13 ביולי 2018, היא צברה למעלה מ-28 מיליון צפיות.
השיר זכה להצלחה רבה במצעדים, ואף הצליח להגיע למקום ה-1 בצרפת, ובולוניה.