ג'אווה (שפת תכנות)

ג'אווה
Java
פרדיגמות	תכנות מונחה־עצמים, תכנות מובנה, תכנות אימפרטיבי
תאריך השקה	1995
מתכנן	ג'יימס גוסלינג
מפתח	סאן מיקרוסיסטמס (ב-2010 נרכשה על ידי אורקל)
טיפוסיות	סטטית, חזקה, בטוחה, מפורשת
ניבים	Generic Java, Pizza
הושפעה על ידי	C++, UCSD Pascal, סי שארפ, Mesa, boxing, Java annotation, variadic function, ניקלאוס וירת, Patrick Naughton, אוברון, עדה, C, אייפל, Objective-C, Smalltalk, אובג'קט פסקל, foreach loop, בפסקה זו 3 רשומות נוספות שטרם תורגמו
רישיון	הרישיון הציבורי הכללי של גנו
סיומת	java, .class.
	https://www.java.com/en/

המונח "Java" מפנה לכאן. אם הכוונה למשמעות אחרת, ראו ג'אווה (פירושונים).

ג'אווה (באנגלית: Java) היא שפת תכנות מונחית עצמים אשר פותחה בחברת סאן מיקרוסיסטמס (כיום חברת־בת של אורקל) על ידי צוות בראשות ג'יימס גוסלינג בשנת 1991, והיא אחת משפות התכנות הנפוצות ביותר הנמצאות בשימוש כיום.^[1] השפה הוצגה לראשונה בשנת 1995, והיא מהווה את אחד מרכיבי הליבה של פלטפורמת התוכנה ג'אווה.

התחביר של השפה מבוסס במידה רבה על התחביר של ++C, אך כולל הרחבות רבות במטרה לאפשר תמיכה מובנית בתהליכונים, בינלאומיות, אבטחה ועבודה בסביבת האינטרנט ותכונות נוספות. לרוב עוברות תוכניות ג'אווה הידור ל־Java bytecode, שפת ביניים דמוית שפת מכונה, שאותה מריצה מכונה וירטואלית (Java Virtual Machine ;JVM). הודות לכך התוכנית יכולה לרוץ על כל מחשב ועל כל מערכת הפעלה המריצים JVM, החל מטלפונים סלולריים ועד למחשבי-על.

בשנת 1996 הוקם לראשונה הכנס "JavaOne", כנס שנתי המאגד אלפי משתמשי ומפתחי השפה הדנים בפיתוחה ובעדכונים הטכנולוגיים בה.

נכון ליולי 2022, ג'אווה נחשבת לשפת התכנות השנייה ברמת הפופולריות בעולם, גם בקרב מהנדסי תוכנה מקצועיים וגם על פי מדידת Google Trends.^[2]^[3]

היסטוריה

השפה פותחה לראשונה כמיזם פנים בתוך חברת סאן מיקרוסיסטמס, על ידי ג'יימס גוסלינג, ארכיטקט הפרויקט, שהחל בדצמבר 1990 בשם "פרויקט החמקן" (Stealth Project), ושמו הוחלף לאחר זמן מה ל"פרויקט הירוק" (Green Project). מטרתו המקורית של הפרויקט הייתה מערכות משובצות מחשב (embedded systems) עבור מכשירים חכמים (smart appliances) שונים, כגון מחשב כף יד (PDA) ואפילו תנור או מקרר חכם, תחום שסאן צפתה כי יתפתח מאוד מבחינה עסקית.

צוות הפרויקט פיתח שפה חדשה משום ששפות קיימות כגון ++C שנשקלה בתחילה, היו מורכבות מדי וצרכו משאבים גדולים מדי עבור מערכות פשוטות משובצות מחשב. אמנם, אחד מהנסיונות הראשונים של הצוות היה כתיבת גרסה שונה של ++C שתיקרא "--++++C"^[^{דרוש מקור]}, אך במהרה החליט הצוות לכתוב שפה חדשה המתבססת על מספר עקרונות ותחביר דומה ל־++C. השם שהוצע בתחילה לשפה היה Oak (אלון), על שמו של עץ שגדל מחוץ לחלון של גוסלינג.

מבחינת תשתית השפה, הרעיון הבסיסי היה ליצור "מְפָרֵשׁ" (Interpreter) שקורא את קוד השפה ומבצע אותה. משמע, כי לכל סביבה יהיה מפרש משלה וכך ניתן לכתוב קוד מקור אחיד עבור סביבות שונות. בסוף 1992 סאן הקימה חברת בת בשם FirstPerson שייעודה לפתח ולמצוא שימושיים עסקיים לשפה החדשה.

הכיוון אותו בחרה FirstPerson היה ממירים (Set-Top Boxes) לחברות כבלים, שיוכלו להריץ יישומים עבור טלוויזיה אינטראקטיבית. לאחר שני כישלונות במכרזים גדולים (חברות הכבלים חששו ממתן חופש גדול מדי בידי משתמש הקצה) נסגרה החברה והצוות חזר לסאן.^[4]

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

באותה שנה, בפגישה בבית קפה בהשתתפות מספר חברי צוות, הוחלט על שינוי השם מאחר ש־Oak היה רשום כסימן רשום על ידי יצרן אחר. מקור השם ג'אווה אינו ברור.^[5] יש טוענים שאלו ראשי תיבות של חברי הצוות שנכחו בפגישה: James Gosling, Arthur Van Hoff, and Andy Bechtolsheim גרסה אחרת טוענת כי השם ניתן על שם הקפה שהוגש באותה פגישה (קפה שמקורו בג'אווה שבאינדונזיה). חיזוק לגרסה האחרונה ניתן למצוא בכך שארבעת הבתים הראשונים (ראה מספר קסם) של כל מחלקה בג'אווה הם, בהקסדצימל: 0xCAFEBABE... (ז'רגון כתיבת מילים באמצעות התווים המותרים בפורמט הקסדצימלי מוכר בשם Hexspeak (אנ')). בהלצה נטען כי אלו ראשי תיבות של Just Another Vague Acronym ("עוד ראשי תיבות עמומים").

בשנת 1995 הטכנולוגיה הודגמה בכנס על דפדפן נטסקייפ על ידי סיבוב גוף תלת־ממדי בעזרת תוכנת קצה בדפדפן המריצה ג'אווה וידועה בימינו כיישומון (Applet – יישום קטן אשר רץ בתוך הדפדפן). הטכנולוגיה התקבלה בהתלהבות. היישומונים התפתחו זמן מה עד שה־Flash התחיל להחליף את מקומם בזכות יכולת ההנפשה שלו.

גרסה 5.0, שהושקה בספטמבר 2004 הייתה ממוספרת גם 1.5, כשלב מעבר ממספור גרסאות בקפיצות של עשירית (למשל, מ־1.3 ל־1.4) למספור בקפיצות של מספרים שלמים. השינוי בשיטת המספור ציין את קפיצת המדרגה בגרסה זו שכללה שינויים רבים (ובפרט Generics). כמו כן השינוי בשיטת המספור נובע, ככל הנראה, גם מן התחרות עם שפת #C, שהמיספור שלה קופץ במספרים שלמים.

בנובמבר 2006, הכריזה חברת סאן כי ג'אווה תוצע גם תחת רישוי GPL v2. ההכרזה כוללת את השפה והמהדר, הספריות, סביבת הריצה (JVM) והכלים הנלווים. בכך הפכה ג'אווה לשפה וסביבה פתוחה וחופשית.^[6] במאי 2007, הודיעה סאן כי סיימה את תהליך העברת ג'אווה לקוד פתוח.^[7]

עקרונות

תוכנית Hello world בשפת ג'אווה שנכתבה ובוצעה
בסביבת הפיתוח המשולבת Eclipse

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

ג'אווה תומכת בתכנות מונחה עצמים. עם זאת ג'אווה עדיין כוללת, מטעמי יעילות, גם "טיפוסים פרימיטיביים", שאינם אובייקטים. משום כך (ומסיבות נוספות) אינה נחשבת שפה מונחית עצמים "טהורה" כמו Smalltalk או Ruby. עם זאת, לכל טיפוס פרימיטיבי בג'אווה יש מחלקה עוטפת, אליה וממנה מתבצעת המרה אוטומטית (Boxing). למשל, לטיפוס הפרימיטיבי int קיימת מחלקה עוטפת Integer.

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

ג'אווה מאפשרת ירושה יחידה בלבד, וזאת על מנת למנוע בעיות דו־משמעות הנוצרות מירושת יהלום. כדי לאפשר גמישות דומה לזו של ירושה מרובה, קיים בג'אווה מנגנון ממשק (interface) המגדיר רשימה של מתודות, המהווה חוזה עם המתכנת. כך כל מחלקה יכולה להרחיב (extends) לכל היותר מחלקה אחת, ולממש (implements) מספר בלתי מוגבל של ממשקים. על המחלקה לממש במפורש כל מתודה בכל ממשק כזה, וכך לא קיימת בעיה של כפל משמעות.

בגרסה 5.0 נוספו מספר הרחבות חשובות לשפה, ביניהן תכנות גנרי (Generics), מספר משתנה של פרמטרים לפונקציה וטיפוסי מניה (Enums).

בגרסה 7 של השפה נוספה תמיכה בהקצאת משאבים תחומה־לקסיקלית – בלוקים של try-with-resources.^[8]

בגרסה 8 של השפה נוספה תמיכה נרחבת וישירה בטכניקות של תכנות פונקציונלי; בין היתר נוסף תחביר עבור פונקציות למבדא, נוסף תחביר להעברה של מתודות כפרמטר, נוספו ממשקים עבור פונקציות, נוסף טיפוס נתונים מובנה Stream התומך בפונקציות מסדר גבוה ובפעולות כגון map או collect ונוספה מתודה forEach לטיפוס הנתונים Iterator.

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

ג'אווה כשפה מוּנְחֵית עצמים חלקית

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

השפה לא מונחית עצמים "טהורה" כיוון שניתן להשתמש בה בטיפוסי נתונים פרימטיביים (כמו int,float,char וכו'..).

חמישה עקרונות חשובים של תכנות מונחה עצמים בjava הם

1. ירושה

דוגמת קוד:

// Parent class
class Animal {
  public void voice() {
    System.out.println("I am animal");
  }
    public void scream() {
    System.out.println("boo!");
    }
  }

// class child, inherit from Animal
class Dog extends Animal {
  // same method like Animal
  public void voice() {
    System.out.println(" I am Dog!");
  }
}

class Main {
  public static void main(String[] args) {
    // create an object of the parent class that will point the child class!
    Animal labrador = new Dog();
    labrador.voice();
    labrador.scream(); // also has the method of his parent class
     }
}
// output: I am Dog! boo!

2. כימוס

דוגמת קוד:

// Java program to demonstrate encapsulation
class EncapsulatedCar {
    // private variables declared these can only be accessed by public methods of class
    private String companyName;
    private int year;
    private int price;

    // getters methods to access private variables
    public int getYear() { return year; }
    public String getCompanyName() { return companyName; }
    public int getPrice() { return price; }

    // setters methods to access and change private variables
    public void setYear(int newYear) { year = newYear; }
    public void setCompanyName(String newCompanyName) {
        companyName = newCompanyName;  }
    public void setNewPrice(int newPrice) { price = newPrice; }
}

public class Car {
    public static void main(String[] args)
    {
        EncapsulatedCar car = new EncapsulatedCar();

        // setting values for the variables
        car.setCompanyName("Tesla");
        car.setNewPrice(200000);
        car.setYear(2022);

        // Displaying values of the variables
        System.out.println("car company: " + car.getCompanyName());
        System.out.println("year " + car.getYear());
        System.out.println("price of the car: " + car.getPrice() +"₪");

        // Direct access to the variables is not possible due to encapsulation
        // output: car company: Tesla
        //         year 2022
        //         price of the car: 200000₪
    }
}

3. פולימורפיזם דוגמת קוד:

class Animal {
  public void animalVoice() {
    System.out.println("Animals make various of voices..");
  }
}

class Cat extends Animal {
  public void animalVoice() {
    System.out.println("The cat howl: Meow Meow!");
  }
}

class Dog extends Animal {
  public void animalVoice() {
    System.out.println("The dog bark: Woof Woof!");
  }
}

class Main {
  public static void main(String[] args) {
    Animal myAnimal = new Animal();  // Create a Animal object
    Animal mitzi = new Cat();  // Create a Cat object
    Animal puppy = new Dog();  // Create a Dog object
    // We have now *two* different objects derived from the same super class!
    myAnimal.animalVoice();
    mitzi.animalVoice();
    puppy.animalVoice();
  }
}
// output: Animals make various of voices..
//         The cat howl: Meow Meow!
//         The dog bark: Woof Woof!

4. אבסטרקציה

5. ממשק

יתרונותיה של java כשפה מונחית עצמים

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

ביצועים

בראשית דרכה סבלה ג'אווה מביצועים גרועים, היות שמנועי זמן הריצה בוססו על מפרש בלבד. אולם, עם התפתחות השפה, הוחל שימוש בטכניקה הקרויה JIT‏ – Just In Time, אשר בבסיסה עמד העיקרון של הידור דינמי של קוד המכונה הווירטואלי לקוד המכונה הספציפי בזמן הריצה. על ידי כך מתקבלים ביצועים טובים יותר, ותאורטית אף גבוהים יותר משפת ++C במצבים מסוימים (היות שההידור מתבצע תוך כדי ריצת התוכנה, יש למהדר ידע מדויק יותר על ריצת התוכנה, מה שמסייע לביצוע אופטימיזציות טובות יותר לקוד).

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

דוגמה לתוכנית בשפת ג'אווה

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

import java.util.Scanner;

public class JavaProgram
{
 public static int getFactor (int num)
 {
  double sqrt = Math.sqrt(num);
  // try to find a factor that is not 1.
  for (int i = 2; i <= sqrt; i++) {
                        if (num % i == 0) // is num divisible by i?
                                return i;
  }
  return 1; // num is a prime.
 } // End of getFactor function.

 public static String communicate (int num)
 { // communicate with the user.
  if (num <= 0)// is it a valid input?
              return "The checked number should be positive";
  int factor = getFactor(num);
  if (factor == 1)
   return num + " is a prime";
  else
   return num + " is not a prime, " + num + " = " + num/factor + " × " + factor;
 } // End of communication function

 public static void main (String [] args)
 {
  Scanner in = new Scanner(System.in);
  System.out.println(communicate(in.nextInt()));
 }
}

גרסאות

סאן הגדירה מספר גרסאות לג'אווה המיועדות לסביבות שונות:

Java Card
Java Platform, Standard Edition ‏(Java SE): סביבת הפיתוח של ג'אווה הכוללת JVM, מהדר וכלי עזר
Java Platform, Enterprise Edition ‏(J2EE)
Java Platform, Micro Edition ‏(J2ME): גרסה למכשירים קטנים וסלולריים

J2EE

ערך מורחב – Java Enterprise Edition

עם התרבות השימוש באינטרנט, התברר שיש צורך ביצירת תשתית של תוכנת שרת על ידי שרת התומך בג'אווה בשיתוף של משאבים כמו בסיסי נתונים ומבני נתונים, בתמיכה בשרתי HTTP ובדפים דינמיים. כך פותחה JSP, טכנולוגיה של ג'אווה לבניית אתרי Web דינמיים. כך נוצר אוסף הכלים של ה־Enterprise Edition הנקרא בקיצור J2EE. לאחר מכן שונה השם ל-J2E.

שרת יישומים זה הצליח עד כדי כך שמיקרוסופט מנסה ב־NET. לתת פתרון דומה. יישומים כבדים באמת כמו SAP עזבו את העולם הסגור של Windows ובחרו לעבוד עם J2EE. ולמעשה רוב הקוד והפיתוח בג'אווה בימינו מבוסס על תשתיות אלו. חברות כמו BEA פיתחו שרת לתשתיות אלו ובמקביל קבוצת JBoss פיתחה שרת המבוסס על קוד פתוח.

J2ME

ערך מורחב – Java ME

תכונה זו של ניתוק ממערכת ההפעלה על ידי כתיבת JVM החוצצת בין התוכנה למערכת ההפעלה אומץ לתחום אחר והוא הטלפונים החכמים כחלק מקבוצה של התקנים משובצי מחשב (Embedded Devices). גם בתחום זה ריבוי המכשירים, מערכות ההפעלה, וסוגי המעבדים השונים נתנו יתרון לפיתוח מבוסס JVM. בתחום זה מספקת Sun את J2ME‏ (Java 2 Mobile Edition), שהיא גרסה קלת־משקל וקומפקטית למכשירי טלפון סלולרי ומחשבי כף יד.