הינה מאמר נחמד שמסביר לנו את ההבדלים בין ב# לJAVA ידוע שיש חילוקי דעות

למאמר לחצו פה

שטחי ולא מעניין...

וגם יש בו לא מעט שגיאות, או משפטים שהם סתם לא ברורים.

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

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

לא בהכרח, בשביל לעשות OOP אתה לא חייב מחלקות, אתה יכול לעשות OO גם בשפה כמו C.

או רק בעזרת קומפוזיציה והעתקה בשפות כמו lua ו java script .

מבחינת ביצועים שפת ג'וואה משתמשת בטכניקה הקרויה JIT‏

זה לא פיצ'ר של java אלא של ה JVM, אתה צריך להבדיל בין 2 הדברים. לדוגמה בגרסאות הראשונות

של dalvik לא היה JIT.

ויש יכולת להורשה מרובה של ממשקים.

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

ריבוי השפות- ג'אווה היא שפה המבוססת על שפת פיתוח אחת - ג'אווה .

בניגוד לשפות .Net שניתן לפתח במספר שפות C++ VB ולשלב בינהן.

זה לא קשור ל java או #C. זה יותר ה JVM מול ה VM של דוט נט או משהו (כל ההיכרות שלי עם דוט נט

מסתכמת בהפסקת קפה אחת ו 2 מאמרי intro, אז אין לי מה להוסיף פה P: ).

אגב אתה יכול להריץ עוד שפות על ה JVM כמו groovy או scala. בכלל בשנים האחרונות ה JVM הפך

לפלטפורמה די חשובה.

הבדל נוסף Foreach אשר קיים בC# ולא בJAVA אשר נמצא כדי לבצע מעבר פשוט ונוח על איברי Collection

חדשות טובות! כן יש foreach ב java :

List<Foo> listOfFooObjects = new ArrayList<Foo>()

for(Foo fooObject : listOfFooObjects)
  fooObject.doSomething()

קיים הבדל לטובת JAVA בכך שהיא שפה של חברת סאן

אין יותר סאן, אורקל קנתה אותם. וזה רק בעניין ה JVM, לא java.

זהו, מקווה שזה עזר לך

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

ראשית - מי אני?

מפתח 10 שנים בג'אווה. התחלתי ב 2001 בגירסה 1.3 ומפתח עד היום תחת גירסה 6 (כן, אני יודע שיש גם גרסה 7, התוספת שיש שם

היא שולית למדי)

בשנה האחרונה יצא לי לפתח גם ל C# והתנדבתי לעשות הרצאה לחברים בעבודה על ההבדלים בין השפות.

הנה הרשימה שלי

דברים שדומים בשתי השפות -

1) תחביר דומה, נובע מכך ששתי השפות הן צאצאים של שפת C

2) שיטת פיתוח עיקרית היא תכנות מונחה עצמים: ירושה + פולימורפיזם + אנקפסולציה + exceptions - כל אלה דומים מאד

3) קים דמיון רב (אבל לא זהה) בשיטת ניהול טיפוסים (type system) -

* הטיפוס מצוין בקוד (explicit),

* משתנים מקבלים טיפוס בזמן קומפילציה (static),

* אוביקטים חייבים להתנהג לפי הטיפוס שלהם (strong),

* ניהול generics דומה מבחינה תחבירית.

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

כאמור, רב הדמיון אולם יש הבדלים והם באים לידי ביטוי באופן יותר בולט בגירסאות אחרונות של C#

4) שתי השפות מתקמפלות לקוד ביניים (intermediate code) ומשתמשות בפלטפרומת הרצה וירטואלית (virtual

machine) הנותנת שירותים כמו ניהול זכרון, ניהול נימים, אופטימיזציה וכו

5) לשתי השפות קיימות פלטפורמת הרצה למגוון של מ"ה (חלונות, יוניקס, מאק וכו) - כן, כן, גם ל C#

6) לשתי הפלטפורמות יש אפשרות להריץ מגוון שפות תכנות שונות, במגוון שיטות פיתוח (שפות סקריפט, שפות פונקציונאליות)

ההבדלים: -

1) הבדלים בשיטת ניהול טיפוסים:

* בג'אווה כל הטיפוסים מצוינים בקוד במפורש (explicit). בגירסה 7 נתנו "הנחה" בכך שאפשר לוותר על generics בזמן יצירת

האוביקט

List<String> strings = new ArrayList<>();

ב C# החל מגירסה 3 הוסיפו מילה שמורה var לציון שהקומפיילר יבין לבד מה הטיפוס של המשתנה. למשל בדוגמא הבאה הקומפיילר

יבין לבד שהטיפוס של X הוא מחרוזת

public string Foo () { ... }
var x = this.Foo();

* בג'אווה כל הטיפוסים מוגדרים בזמן קומפילציה (static).ב C# החל מגירסה 4 הוסיפו מילה שמורה dynamic לציון משתנה

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

2) תמיכה מלאה בשיטת פיתוח מונחת עצמים:

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

מתודות) ויצירה של טיפוסי מחלקה עוטפים (wrapper types)

בC# כל הטיפוסים הם מחלקות וכל הערכים הם אוביקטים מה שמאפשר קוד כזה

123456789.ToString("N1")

התוצאה היא "123,456,789.0"

ישנה אפילו תמיכה בערך null בטיפוסים שמייצגים ערכים נומריים.

3) הבדלים במתודות

* בג'אווה, כל מתודה היא virtual אלא אם צוין אחרת - כלומר ניתן ליישם אותה במחלקה יורשת.

בC#, כל מתודה היא non-virtual אלא אם צוין אחרת. כמו כן ניתן לציין במפורש במחלקה יורשת שמתודה בעלת חתימה זהה אינה

מיישמת את המתודה במחלקת הבסיס.

* בג'אווה כל הארגומנטים מועברים by value

בC# ניתן לציין העברת ארגומנטים by reference

* תכונות נוספות שקיימות רק בC# ולא יפורטו: extension methods, named and optional method

arguments

4) exceptions

בג'אווה כל מתודה חייבת לציין את ה excpetions שהיא זורקת באמצעות throws

בC# אין שום הכרזה כזו. עדיין ניתן לטפל בזריקת exceptions ע"י בלוק try-catch אולם אין חובה כזו ואין בדיקה של

הקומפיילר.

5) תכונות של שפות C/C++

לC# יש תמיכה בתכונות שקיימות בשפות הנ"ל: operator overloading, preprocessor directives

6) שמות קבצי מקור

לC# אין את הקונבנציה שקיימת בג'אווה לגבי שמות ומיקום קבצי קוד. שם הקובץ ומיקומו אינם נגזרים משמות המחלקה והpackage

7) שיטות פיתוח נוספות

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

C# תומכת בפיתוח בשיטה דינאמית (כמו שפות סקריפט, למשל javascript) וכן בפיתוח בשיטה פונקציונאלית (כמו lisp למשל)

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

(למשל ע"י הוספה של מצביעים למתודות ותמיכה ב closures)

זהו פחות או יותר בקצרה (סיכום של מצגת שלי עם 68 שקפים...)

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

אני חושב שכיווני ההתקדמות של שתי השפות האלה הם שונים: בג'אווה מתרכזים בלפתח את הפלטפורמה (מירה הפיצ'רים החדשים של

גירסאות 6 ו 7 היו בפלטפורמה) והתקדמות בשיטות הפיתוח נעשית דרך שפות תכנות אחרות, שרצות על אותה פלטפורמה.

בC# ישנו זיווג חזק יותר בין התקדמות הפלטפורמה והשפת תכנות. C# היתה ונשארה שפת התכנות העיקרית (אם כי בכלל לא היחידה) והיא

הולכת ונעשית עשירה יותר ויותר בפיצ'רים. הגירסה הבאה של C# תתמוך בתכנות א-סינכרוני.

כאמור, הרחבות ודוגמאות יש למכביר.

למה להמציא את הגלגל? גלגל מלשון גוגל

http://stackoverflow.com/questions/295224/what-are-major-differences-between-c-sharp-and-java

שם מובא גם הקישור הבא:

http://www.25hoursaday.com/CsharpVsJava.html

וגם ויקיפדיה הידועה, עם הסגנון שלה על מעלותיו וחסרונותיו:

http://en.wikipedia.org/wiki/Comparison_of_C_Sharp_and_Java

זה משפט רציני:

Java doesn't have anything like LINQ

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

בלינק השני והשלישי יש פירוט מאוד נרחב על ההבדלים בין ג'אווה ו-#C, אבל בלי התמקדות בעיקר.

כמה הערות ל-sharonbn:

ישנה אפילו תמיכה בערך null בטיפוסים שמייצגים ערכים נומריים.

לא מדויק. אי אפשר לעשות int x = null. בשביל דבר כזה צריך להגדיר את x להיות nullable באמצעות סימן שאלה, יענו לעשות int? x = null.

בג'אווה כל מתודה חייבת לציין את ה excpetions שהיא זורקת באמצעות throws

אם אני לא טועה בגרסה החדשה של ג'אווה זה כבר לא חובה.

ועוד כמה הערות שלי:

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

גם לפתח UI ב-#C זה הרבה יותר קל מאשר בג'אווה. לדוגמה, שימוש ב-events+delegates הוא הרבה יותר קל מאשר שימוש בממשקים וadapters.

ועוד כמה הערות שלי:

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

קשה לקרוא לדברים האלה הבדלים בשפות...

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

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

אתה יכול להשתמש בספריה כמו apache commans או לכתוב משהו משלך. עדין אבל לדעתי הספריה

הסטנדרטית היא חלק מאוד חשוב מה eco system של השפה.

סתכל על זה ככה, אם כל המסביב היה אותו דבר, הייתי מצהיר על עצמי כמתכנת #C אחרי הפוסט של sharonbn

(נראה אחלה פוסט אגב, אשב לקרוא בערב)