مقارنة بين لغتي سي شارب وجافا

كلتا اللغتين تعتمدان على الكتابة الثابتة مع توجيه كائني قائم على الأصناف. في جافا، تتميز الأنواع الأولية بكونها غير موجهة كائنيًا، ولم يكن من الممكن تعريفها باستخدام اللغة نفسها. كما أنها لا تشترك في سلف مشترك مع الأنواع المرجعية. جميع الأنواع المرجعية في جافا مشتقة من نوع جذري مشترك. أما لغة C#، فلديها نظام أنواع موحد ، حيث تشتق جميع الأنواع (باستثناء المؤشرات غير الآمنة ^{[ 14 ]} ) في النهاية من نوع جذري مشترك. ونتيجة لذلك، تُنفذ جميع الأنواع أساليب هذا النوع الجذري، وتُطبق أساليب الإضافة المُعرّفة لنوع الكائن على جميع الأنواع، حتى القيم الحرفية الأولية من نوع int والمفوضين . هذا يسمح للغة C#، على عكس جافا، بدعم الكائنات ذات التغليف التي ليست أنواعًا مرجعية.

في لغة جافا، تُعتبر الأنواع المركبة مرادفةً للأنواع المرجعية؛ فلا يُمكن تعريف الدوال لنوعٍ ما إلا إذا كان أيضًا نوعًا مرجعيًا لفئة . أما في لغة سي شارب، فقد تم فصل مفهومي التغليف والدوال عن شرط المرجعية، بحيث يُمكن للنوع دعم الدوال والتغليف دون أن يكون نوعًا مرجعيًا. مع ذلك، فإن الأنواع المرجعية فقط هي التي تدعم الدوال الافتراضية والتخصيص.

تدعم كلتا اللغتين العديد من الأنواع المضمنة التي تُنسخ وتُمرر بالقيمة لا بالمرجع. تُطلق جافا على هذه الأنواع اسم الأنواع الأولية ، بينما تُسمى الأنواع البسيطة في لغة سي شارب. عادةً ما تحظى الأنواع الأولية/البسيطة بدعم أصلي من بنية المعالج الأساسية.

تُطبّق أنواع C# البسيطة العديد من الواجهات ، وبالتالي تُتيح العديد من الدوال مباشرةً على مثيلات هذه الأنواع، حتى على القيم الحرفية. كما أن أسماء أنواع C# هي مجرد أسماء بديلة لأنواع وقت تشغيل اللغة العامة (CLR). نوع C# System.Int64هو نفسه نوع long تمامًا ؛ والفرق الوحيد هو أن الأول هو الاسم المتعارف عليه في .NET ، بينما الثاني هو اسم بديل له في C#.

لا توفر لغة جافا طرقًا مباشرة للتعامل مع الأنواع الأولية. بدلًا من ذلك، تُقدم الطرق التي تعمل على القيم الأولية من خلال فئات تغليف أولية مُصاحبة. توجد مجموعة ثابتة من هذه الفئات، كل منها يُغلف نوعًا واحدًا من مجموعة الأنواع الأولية الثابتة. على سبيل المثال، يُعد نوع Long في جافا نوعًا مرجعيًا يُغلف النوع الأولي long . مع ذلك، فهما ليسا النوع نفسه.

تتيح لغة C# للمبرمج إنشاء أنواع قيم مُعرَّفة من قِبل المستخدم ، باستخدام الكلمة المفتاحية struct . على عكس الأصناف، وكما هو الحال مع الأنواع الأولية القياسية، تُمرَّر هذه الأنواع وتُسند إليها القيم مباشرةً بدلاً من الإسناد إليها. كما يمكن أن تكون جزءًا من كائن (إما كحقل أو كعنصر مُغلَّف )، أو تُخزَّن في مصفوفة دون الحاجة إلى توجيه الذاكرة غير المباشر الموجود عادةً لأنواع الأصناف.

نظرًا لأن أنواع القيم لا تحتوي على مفهوم القيمة الفارغة ويمكن استخدامها في المصفوفات دون تهيئة، فإنها تأتي دائمًا مع مُنشئ افتراضي ضمني يملأ مساحة ذاكرة البنية بالأصفار. ولا يمكن تعريف مُنشئات أخرى إلا باستخدام وسيط واحد أو أكثر. لا تحتوي أنواع القيم على جداول طرق افتراضية ، ولهذا السبب (ولحجم الذاكرة الثابت )، فهي مُغلقة ضمنيًا. ومع ذلك، يمكن لأنواع القيم (وكثيرًا ما تفعل) تطبيق الواجهات . على سبيل المثال، تُطبّق أنواع الأعداد الصحيحة المُدمجة العديد من الواجهات .

بصرف النظر عن الأنواع الأولية المضمنة، لا تتضمن لغة جافا مفهوم أنواع القيم.

تُعرّف كلتا اللغتين التعدادات، لكنهما تُنفّذان بطرق مختلفة جذريًا. ولذلك، تُعدّ التعدادات أحد المجالات التي تفشل فيها الأدوات المصممة لترجمة التعليمات البرمجية تلقائيًا بين اللغتين (مثل محولات Java إلى C#).

تُطبّق لغة C# التعدادات بطريقة مشابهة للغة C، أي كأغلفة حول علامات البت المُطبّقة في أنواع البيانات الصحيحة الأولية (int، byte، short، إلخ). يُحسّن هذا الأداء ويُسهّل التفاعل مع شيفرة C/C++ المُصرّفة، ولكنه يُوفّر ميزات أقل وقد يُؤدي إلى أخطاء إذا تم تحويل أنواع القيم منخفضة المستوى مباشرةً إلى نوع تعداد، كما هو مسموح به في لغة C#. لذلك، يُنظر إليه على أنه تحسين شكلي . ^{[ 24 ]} في المقابل، تُطبّق لغة Java التعدادات كمجموعة كاملة الميزات من النسخ، مما يتطلب ذاكرة أكبر ولا يُحسّن التفاعل مع شيفرة C/C++، ولكنه يُوفّر ميزات إضافية في الانعكاس والسلوك الجوهري. يُوضّح الجدول أدناه كيفية تطبيق التعدادات في كل لغة.

في كلٍ من لغتي C# و Java، يُمكن للمبرمجين استخدام التعدادات في عبارة switch دون تحويلها إلى سلسلة نصية أو نوع عدد صحيح أولي. مع ذلك، تمنع لغة C# الانتقال الضمني إلا إذا كانت عبارة case خالية من أي تعليمات برمجية، إذ يُعدّ ذلك سببًا شائعًا للأخطاء التي يصعب اكتشافها. ^{[ 27 ]} يجب التصريح عن الانتقال صراحةً باستخدام عبارة goto . ^{[ 28 ]}

تُطبّق لغة C# مؤشرات الأساليب الموجهة للكائنات على شكل دوال مُفوَّضة . الدالة المُفوَّضة هي نوع خاص يُمكنه الاحتفاظ بمرجع إلى أسلوب. يُمكن تخزين هذا المرجع في متغير من نوع الدالة المُفوَّضة أو تمريره إلى الأسلوب عبر مُعامل الدالة المُفوَّضة لاستدعائه لاحقًا. تدعم دوال C# المُفوَّضة التغاير والتغاير العكسي ، ويُمكنها الاحتفاظ بمرجع إلى أي أسلوب ثابت، أو أسلوب مثيل، أو أسلوب مجهول، أو تعبير لامدا متوافق مع التوقيع .

لا ينبغي الخلط بين المندوبين والإغلاقات والدوال المضمنة. ترتبط هذه المفاهيم ببعضها لأن الإشارة إلى إغلاق/دالة مضمنة يجب أن تُضمّن في مرجع المندوب لتكون مفيدة. لكن المندوب لا يشير دائمًا إلى دالة مضمنة؛ بل يمكنه أيضًا الإشارة إلى دوال ثابتة أو دوال مثيل موجودة. تُشكّل المندوبين أساس أحداث C# ، ولكن لا ينبغي الخلط بينها وبين أحداث C# أيضًا.

تم استبعاد المندوبين عمدًا من لغة جافا لأنهم اعتبروا غير ضروريين ومضرين باللغة، فضلًا عن مشاكل الأداء المحتملة. ^{[ 29 ]} وبدلًا من ذلك، تُستخدم آليات بديلة. يُعد نمط التغليف ، الذي يُشبه المندوبين في لغة سي شارب من حيث أنه يسمح للعميل بالوصول إلى طريقة واحدة أو أكثر مُعرّفة من قِبله عبر واجهة معروفة ، إحدى هذه الآليات. وهناك آلية أخرى تتمثل في استخدام كائنات المُهايئ باستخدام الفئات الداخلية، والتي جادل مصممو جافا بأنها حل أفضل من مراجع الطرق المُقيدة. ^{[ 29 ]}

انظر أيضًا إلى أمثلة المندوبين في لغة C# والبنى المكافئة في لغة Java .

تتيح لغة C# رفع أنواع البيانات الأولية/البسيطة/القيمية للسماح باستخدام القيمة الفارغة (null ) بالإضافة إلى القيم الأصلية للنوع. يتم رفع النوع بإضافة لاحقة إلى اسمه؛ وهذا يُعادل استخدام النوع العام ، حيث T هو النوع المراد رفعه. تُعرَّف التحويلات ضمنيًا للتحويل بين قيم النوع الأساسي والنوع المرفوع. يمكن مقارنة النوع المرفوع بالقيمة الفارغة (null) أو اختباره للتأكد من وجود قيمة له (HasValue) . كما تُعرَّف المعاملات المرفوعة ضمنيًا وتلقائيًا بناءً على النوع الأساسي غير المرفوع، حيث - باستثناء بعض المعاملات المنطقية - تنتقل القيمة الفارغة (null) إلى النتيجة.?Nullable<T>

لا تدعم لغة جافا رفع النوع كمفهوم، ولكن جميع الأنواع الأولية المضمنة لها أنواع تغليف مقابلة، والتي تدعم القيمة الفارغة بحكم كونها أنواع مرجعية (فئات).

وفقًا لمواصفات جافا، فإن أي محاولة لفك مرجعية قيمة فارغة (null) ستؤدي إلى ظهور استثناء أثناء التشغيل، وتحديدًا استثناء NullPointerException . (وإلا لما كان من المنطقي فك مرجعية القيمة الفارغة، لأنها، بحكم تعريفها، لا تشير إلى أي كائن في الذاكرة). وينطبق هذا أيضًا عند محاولة فك تغليف متغير من نوع مُغلِّف، والذي يُقيَّم إلى قيمة فارغة (null ): سيُطلق البرنامج استثناءً، لأنه لا يوجد كائن لفك تغليفه، وبالتالي لا توجد قيمة مُغلَّفة للمشاركة في الحساب اللاحق.

يوضح المثال التالي اختلاف السلوك. في لغة C#، يقوم عامل التشغيل lifted* بتمرير القيمة الفارغة للمعامل؛ أما في لغة Java، فإن فك تغليف المرجع الفارغ يؤدي إلى ظهور استثناء.

لم تُعرَّف جميع عوامل التشغيل المُرفَّعة في لغة C# بحيث تُمرِّر القيمة الفارغة (null) بشكلٍ غير مشروط إذا كانت إحدى المعاملات فارغة . على وجه التحديد، تم رفع عوامل التشغيل المنطقية (Boolean) لدعم المنطق الثلاثي، مما يحافظ على التوافق مع لغة SQL .

لا تدعم عوامل التشغيل المنطقية في Java المنطق الثلاثي، كما أنها غير مطبقة في مكتبة الفئة الأساسية.

تتميز لغة C# بنوع ديناميكي مرتبط متأخرًا يدعم الاستدعاء الديناميكي بدون استخدام الانعكاس، والتوافق مع اللغات الديناميكية، والربط المخصص (على سبيل المثال) بنماذج كائنات المستندات. يحل هذا النوع الديناميكي الوصول إلى الأعضاء ديناميكيًا في وقت التشغيل، بدلًا من حله بشكل ثابت/افتراضي في وقت الترجمة. آلية البحث عن الأعضاء قابلة للتوسيع باستخدام الانعكاس التقليدي كآلية احتياطية.

توجد عدة حالات استخدام للنوع الديناميكي في لغة C#:

• استخدام أقل إسهابًا للانعكاس: من خلال تحويل مثيل إلى النوع الديناميكي ، يمكن استدعاء الأعضاء مثل الخصائص والأساليب والأحداث وما إلى ذلك مباشرة على المثيل دون استخدام واجهة برمجة تطبيقات الانعكاس مباشرة.
• التوافق مع اللغات الديناميكية: يأتي النوع الديناميكي مع دعم مركزي ومحوري لتنفيذ الكائنات ذات الأنواع الديناميكية وبنية وقت التشغيل المشتركة للبحث الفعال عن الأعضاء.
• إنشاء تجريدات ديناميكية أثناء التنقل: على سبيل المثال، يمكن للكائن الديناميكي أن يوفر وصولاً أبسط إلى نماذج كائنات المستندات مثل مستندات XML أو XHTML .

لا تدعم لغة جافا أنواع الربط المتأخر. تختلف حالات استخدام الأنواع الديناميكية في لغة C# عن تلك الموجودة في جافا، حيث لها بنيات مقابلة مختلفة.

• بالنسبة للاستدعاء الديناميكي المتأخر بالاسم للأنواع الموجودة مسبقًا، يجب استخدام الانعكاس.
• لضمان التوافق مع اللغات الديناميكية، يجب استخدام واجهة برمجة تطبيقات (API) خاصة بتلك اللغة. تحتوي منصة آلة جافا الافتراضية على العديد من اللغات الديناميكية، ولكن لا يوجد معيار موحد لكيفية تمرير الكائنات بين اللغات. عادةً ما يتضمن ذلك استخدام نوع من الانعكاس أو واجهة برمجة تطبيقات شبيهة به. كمثال على كيفية استخدام كائنات JavaFX من جافا. ^{[ 30 ]}
• لإنشاء الكائنات والتفاعل معها بالكامل في وقت التشغيل، على سبيل المثال، التفاعل مع تجريد نموذج كائن المستند، يجب استخدام واجهة برمجة تطبيقات تجريد محددة.

انظر أيضًا المثال #التوافق مع اللغات الديناميكية .

تمنع لغة جافا استخدام المؤشرات وعملياتها الحسابية ضمن بيئة تشغيلها. وقد برر مصممو لغة جافا ذلك بأن المؤشرات تُعدّ من أبرز العوامل التي تُتيح للمبرمجين إدخال أخطاء في برامجهم، لذا اختاروا عدم دعمها. ^{[ 16 ]} لا تسمح جافا بتمرير واستقبال الكائنات/الهياكل مباشرةً من وإلى نظام التشغيل الأساسي، وبالتالي لا تحتاج إلى نمذجة الكائنات/الهياكل وفقًا لتخطيط ذاكرة مُحدد، وهو تخطيط غالبًا ما يتضمن استخدام المؤشرات. بدلًا من ذلك، تعتمد جافا في تواصلها مع نظام التشغيل الأساسي على واجهة جافا الأصلية (JNI)، حيث تتم إدارة التواصل مع نظام التشغيل الأساسي والتكيف معه من خلال طبقة وسيطة خارجية .

على الرغم من أن لغة C# تسمح باستخدام المؤشرات وعملياتها الحسابية، إلا أن مصممي اللغة كانوا قلقين من إمكانية استغلال المؤشرات للتحايل على قواعد الوصول الصارمة للكائنات. لذا، تمنع C# استخدام المؤشرات افتراضيًا. ^{[ 31 ]} مع ذلك، ونظرًا لأهمية المؤشرات عند استدعاء العديد من الدوال الأصلية، يُسمح باستخدامها في وضع غير آمن صريح . يجب وضع علامة " unsafe" على كتل التعليمات البرمجية أو الدوال التي تستخدم المؤشرات لكي تتمكن من استخدامها، ويتطلب المُصرّف استخدام مفتاح التبديل للسماح بتجميع هذا النوع من التعليمات البرمجية. تُعلّم التجميعات التي تُجمّع باستخدام مفتاح التبديل على هذا النحو، ولا يُسمح بتنفيذها إلا إذا كانت موثوقة صراحةً. يتيح هذا استخدام المؤشرات وعملياتها الحسابية لتمرير واستقبال الكائنات مباشرةً من وإلى نظام التشغيل أو واجهات برمجة التطبيقات الأصلية الأخرى باستخدام تخطيط الذاكرة الأصلي لتلك الكائنات، مع عزل هذه التعليمات البرمجية التي قد تكون غير آمنة في تجميعات موثوقة تحديدًا./unsafe/unsafe

في كلتا اللغتين ، تُعدّ المراجع مفهوماً أساسياً. جميع مثيلات الفئات تتم عن طريق المراجع .

على الرغم من أن ذلك ليس واضحًا بشكل مباشر في بنية اللغة نفسها ، إلا أن كلتا اللغتين تدعمان مفهوم المراجع الضعيفة . أي كائن يُشار إليه فقط بمراجع ضعيفة يكون مؤهلًا لجمع البيانات المهملة تمامًا كما لو لم تكن هناك أي مراجع على الإطلاق. في كلتا اللغتين، تُتاح هذه الميزة من خلال المكتبات المرتبطة، مع أنها في الواقع ميزة أساسية في وقت التشغيل.

إلى جانب المراجع الضعيفة، تحتوي لغة جافا على المراجع المرنة . وهي تشبه المراجع الضعيفة إلى حد كبير، ولكن آلة جافا الافتراضية (JVM) لن تُحرر الكائنات ذات المراجع المرنة إلا عند الحاجة إلى الذاكرة.

تُعدّ المصفوفات والمجموعات من المفاهيم المميزة لكلا اللغتين.

إن الصيغة المستخدمة لإعلان المصفوفات والوصول إليها متطابقة، باستثناء أن لغة C# قد أضافت صيغة لإعلان المصفوفات متعددة الأبعاد ومعالجتها.

قد تُحسّن المصفوفات متعددة الأبعاد الأداء في بعض الحالات بفضل زيادة التوطين (حيث يتم الوصول إلى مؤشر واحد فقط بدلاً من الوصول إلى مؤشر واحد لكل بُعد من أبعاد المصفوفة، كما هو الحال في المصفوفات غير المنتظمة). مع ذلك، ونظرًا لأن الوصول إلى جميع عناصر المصفوفة متعددة الأبعاد يتطلب الضرب/الإزاحة بين بُعدين أو أكثر، فإن هذه الميزة لا تُعدّ مفيدة إلا في حالات الوصول العشوائي للغاية.

يتمثل فرق آخر في إمكانية تخصيص مساحة كاملة للمصفوفة متعددة الأبعاد باستخدام عامل التشغيل new مرة واحدة ، بينما تتطلب المصفوفات غير المنتظمة حلقات تكرار وتخصيصات لكل بُعد. مع ذلك، توفر لغة جافا بنيةً نحويةً لتخصيص مساحة لمصفوفة غير منتظمة بأطوال منتظمة؛ حيث تتولى الآلة الافتراضية تنفيذ الحلقات التكرارية والتخصيصات المتعددة، ولا يلزم توضيحها صراحةً في الكود المصدري.

تتميز كلتا اللغتين بمجموعة واسعة من أنواع المجموعات التي تشمل أنواعًا مختلفة مرتبة وغير مرتبة من القوائم والخرائط/القواميس والمجموعات وما إلى ذلك.

توفر لغة C# طريقتين مختلفتين لإنشاء أنواع الصفوف (المعروفة أيضًا بأنواع المنتج ). الأولى هي عبر System.Tupleالفئات، وهي أنواع مرجعية غير قابلة للتغيير توفرها واجهة برمجة تطبيقات إطار العمل (بدءًا من .NET Framework 4.0) لإنشاء أنواع صفوف عامة. ^{[ 12 ]} وقد تم استبدال هذه الطريقة الأولى فعليًا بالطريقة الثانية، وهي System.ValueTupleالبنى، وهي أنواع قيم قابلة للتغيير توفرها واجهة برمجة تطبيقات إطار العمل (بدءًا من .NET Framework 4.7). ^{[ 13 ]}

على الرغم من تشابه الطريقتين ظاهريًا، إلا أنهما تختلفان اختلافًا ملحوظًا في عدة جوانب. فأنواع ValueTuple هي أنواع قيم، لذا فهي تشغل مساحة ذاكرة أقل؛ كما أنها تعرض محتوياتها كحقول قابلة للتغيير، مقارنةً بخصائص Tuple غير القابلة للتغيير . وأخيرًا، منذ إصدار C# 7.0، تدعم اللغة بناء الجملة الأصلي لإنشاء وتفكيك ومعالجة tuples ككائنات ValueTuple ؛ وهذا يتيح أيضًا إعادة تسمية حقول tuples بشكل عشوائي (على عكس Tuple ، حيث تُسمى الحقول دائمًا Item1 و Item2 وما إلى ذلك ).

لا توفر لغة جافا أنواع البيانات الثنائية (tuple) كجزء من لغتها أو واجهة برمجة التطبيقات القياسية الخاصة بها؛ توجد العديد من المكتبات الخارجية التي توفر أنواع البيانات الثنائية، ^{[ 39 ]} ولكنها جميعًا متشابهة بالضرورة مع System.Tupleفئات C#. بالمقارنة مع أنواع ValueTuple في C# وبنيتها، فإن استخدامها أكثر تعقيدًا (إذ يتطلب استخدامًا صريحًا للدوال البانية أو دوال المصنع الثابتة لإنشائها، ويتطلب الوصول إلى كل عضو على حدة لتفكيكها، ولها أسماء ثابتة لعناصرها).

تسمح كلتا اللغتين بالتحويل التلقائي بين أنواع البيانات الأولية وأنواع البيانات المرجعية المقابلة.

في لغة C#، تُعتبر الأنواع الأولية أنواعًا فرعية من النوع Object. أما في لغة Java، فالأمر مختلف؛ إذ لا توجد علاقة محددة بين أي نوع أولي ونوع الغلاف المقابل له، باستثناء التحويل التلقائي بين الأنواع وفك التحويل، وهما بمثابة اختصار برمجي للتبادل بينهما. وقد تم ذلك عمدًا للحفاظ على التوافق مع الإصدارات السابقة من Java، حيث لم يكن التحويل التلقائي مسموحًا، وكان المبرمج يتعامل مع مجموعتين منفصلتين من الأنواع: الأنواع الأولية، وتسلسل أنواع الغلاف (المرجعية). ^{[ 44 ]}

يترتب على هذا الاختلاف النتائج التالية. أولاً، في لغة C#، يمكن للأنواع الأولية تعريف الدوال، مثل إعادة تعريف ToString()دالة الكائن. أما في لغة Java، فتُنجز هذه المهمة بواسطة فئات التغليف الأولية .

ثانيًا، في لغة جافا، يلزم إجراء تحويل نوع إضافي عند محاولة الوصول المباشر إلى قيمة أولية، لأنها لا تُحوّل تلقائيًا. يُحوّل التعبير قيمة عددية صحيحة إلى سلسلة نصية في جافا، بينما يُنفّذ التعبير نفسه في لغة سي شارب. والسبب في ذلك هو أن التعبير الأخير يُمثّل استدعاءً لمثيل القيمة الأولية 42 ، بينما يُمثّل التعبير الأول استدعاءً لمثيل كائن من النوع .((Integer)42).toString()42.ToString()java.lang.Integer

وأخيرًا، هناك فرق آخر يتمثل في أن لغة جافا تستخدم أنواعًا معلبة بشكل كبير في الأنواع العامة (انظر أدناه ).

مع تطور اللغتين، واجه مصمموهما مواقفَ استدعت إضافة كلمات مفتاحية أو صيغ جديدة. قد تُؤدي الكلمات المفتاحية الجديدة، على وجه الخصوص، إلى تعطل الشيفرة المصدرية الحالية، أي أن الشيفرة القديمة قد لا تُترجم عند تقديمها إلى مُترجم لإصدار أحدث من اللغة. يحرص مصممو اللغتين على تجنب مثل هذه المشاكل. وقد اتبع مصممو اللغتين مساراتٍ مختلفة في معالجة هذه المشكلة.

تجنّب مصممو لغة جافا استخدام الكلمات المفتاحية الجديدة قدر الإمكان، مفضلين بدلاً من ذلك تقديم تراكيب نحوية جديدة لم تكن مسموحة سابقًا، أو إعادة استخدام الكلمات المفتاحية الموجودة في سياقات جديدة. وبهذه الطريقة، لم يُعرّضوا التوافق مع الإصدارات السابقة للخطر. مثال على ذلك هو كيفية توسيع حلقة for لقبول الأنواع القابلة للتكرار. ومثال على ذلك هو كيفية إعادة استخدام الكلمتين المفتاحيتين extends و super (خاصةً) لتحديد حدود الأنواع عند تقديم الأنواع العامة في جافا 1.5. في وقت ما (جافا 1.4)، تم تقديم كلمة مفتاحية جديدة assert لم تكن محجوزة ككلمة مفتاحية من قبل. كان من الممكن أن يؤدي ذلك إلى إبطال شيفرة برمجية كانت صالحة سابقًا، إذا كانت الشيفرة، على سبيل المثال، تستخدم assert كمعرّف. اختار المصممون معالجة هذه المشكلة بحل من أربع خطوات: 1) إدخال مفتاح تبديل للمترجم يشير إلى ما إذا كان يجب استخدام Java 1.4 أو أحدث، 2) وضع علامة assert ككلمة رئيسية فقط عند الترجمة باستخدام Java 1.4 أو أحدث، 3) استخدام الإصدار 1.3 افتراضيًا لتجنب جعل التعليمات البرمجية السابقة (غير المتوافقة مع الإصدار 1.4) غير صالحة، 4) إصدار تحذيرات، إذا تم استخدام الكلمة الرئيسية في وضع Java 1.3، للسماح بإجراء تغييرات في التعليمات البرمجية.

أدخل مصممو لغة C# العديد من الكلمات المفتاحية الجديدة منذ الإصدار الأول. ومع ذلك، فبدلاً من تعريف هذه الكلمات ككلمات مفتاحية عامة ، تم تعريفها ككلمات مفتاحية حساسة للسياق . هذا يعني أنه حتى عند إدخال الكلمتين المفتاحيتين partial و yield (من بين كلمات أخرى) في C# 2.0، يظل استخدام هاتين الكلمتين كمعرفات صحيحًا، إذ لا يوجد تعارض محتمل بين استخدامهما ككلمة مفتاحية واستخدامهما كمعرف، بالنظر إلى السياق. وبالتالي، فإن بنية C# الحالية متوافقة تمامًا مع الإصدارات السابقة من التعليمات البرمجية، بغض النظر عن إصدار اللغة المستخدم.

switch ( color ) { case Color . Blue : Console . WriteLine ( "اللون أزرق" ); break ; case Color . DarkBlue : Console . WriteLine ( "اللون داكن" ); goto case Color . Blue ; // ... }

استيراد java.io.IOException ؛public int readItem () throws IOException { // ... }

// أنشئ ملفًا صغيرًا باسم "test.txt"، واكتب سلسلة نصية فيه، // ... ثم أغلقه (حتى في حالة حدوث استثناء) باستخدام ( StreamWriter file = new ( "test.txt" )) { file . Write ( "test" ); }

try ( BufferedReader br = new BufferedReader ( new FileReader ( path ))) { return br.readLine ( ) ; }

تتيح لغة C# تقسيم تعريف الصنف إلى عدة ملفات مصدرية باستخدام ميزة تُسمى الأصناف الجزئية . يجب تمييز كل جزء بالكلمة المفتاحية partial . يجب تقديم جميع الأجزاء للمترجم كجزء من عملية ترجمة واحدة. يمكن للأجزاء الإشارة إلى أعضاء من أجزاء أخرى، كما يمكنها تطبيق الواجهات، ويمكن لأحد الأجزاء تعريف صنف أساسي. تُعد هذه الميزة مفيدة في سيناريوهات توليد التعليمات البرمجية (مثل تصميم واجهة المستخدم )، حيث يمكن لمولد التعليمات البرمجية تزويد المطور بجزء، بينما يُزوّد ​​المطور بجزء آخر ليتم تجميعهما معًا. وبالتالي، يستطيع المطور تعديل الجزء الخاص به دون خطر استبداله بواسطة مولد التعليمات البرمجية لاحقًا. على عكس آلية توسيع الأصناف، يسمح الصنف الجزئي بوجود تبعيات دائرية بين أجزائه، حيث يُضمن حلها في وقت الترجمة. لا يوجد مفهوم مماثل في لغة Java.

تسمح كلتا اللغتين بالفئات الداخلية ، حيث تُعرَّف فئة ما معجميًا داخل فئة أخرى. ومع ذلك، فإن لهذه الفئات الداخلية دلالات مختلفة تمامًا في كل لغة .

في لغة جافا، ما لم يُصرَّح عن الفئة الداخلية بأنها ثابتة (static) ، فإن أي إشارة إلى نسخة من فئة داخلية تحمل معها إشارة إلى الفئة الخارجية. ونتيجةً لذلك، يمكن للكود الموجود في الفئة الداخلية الوصول إلى كلٍّ من الأعضاء الثابتة وغير الثابتة للفئة الخارجية. لإنشاء نسخة من فئة داخلية غير ثابتة، يجب تسمية نسخة الفئة الخارجية المُحيطة بها. ^{[ 52 ]} يتم ذلك باستخدام عامل التشغيل الجديد `new` الذي تم تقديمه في JDK 1.3 . يمكن تطبيق هذا في أي فئة تحتوي على إشارة إلى نسخة من الفئة الخارجية.outerClassInstance.new Outer.InnerClass()

في لغة C#، يُعتبر الصنف الداخلي مُرادفًا للصنف العادي من حيث المفهوم. بمعنى آخر، يعمل الصنف الخارجي كمساحة اسم فقط. وبالتالي، لا يمكن للتعليمات البرمجية في الصنف الداخلي الوصول إلى الأعضاء غير الثابتة في الصنف الخارجي إلا من خلال مرجع صريح إلى نسخة من الصنف الخارجي. يمكن للمبرمجين تعريف الصنف الداخلي كصنف خاص (private) بحيث يقتصر الوصول إليه على الصنف الخارجي فقط.

توفر لغة جافا ميزة أخرى تُسمى الفئات المحلية أو الفئات المجهولة ، والتي يمكن تعريفها داخل جسم الدالة. تُستخدم هذه الفئات عادةً لتنفيذ واجهة باستخدام دالة واحدة أو اثنتين فقط، والتي تكون عادةً معالجات أحداث. مع ذلك، يمكن استخدامها أيضًا لتجاوز الدوال الافتراضية للفئة الأصلية. تتمتع الدوال في هذه الفئات المحلية بإمكانية الوصول إلى المتغيرات المحلية للدالة الخارجية المُعلنة كـ final . تُلبي لغة سي شارب حالات استخدام هذه الفئات من خلال توفير المندوبين المجهولين ؛ راجع قسم معالجة الأحداث لمزيد من المعلومات حول هذا الموضوع.

توفر لغة C# ميزة تُسمى الأنواع/الفئات المجهولة ، لكنها تختلف تمامًا عن مفهوم Java الذي يحمل نفس الاسم. فهي تُمكّن المبرمج من إنشاء كائن من فئة ما بمجرد تحديد مجموعة من أسماء خصائص الفئة، وتعبير لتهيئة كل خاصية. ويتم استنتاج أنواع الخصائص من أنواع تلك التعبيرات. وتُشتق هذه الفئات المُعلنة ضمنيًا مباشرةً من الكائن `object` .

تُستخدم مُفوّضات البث المتعدد في لغة C# مع الأحداث . تُوفّر الأحداث دعمًا للبرمجة القائمة على الأحداث ، وهي تطبيق لنمط المُراقب . ولتحقيق ذلك، توجد صيغة مُحدّدة لتعريف الأحداث في الفئات، بالإضافة إلى مُعاملات لتسجيل مُعالجات الأحداث أو إلغاء تسجيلها أو دمجها.

انظر هنا للحصول على معلومات حول كيفية تنفيذ الأحداث في لغة جافا.

يُعدّ تحميل المعاملات الزائد والتحويلات المُعرّفة من قِبل المستخدم ميزتين منفصلتين تهدفان إلى تمكين الأنواع الجديدة من أن تُصبح عناصر أساسية في نظام الأنواع. وباستخدام هاتين الميزتين في لغة C#، تم دمج أنواع مثل Complex و decimal بحيث تعمل المعاملات المعتادة كالجمع والضرب مع هذه الأنواع الجديدة. وعلى عكس لغة C++، تُقيّد لغة C# استخدام تحميل المعاملات الزائد، إذ تمنعه ​​للمعاملات new و و و و وأي صيغ مُختلفة من العبارات المركبة مثل . ولكن المعاملات المركبة ستستدعي المعاملات البسيطة المُحمّلة، مثل استدعاء و . ^{[ 53 ]}( )||&&=+=-=-=

لا تتضمن لغة جافا خاصية تحميل المعاملات الزائدة، ولا التحويلات المخصصة لمنع إساءة استخدام هذه الخاصية وللحفاظ على بساطة اللغة. ^{[ 54 ]}

تتضمن لغة C# أيضًا الفهارس التي يمكن اعتبارها حالة خاصة من تحميل المعاملات الزائد (مثل لغة C++ operator[])، أو خصائص get / set المُعَلمة . الفهرس هو خاصية مُسماة تستخدم مُعاملًا واحدًا أو أكثر (فهرسًا)؛ ويمكن أن تكون الفهارس كائنات من أي نوع.this[]

myList [ 4 ] = 5 ; string name = xmlNode.Attributes [ "name" ] ; orders = customerMap [ theCustomer ] ;

لا تتضمن لغة جافا الفهارس. يعتمد نمط جافا الشائع على كتابة دوال الوصول والتعديل الصريحة، بينما يستخدم مبرمج لغة سي شارب الفهرس.

تستخدم كلتا اللغتين بشكل أساسي آلية جمع البيانات المهملة لاستعادة موارد الذاكرة، بدلاً من تحرير الذاكرة بشكل صريح. في كلتا الحالتين، إذا كان الكائن يحتوي على موارد من أنواع مختلفة غير الذاكرة، مثل مؤشرات الملفات والموارد الرسومية، وما إلى ذلك، فيجب إخطاره صراحةً عندما يتوقف التطبيق عن استخدامه. توفر كل من C# و Java واجهات لهذا النوع من التخلص الحتمي ، كما تتميز كلتاهما (منذ Java 7) بعبارات إدارة موارد تلقائية تستدعي تلقائيًا دوال التخلص/الإغلاق في تلك الواجهات.

تُعدّ الأنواع العامة في جافا بنيةً لغويةً بحتة، إذ تُنفَّذ فقط في المُصرِّف. تتضمن ملفات الفئات المُولَّدة توقيعات الأنواع العامة فقط في صورة بيانات وصفية (مما يسمح للمُصرِّف بتجميع فئات جديدة بناءً عليها). لا يمتلك وقت التشغيل أي معرفة بنظام الأنواع العامة؛ فالأنواع العامة ليست جزءًا من آلة جافا الافتراضية (JVM). بدلاً من ذلك، تُحوَّل فئات وأساليب الأنواع العامة أثناء التجميع عبر عملية تُسمى محو النوع . خلال هذه العملية، يستبدل المُصرِّف جميع الأنواع العامة بنسخها الأصلية ، ويُدرج عمليات التحويل/التحقق المناسبة في كود العميل حيث يُستخدم النوع وأساليبه. لن يحتوي رمز البايت الناتج على أي مراجع لأي أنواع أو معلمات عامة (انظر أيضًا الأنواع العامة في جافا ).

تمنع مواصفات لغة جافا عمدًا استخدامات معينة للأنواع العامة؛ وهذا ضروري للسماح بتنفيذ الأنواع العامة من خلال حذف الأنواع ، ولضمان توافقها مع عمليات الترحيل. ^{[ 71 ]} ولا يزال البحث جاريًا لإضافة الأنواع العامة المُجسّدة إلى منصة جافا، كجزء من مشروع فالهالا .

تعتمد لغة C# على دعم الأنواع العامة من نظام التنفيذ الافتراضي، أي أنها ليست مجرد ميزة لغوية. اللغة هي مجرد واجهة أمامية لدعم الأنواع العامة عبر اللغات في بيئة CLR . أثناء عملية الترجمة، يتم التحقق من صحة الأنواع العامة، ولكن يتم تأجيل توليد الكود اللازم لتنفيذها إلى وقت تحميل الفئة. يتم تجميع كود العميل (الكود الذي يستدعي الطرق/الخصائص العامة) بالكامل، ويمكنه افتراض أن الأنواع العامة آمنة من حيث النوع. يُسمى هذا التجسيد . في وقت التشغيل، عند مصادفة مجموعة فريدة من معلمات النوع لفئة/طريقة/مفوض عام لأول مرة، يقوم مُحمِّل/مُدقِّق الفئات بتوليد واصف فئة ملموس وإنشاء تطبيقات للطرق. أثناء توليد تطبيقات الطرق، تُعتبر جميع أنواع المراجع نوعًا واحدًا، حيث يمكن لأنواع المراجع مشاركة نفس التطبيقات بأمان. هذا فقط لغرض تنفيذ الكود. ستظل مجموعات أنواع المراجع المختلفة تحتوي على واصفات أنواع فريدة؛ وستشير جداول الطرق الخاصة بها إلى نفس الكود.

توضح القائمة التالية بعض الاختلافات بين لغتي Java و C# عند إدارة الأنواع العامة. وهي ليست شاملة: ^{[ 72 ]}

Pair < String , String >[] tenPairs = new Pair [ 10 ] ; // صحيح

object tenPairs = new Pair < int , string > [ 10 ]; // صحيح

class Lookup < K , V > { V [] getEmptyValues ( K key ) { return ( V [] ) new Object [ 0 ] ; // OK } }

class Lookup < K , V extends Comparable <V> > { V [ ] getEmptyValues ( K key ) { return ( V [] ) new Comparable [ 0 ] ; } }

public class Lookup < K , V > { public V [] GetEmptyValues ( K key ) { return new V [ 0 ]; // OK } }

تسمح لغة C# باستخدام الأنواع العامة مباشرةً مع الأنواع الأولية. أما لغة Java، فتسمح باستخدام الأنواع المُغلّفة كمعاملات للأنواع (مثلًا، بدلًا من `<type> `). يأتي هذا بتكلفة، إذ يجب تغليف/فك تغليف جميع هذه القيم عند استخدامها، كما يجب تخصيصها في الذاكرة الديناميكية. مع ذلك، يمكن تخصيص نوع عام باستخدام نوع مصفوفة من نوع أولي في Java، على سبيل المثال، يُسمح باستخدام `<type>`. ^{[ 77 ]} قامت العديد من مكتبات الطرف الثالث بتنفيذ المجموعات الأساسية في Java باستخدام مصفوفات أولية داعمة للحفاظ على تحسين وقت التشغيل والذاكرة الذي توفره الأنواع الأولية. ^{[ 78 ]}List<Integer>List<int>List<int[]>

استُلهم تصميم حذف الأنواع في جافا من متطلبات التصميم لتحقيق التوافق مع عمليات الترحيل ، مع التنويه إلى عدم الخلط بينه وبين التوافق مع الإصدارات السابقة . وبالتحديد، كان الشرط الأصلي هو: " ... يجب أن يكون هناك مسار ترحيل واضح وقابل للإثبات لواجهات برمجة تطبيقات المجموعات التي تم تقديمها في منصة جافا 2 ". ^{[ 44 ]} وقد صُمم هذا بحيث يمكن تمرير أي مجموعات عامة جديدة إلى الطرق التي تتوقع إحدى فئات المجموعات الموجودة مسبقًا. ^{[ 79 ]}

تم إدخال ميزة الأنواع العامة في لغة C# مع الحفاظ على التوافق التام مع الإصدارات السابقة، ولكن لم يتم الحفاظ على التوافق التام مع التحديثات اللاحقة : يعمل الكود القديم (قبل C# 2.0) دون تغيير على بيئة التشغيل الجديدة المتوافقة مع الأنواع العامة دون الحاجة إلى إعادة تجميع. أما بالنسبة للتوافق مع التحديثات اللاحقة ، فقد تم تطوير فئات وواجهات جديدة للمجموعات العامة تُكمّل مجموعات .NET 1.x غير العامة بدلاً من استبدالها. بالإضافة إلى واجهات المجموعات العامة، تُطبّق فئات المجموعات العامة الجديدة واجهات المجموعات غير العامة حيثما أمكن. هذا يمنع استخدام المجموعات العامة الجديدة مع الطرق الموجودة مسبقًا (غير المتوافقة مع الأنواع العامة)، إذا كانت هذه الطرق مُبرمجة لاستخدام فئات المجموعات .

يدعم كلا اللغتين التغاير والتغاير العكسي. تتميز لغة جافا بخاصية التباين في موقع الاستخدام، والتي تسمح لفئة عامة واحدة بتعريف أعضاء باستخدام كلٍ من التغاير والتغاير العكسي. أما لغة سي شارب، فتتميز بخاصية التباين في موقع التعريف للواجهات العامة والمفوضين. لا يُدعم التباين مباشرةً على مستوى الفئات، ولكنه يُدعم من خلال تطبيقها للواجهات المتغيرة. كما تدعم لغة سي شارب التغاير في موقع الاستخدام للأساليب والمفوضين.

الإغلاق هو دالة مضمنة تلتقط المتغيرات من نطاقها المعجمي.

تدعم لغة C# الدوال المغلقة كطرق مجهولة أو تعبيرات لامدا مع دلالات إغلاق كاملة الميزات . ^{[ 85 ] [ 86 ]}

في لغة جافا، ستظل الفئات الداخلية المجهولة هي الطريقة المُفضلة لمحاكاة الدوال المغلقة حتى يصبح الإصدار 8 من جافا هو المعيار الجديد. يُعد هذا الأسلوب أكثر تفصيلاً، كما أنه يختلف عن الدوال المغلقة الحقيقية في بعض الجوانب، لا سيما التحكم المُحكم في الوصول إلى المتغيرات من النطاقات المُحيطة: إذ لا يُمكن الإشارة إلا إلى الأعضاء النهائية. مع ذلك، يُقدم الإصدار 8 من جافا تعابير لامدا التي ترث النطاق الحالي بالكامل، ولا تُنشئ نطاقًا جديدًا.

عندما يُمكن تمرير مرجع إلى دالة لتنفيذها لاحقًا، يبرز إشكالٌ حول كيفية التعامل مع وجود مراجع لمتغيرات/معاملات ضمن النطاق المعجمي لهذه الدالة. في لغة C#، يُمكن للدوال المغلقة الوصول إلى أي متغير/معامل من نطاقها المعجمي. أما في Java، فيُسمح فقط بالمراجع إلى الأعضاء النهائية في النطاق المعجمي، مما يُلزم المطور بتحديد المتغيرات التي يجب إتاحتها، وحالتها (وقد يتطلب ذلك استخدام تقنية التغليف).

تتميز لغتا C# و Java بنوع خاص من الدوال المغلقة المضمنة تُسمى دوال لامدا . هذه الدوال مجهولة الهوية: لها توقيع وجسم، ولكن ليس لها اسم. تُستخدم بشكل أساسي لتحديد وسائط محلية ذات قيم دوال في استدعاءات دوال أخرى، وهي تقنية ترتبط بشكل رئيسي بالبرمجة الوظيفية .

تتيح لغة C#، على عكس لغة Java، استخدام دوال لامدا لتعريف هياكل بيانات خاصة تُسمى أشجار التعبير. ويعتمد تصنيفها كدالة قابلة للتنفيذ أو كهيكل بيانات على استنتاج نوع المُصرّف ونوع المتغير أو المعامل الذي تُسند إليه أو تُحوّل إليه. وتلعب دوال لامدا وأشجار التعبير أدوارًا محورية في استعلام اللغة المتكامل (LINQ).

في لغة C#، تُشابه مساحات الأسماء تلك الموجودة في لغة C++ . على عكس أسماء الحزم في لغة Java، لا ترتبط مساحة الاسم بموقع ملف المصدر بأي شكل من الأشكال. مع أنه ليس من الضروري تمامًا أن يتطابق موقع ملف مصدر Java مع بنية دليل الحزمة، إلا أن هذا هو التنظيم المتعارف عليه.

تسمح كلتا اللغتين باستيراد الأصناف (كما في جافا مثلاً)، مما يتيح الإشارة إلى الصنف باستخدام اسمه فقط. أحيانًا، توجد أصناف تحمل الاسم نفسه في مساحات أسماء أو حزم متعددة. يمكن الإشارة إلى هذه الأصناف باستخدام الأسماء الكاملة، أو باستيراد أصناف محددة بأسماء مختلفة. وللقيام بذلك، تسمح جافا باستيراد صنف واحد (مثلاً، ). أما لغة C# فتسمح باستيراد الأصناف تحت اسم محلي جديد باستخدام الصيغة التالية: . كما تسمح باستيراد تخصصات الأصناف على شكل .importjava.util.*importjava.util.ListusingConsole=System.ConsoleusingIntList=System.Collections.Generic.List<int>

تتميز كلتا اللغتين بصيغة استيراد ثابتة تسمح باستخدام الاسم المختصر لبعض أو كل الدوال/الحقول الثابتة في فئة ما (على سبيل المثال، السماح باستيراد foo(bar)دالة foo()ثابتة من فئة أخرى). تعتمد لغة C# على صيغة فئات ثابتة (لا ينبغي الخلط بينها وبين الفئات الداخلية الثابتة في Java)، مما يقصر محتوى الفئة على الدوال الثابتة فقط. يُقدم الإصدار 3.0 من C# دوال الإضافة التي تسمح للمستخدمين بإضافة دالة ثابتة إلى نوع ما (على سبيل المثال، السماح foo.bar()باستيراد bar()دالة إضافة تعمل على نوع foo ).

يشترط مُصرّف جافا من صن مايكروسيستمز أن يتطابق اسم ملف المصدر مع اسم الفئة العامة الوحيدة الموجودة فيه، بينما يسمح C# بوجود فئات عامة متعددة في الملف نفسه، ولا يفرض أي قيود على اسم الملف. يسمح C# 2.0 والإصدارات الأحدث بتقسيم تعريف الفئة إلى عدة ملفات باستخدام الكلمة المفتاحية partial في شفرة المصدر. في جافا، تكون الفئة العامة دائمًا في ملف مصدر خاص بها. أما في C#، فلا توجد علاقة وثيقة بين ملفات شفرة المصدر وفصل الوحدات المنطقية.

على عكس جافا، تُنفّذ لغة C# الترجمة الشرطية باستخدام توجيهات المعالج المسبق . كما توفر سمة Conditional لتعريف الدوال التي تُستدعى فقط عند تعريف ثابت ترجمة مُحدد. بهذه الطريقة، يُمكن توفير التأكيدات كميزة إطار عمل باستخدام الدالة التي تُقيّم فقط عند تعريف ثابت DEBUG . منذ الإصدار 1.4، توفر جافا ميزة لغوية للتأكيدات، وهي مُعطّلة افتراضيًا أثناء التشغيل، ولكن يُمكن تفعيلها باستخدام مفتاح التبديل عند استدعاء JVM.Debug.Assert()-enableassertions-ea

مع إصدار .NET Framework 4.0، تم تقديم نموذج برمجة جديد قائم على المهام ليحل محل النموذج غير المتزامن القائم على الأحداث. تعتمد واجهة برمجة التطبيقات (API) على المهام والفئات . ويمكن دمج المهام وربطها ببعضها البعض.Task<T>

بحسب العرف، يجب أن يكون اسم كل طريقة تُرجع مهمة (Task) متبوعًا بـ Async .

باستخدام System.Threading.Tasks ؛public static class SomeAsyncCode { public static Task <XDocument> GetContentAsync ( ) { HttpClient httpClient = new ( ); return httpClient.GetStringAsync ( " www.contoso.com" ) . ContinueWith (( task ) = > { string responseBodyAsText = task.Result ; return XDocument.Parse ( responseBodyAsText ) ; } ) ; } }Task t = SomeAsyncCode.GetContentAsync ( ) . ContinueWith ( ( task ) => { XDocument xmlDocument = task.Result ; } ) ;t . ابدأ ();

في لغة C# 5، تم تقديم مجموعة من امتدادات اللغة والمترجم لتسهيل التعامل مع نموذج المهام. تضمنت هذه الامتدادات مفهوم الأساليب غير المتزامنة وعبارة await التي تجعل تدفق البرنامج يبدو متزامنًا.

باستخدام System.Threading.Tasks ؛public static class SomeAsyncCode { public static async Task <XDocument> GetContentAsync ( ) { HttpClient httpClient = new ( ) ; string responseBodyAsText = await httpClient.GetStringAsync ( " www.contoso.com" ) ; return XDocument.Parse ( responseBodyAsText ) ; } }XDocument xmlDocument = await SomeAsyncCode . GetContentAsync ();// سيتم بدء المهمة عند استدعائها باستخدام await.

من خلال هذا الاختصار النحوي، يقوم مترجم لغة C# بإنشاء آلة حالة تتعامل مع الاستمراريات الضرورية دون أن يضطر المطورون إلى التفكير في ذلك.

يدعم جافا الخيوط منذ إصدار JDK 1.0. يوفر جافا مرونة عالية لتشغيل الخيوط، والتي تُسمى غالبًا بالمهام. يتم ذلك من خلال تطبيق واجهة وظيفية ( java.lang.Runnableواجهة) تُعرّف دالة واحدة من نوع void بدون وسائط، كما هو موضح في المثال التالي:

var myThread = new Thread (() -> {String threadName = Thread.currentThread (). getName ( ) ;System.out.println ( " Hello " + threadName ) ;​});myThread.start ( ) ;

على غرار لغة C#، تمتلك Java آلية عالية المستوى للتعامل مع الخيوط. يمكن للمنفذين تنفيذ المهام غير المتزامنة وإدارة مجموعة من العمليات الفرعية. تُدار جميع خيوط مثيل ExecutorService في مجمع . يُعاد استخدام مثيل ExecutorService هذا داخليًا للمهام المتكررة، مما يُتيح للمبرمج تشغيل أي عدد من المهام المتزامنة طوال دورة حياة التطبيق باستخدام مثيل ExecutorService واحد. علاوة على ذلك، تدعم Java الخيوط الافتراضية ، وهي خيوط خفيفة الوزن للغاية تسمح بتزامن هائل دون أي تكلفة إضافية للخيوط التقليدية في النظام الأساسي، على الرغم من استخدامها جنبًا إلى جنب مع نموذج ExecutorService القياسي.

هكذا يبدو المثال الأول للخيط باستخدام المنفذين:

استيراد الوحدة النمطية java.base ؛​var executor = Executors . newSingleThreadExecutor ();executor.submit ( () - > {var threadName = Thread.currentThread (). getName ( ) ;IO.println ( "Hello " + threadName ) ;});

يدعم مثيل ExecutorService أيضًا واجهة Callable ، وهي واجهة أخرى ذات دالة واحدة مثل Runnable، ولكن توقيع الدالة المُضمنة في Callable يُرجع قيمة. وبهذه الطريقة، يجب أن يُرجع تعبير lambda قيمة أيضًا، كما في المثال أدناه لاستدعاء موقع ويب بشكل غير متزامن في مثال C#.

استيراد الوحدة النمطية java.base ؛​استيراد وحدة جافا.نت. http ؛​​​class SomeAsyncCode {static Future <String> getContentAsync ( ) {var executor = Executors . newSingleThreadExecutor ();return executor.submit ( () - > {var httpReq = HttpRequest.newBuilder ( )​. uri ( new URI ( "https://www.graalvm.org" )). يبني ()؛return HttpClient.newHttpClient ( )​. إرسال ( httpReq , HttpResponse . BodyHandlers . ofString ()). جسم ()؛});}}void main () throws Exception {var webPageResult = SomeAsyncCode . الحصول على المحتوى (). يحصل ()؛IO.println ( webPageResult ) ;​}

يؤدي استدعاء هذه الطريقة get()إلى حظر الخيط الحالي والانتظار حتى يكتمل استدعاء الدالة قبل إرجاع القيمة (في المثال، محتوى صفحة ويب):

ولتوفير الدعم الكافي للتطبيقات في مجال الحسابات الرياضية والمالية، توجد العديد من ميزات اللغة. ^{[ 92 ]}

تُمكّن الكلمة المفتاحية strictfp في لغة جافا من إجراء حسابات دقيقة للأعداد العشرية في جزء من الكود. تتطلب هذه الحسابات تحويل النتائج الوسيطة إلى نوعي Single/Double، حتى لو كانت المنصة تدعم دقة أعلى أثناء الحساب. يضمن هذا أن تُعيد حسابات الأعداد العشرية الدقيقة نفس النتيجة تمامًا على جميع المنصات. بدون استخدام الأعداد العشرية الدقيقة، يُمكن للمنصة استخدام دقة أعلى للنتائج الوسيطة أثناء الحساب. تسمح لغة C# للتنفيذ، المُصمم لبنية أجهزة معينة، باستخدام دقة أعلى للنتائج الوسيطة دائمًا، إن توفرت، أي أن C# لا تسمح للمبرمج بفرض استخدام دقة أقل للنتائج الوسيطة. ^{[ 93 ]}

على الرغم من أن حسابات الفاصلة العائمة في جافا تعتمد إلى حد كبير على معيار IEEE 754 (معيار حسابات الفاصلة العائمة الثنائية)، إلا أن بعض الميزات غير مدعومة حتى عند استخدام مُعدِّل strictfp، مثل علامات الاستثناء والتقريب الموجه، وهي قدرات يفرضها معيار IEEE 754 (انظر نقد جافا، حسابات الفاصلة العائمة ).

توفر لغة C# نوع بيانات عشري مدمجًا، ^{[ 94 ]} يتميز بدقة أعلى (ولكن بنطاق أضيق) من نوع البيانات double في Java/C#. يُعدّ النوع العشري نوع بيانات 128 بت، وهو مناسب للحسابات المالية والنقدية. يمكن لهذا النوع تمثيل قيم تتراوح من 1.0 × 10⁻²⁸ ^إلى حوالي 7.9 × ^10²⁸ ، مع 28-29 رقمًا معنويًا. ^{[ 95 ]} يستخدم هذا النوع خاصية تحميل المعاملات الزائدة في C#، مما يسمح بمعالجة الأعداد العشرية باستخدام معاملات مثل + و- و * و / ، تمامًا مثل أنواع البيانات الأولية الأخرى.

تتيح أنواع البيانات BigDecimal`int` و`int` BigIntegerالمتوفرة في جافا تمثيل الأعداد العشرية والأعداد الصحيحة بدقة غير محدودة، على التوالي. ولا تحتوي مكتبة جافا القياسية على فئات للتعامل مع الأعداد المركبة.

تتيح الأنواع BigInteger[ ^{3 ]} و ^{[ 96 ]} المتوفرة في لغة C# تمثيل ومعالجة الأعداد الصحيحة والأعداد المركبة ذات الدقة العشوائية، على التوالي. تستخدم هذه البنى خاصية تحميل المعاملات الزائدة في C#، مما يسمح بمعالجة الكائنات باستخدام معاملات مثل ⁺ و- و * و / ، كما هو الحال مع أنواع البيانات الأولية الأخرى. لا تحتوي مكتبة C# القياسية على فئات للتعامل مع أعداد الفاصلة العائمة ذات الدقة العشوائية (انظر برنامج العمليات الحسابية ذات الدقة العشوائية ).Complex

يمكن للغة C# أن تساعد التطبيقات الرياضية باستخدام checkedعوامل uncheckedالتشغيل التي تسمح بتمكين أو تعطيل التحقق من تجاوز السعة الحسابية في وقت التشغيل لمنطقة معينة من التعليمات البرمجية.

تُعد ميزة الاستعلام المتكامل للغة C# (LINQ) مجموعة من الميزات المصممة للعمل معًا للسماح بإمكانيات الاستعلام داخل اللغة، وهي ميزة مميزة بين C# و Java.

يتضمن LINC هذه الميزات:

• تتيح أساليب الإضافة توسيع الواجهات أو الفئات الموجودة بأساليب جديدة. ويمكن مشاركة التطبيقات أو تخصيص تطبيق لكل واجهة.
• تسمح الدوال اللامدا بالتعبير عن المعايير بطريقة وظيفية.
• تتيح أشجار التعبير لتطبيق معين التقاط تعبير لامدا كشجرة بناء جملة مجردة بدلاً من كتلة قابلة للتنفيذ. ويمكن للتطبيقات الاستفادة من ذلك لتمثيل المعايير بلغة مختلفة، على سبيل المثال في شكل جملة شرطية في لغة SQL، كما هو الحال مع LINQ وLINQ to SQL .
• تدعم الأنواع المجهولة واستنتاج الأنواع التقاط نوع نتيجة الاستعلام والتعامل معه. قد يقوم الاستعلام بربط مصادر الاستعلام وإسقاطها، مما قد يؤدي إلى نوع نتيجة لا يمكن تسميته.
• تعبيرات الاستعلام لدعم بناء جملة مألوف لمستخدمي SQL .
• أنواع قابلة للتصفير (مرفوعة) للسماح بمطابقة أفضل مع موفري الاستعلام الذين يدعمون الأنواع القابلة للتصفير، مثل SQL على سبيل المثال .

توفر منصة جافا آليات متعددة للتفاعل مع التعليمات البرمجية الأصلية. أحدث هذه الآليات هي واجهة برمجة تطبيقات الوظائف الخارجية والذاكرة (FFM API)، التي طُوّرت ضمن مشروع بنما ^{[ 118 ]} ، والتي تُقدّم منهجًا معياريًا أكثر أمانًا وكفاءة لاستدعاء الوظائف الأصلية والوصول إلى الذاكرة الأصلية دون الاعتماد على واجهة جافا الأصلية (JNI). تُقلّل واجهة FFM API من الحمل الزائد وتُزيل الكثير من التعليمات البرمجية المتكررة المرتبطة تقليديًا بـ JNI، مع تمكين أداء أقرب إلى الأداء الأصلي والحفاظ على ضمانات السلامة ودورة حياة التعليمات البرمجية. ^{[ 119 ]}

تاريخياً، كانت JNI هي الآلية الأساسية للتوافق الأصلي في Java ولا تزال تستخدم على نطاق واسع في قواعد التعليمات البرمجية الحالية.

تتيح ميزة واجهة جافا الأصلية (JNI) لبرامج جافا استدعاء أكواد غير مكتوبة بلغة جافا. مع ذلك، تتطلب JNI من الكود المُستدعى اتباع عدة اصطلاحات، وتفرض قيودًا على أنواع البيانات والأسماء المستخدمة. هذا يعني الحاجة غالبًا إلى طبقة وسيطة إضافية بين الكود القديم وجافا. يجب كتابة هذا الكود الوسيط بلغة غير جافا، غالبًا C أو C++. أما ميزة الوصول الأصلي لجافا (JNA) فتتيح استدعاءً أسهل للأكواد الأصلية، ما يتطلب كتابة كود جافا فقط، ولكن على حساب الأداء.

بالإضافة إلى ذلك، توفر مكتبات الطرف الثالث جسر نموذج كائن المكون (COM)، على سبيل المثال، JACOB ( برنامج مجاني ) و J-Integra لـ COM ( برنامج احتكاري ).

عادةً ما يوجد الكود الأصلي في مكتبة ، والتي يمكن لجافا التفاعل معها عبر هذه الآليات.

توفر منصة .NET للاستدعاء ( P/Invoke ) نفس الإمكانية من خلال السماح باستدعاءات من لغة C# لما تسميه مايكروسوفت " التعليمات البرمجية غير المُدارة" . يستطيع المبرمج، عبر سمات البيانات الوصفية، التحكم بدقة في كيفية معالجة المعاملات والنتائج ، متجنبًا بذلك الحاجة إلى التعليمات البرمجية الخارجية اللازمة لـ JNI المكافئ في Java. تتيح P/Invoke وصولًا شبه كامل إلى واجهات برمجة التطبيقات الإجرائية (مثل Win32 أو POSIX)، ولكن وصولًا محدودًا إلى مكتبات فئات C++.

بالإضافة إلى ذلك، يوفر إطار عمل .NET أيضًا جسر .NET-COM، مما يسمح بالوصول إلى مكونات COM كما لو كانت كائنات .NET من الدرجة الأولى.

تتيح لغة C# للمبرمج تعطيل التحقق من الأنواع وميزات الأمان الأخرى في بيئة CLR ، مما يسمح باستخدام متغيرات المؤشر . عند استخدام هذه الميزة، يجب على المبرمج وضع علامة على الكود باستخدام الكلمة المفتاحية `unsafe` . تُعدّ كل من JNI وP/Invoke والكود "غير الآمن" ميزات خطيرة بنفس القدر، إذ تُعرّض التطبيقات لثغرات أمنية محتملة وعدم استقرار. من مزايا الكود المُدار غير الآمن مقارنةً بـ P/Invoke أو JNI أنه يسمح للمبرمج بمواصلة العمل في بيئة C# المألوفة لإنجاز بعض المهام التي تتطلب عادةً استدعاء كود غير مُدار. يجب تجميع أي برنامج أو مكتبة تستخدم كودًا غير آمن باستخدام مفتاح خاص، وسيتم وضع علامة عليه. يُمكّن هذا بيئات التشغيل من اتخاذ احتياطات خاصة قبل تنفيذ أي كود قد يكون ضارًا.

صُممت لغة البرمجة جافا للتنفيذ على منصة جافا عبر بيئة تشغيل جافا (JRE). تتضمن منصة جافا آلة جافا الافتراضية (JVM) ومجموعة من المكتبات المشتركة. صُممت بيئة تشغيل جافا في الأصل لدعم التنفيذ التفسيري مع إمكانية الترجمة النهائية. تُنفذ معظم بيئات تشغيل جافا برامج مترجمة كليًا أو جزئيًا على الأقل، مع إمكانية التحسين التكيفي . يُنتج مُترجم جافا بايت كود جافا . عند التنفيذ، يتم تحميل البايت كود بواسطة بيئة تشغيل جافا، ويتم تفسيره مباشرةً أو ترجمته إلى تعليمات الآلة ثم تنفيذه.

صُممت لغة C# للتنفيذ على بيئة تشغيل اللغة المشتركة (CLR). صُممت بيئة تشغيل اللغة المشتركة لتنفيذ التعليمات البرمجية المُترجمة بالكامل. يُنتج مُترجم لغة C# تعليمات لغة وسيطة مشتركة . عند التنفيذ، تقوم بيئة التشغيل بتحميل هذه التعليمات البرمجية وترجمتها إلى تعليمات الآلة على بنية النظام المستهدف.

مثال يوضح كيفية نسخ النص سطرًا سطرًا من ملف إلى آخر، باستخدام اللغتين.

استيراد الوحدة النمطية java.base ؛​void main () throws Exception { var input = Paths . get ( "input.txt" ); var output = Paths . get ( "output.txt" );var lines = Files.readAllLines ( input ) ; Files.write ( output , lines ) ; }​​

باستخدام System.Collections.Generic ؛ باستخدام System.IO ؛class FileIOTest { public static void Main ( string [] args ) { IEnumerable < string > lines = File . ReadLines ( "input.txt" ); File . WriteAllLines ( "output.txt" , lines ); } }

تتيح لغة C# دمج الأنواع المعرفة في المكتبة مع الأنواع والمعاملات الموجودة باستخدام التحويلات الضمنية/الصريحة المخصصة وتحميل المعاملات الزائد كما هو موضح في المثال التالي:

استيراد java.math.BigInteger ؛BigInteger bigNumber = BigInteger ( "123456789012345678901234567890" );BigInteger answer = bigNumber.multiply ( BigInteger.valueOf ( 42 ) ) ; BigInteger square = bigNumber.sqrt ( ) ; BigInteger sum = bigNumber.add ( bigNumber ) ;​​​

باستخدام System.Numerics ؛BigInteger bigNumber = BigInteger.Parse ( "123456789012345678901234567890 " ) ;عدد صحيح كبير للإجابة = العدد الكبير * 42 ؛ عدد صحيح كبير للمربع = العدد الكبير * العدد الكبير ؛ عدد صحيح كبير للمجموع = العدد الكبير + العدد الكبير ؛

يوضح هذا المثال كيفية استخدام لغتي Java وC# لإنشاء واستدعاء نسخة من فئة مُنفذة بلغة برمجة أخرى. فئة "Deepthought" مُنفذة بلغة برمجة Ruby ، وهي عبارة عن آلة حاسبة بسيطة تقوم بضرب قيمتين مُدخلتين ( a و b ) عند استدعاء دالة Calculate . بالإضافة إلى الطريقة التقليدية، توفر Java آلة GraalVM الافتراضية، القادرة على تشغيل أي لغة برمجة مُنفذة.

Context polyglot = Context.newBuilder (). allowAllAccess ( true ) .build ( ) ;// Ruby Value rubyArray = polyglot.eval ( "ruby" , " [ 1,2,42,4]" ); int rubyResult = rubyArray.getArrayElement ( 2 ) .asInt ( ) ;// قيمة بايثون pythonArray = polyglot.eval ( " python " , " [ 1,2,42,4]" ) ; int pythonResult = pythonArray.getArrayElement ( 2 ) .asInt ( );// قيمة جافا سكريبت jsArray = متعدد اللغات . إيفال ( "js" ، "[1,2,42,4]" )؛ int jsResult = jsArray . الحصول على عنصر الصفيف ( 2 ). asInt ();// قيمة R rArray = polyglot.eval ( "R" , " c ( 1,2,42,4)" ); int rResult = rArray.getArrayElement ( 2 ) .asInt ( );// LLVM (في هذه الحالة C، ولكن يمكن أن تكون C++ أو Go أو Basic، إلخ...) المصدر source = Source.newBuilder ( " llvm " , new File ( "C_Program.bc" )). build (); القيمة cpart = polyglot.eval ( source ) ; cpart.getMember ( " main " ). execute ( );

استيراد java.io.FileReader ؛ استيراد javax.script.* ؛ استيراد org.jruby.* ؛// تهيئة المحرك ScriptEngineManager invocable = new ScriptEngineManager ( ). getEngineByName ( "jruby" ); FileReader rubyFile = new FileReader ( "Deepthought.rb" ); engine.eval ( fr ) ;

// إنشاء نسخة جديدة من آلة حاسبة "Deepthought" Object calcClass = engine.eval ( " Deepthought " ); Object calc = invocable.invokeMethod ( calcClass , " new" );// ضبط قيم إدخال الآلة الحاسبة invocable.invokeMethod ( calc , " a=" , 6 ) ; invocable.invokeMethod ( calc , "b=" , 7 ) ;// حساب النتيجة Object answer = invocable.invokeMethod ( calc , "Calculate" ) ;

باستخدام System ؛ باستخدام Microsoft.Scripting.Hosting ؛ باستخدام IronRuby ؛// تهيئة المحركScriptRuntime runtime = ScriptRuntime.CreateFromConfiguration ( ) ; dynamic globals = runtime.Globals ;​​runtime.ExecuteFile ( "Deepthought.rb " ) ;

// إنشاء نسخة جديدة من آلة حاسبة "Deepthought" ديناميكيًا calc = globals.Deepthought . @ new ( );// ضبط قيم إدخال الآلة الحاسبة calc.a = 6 ; calc.b = 7 ;// حساب النتيجة ديناميكيًا الإجابة = calc.Calculate ( );

يوضح هذا المثال كيفية تطبيق متتالية فيبوناتشي باستخدام اللغتين. تستفيد نسخة C# من دوال المولدات الخاصة بها ، بينما تستفيد نسخة Java من واجهة Stream ومراجع الدوال. يستخدم كلا المثالين، Java وC#، أسلوب K&R لتنسيق الكود الخاص بالفئات والدوال والعبارات.

// سلسلة فيبوناتشي Stream.generate ( new Supplier <Integer> ( ) { int a = 0 ; int b = 1 ;​public Integer get () { int temp = a ; a = b ; b = a + temp ; return temp ; } } ) . limit ( 10 ) .forEach ( System.out :: println ) ;

باستخدام System.Collections.Generic ؛// متتالية فيبوناتشي العامة IEnumerable <int> Fibonacci ( ) { int a = 0 ; int b = 1 ;بينما ( صحيح ) { أرجع a ؛ ( a ، b ) = ( b ، a + b ) ؛ } }

// اطبع أول 10 أعداد من متتالية فيبوناتشي foreach ( int it in Fibonacci (). Take ( 10 )) { Console . WriteLine ( it ); }

استيراد java.util.stream.Stream ؛ استيراد java.util.function.Supplier ؛Iterable <Integer> fibonacci ( int limit ) { return Stream.generate ( new Supplier <Integer> ( ) { int a = 0 ; int b = 1 ; public Integer get ( ) { int temp = a ; a = b ; b = a + temp ; return temp ; } } ) . limit ( limit ) :: iterator ; }​

// اطبع أول 10 أعداد من متتالية فيبوناتشي for ( int it : fibonacci ( 10 )) { System . out . println ( it ); }

استيراد java.util.stream.Stream ؛ استيراد java.util.function.Supplier ؛Stream <Integer> fibonacci = Stream.generate ( new Supplier <Integer> ( ) { int a = 0 ; int b = 1 ; public Integer get ( ) { int temp = a ; a = b ; b = a + temp ; return temp ; } } ) ;​​

// اطبع أول 10 أعداد من متتالية فيبوناتشي for ( int it : fibonacci . limit ( 10 ). toList ()) { System . out . println ( it ); }