بناء جملة جافا

الكلمات التالية هي كلمات مفتاحية ولا يمكن استخدامها كمعرفات تحت أي ظرف من الظروف، ويبلغ عددها 47 كلمة.

الكلمات التالية هي كلمات مفتاحية سياقية، وهي مقيدة فقط في سياقات معينة، ويبلغ عددها 16 سياقًا.

تشير الكلمات التالية إلى القيم الحرفية المستخدمة في اللغة، والتي يوجد منها 3.

الكلمات التالية محجوزة ككلمات مفتاحية، ولكن ليس لها حاليًا أي استخدام أو غرض، وعددها 4.

منذ إصدار Java 10، أصبح من الممكن استنتاج أنواع المتغيرات تلقائيًا باستخدام var.

استيراد java.io.FileOutputStream ؛// سيكون للتدفق نوع FileOutputStream كما هو مستنتج من مُهيئه var stream = new FileOutputStream ( "file.txt" );// إعلان مكافئ بنوع صريح FileOutputStream stream = new FileOutputStream ( "file.txt" );

java.lang.Systemتُعدّ هذه الفئة واحدة من أهم الفئات الأساسية في لغة جافا. وهي فئة مساعدة للتفاعل مع النظام، وتحتوي على مدخلات ومخرجات وتدفقات أخطاء قياسية، وخصائص النظام ومتغيرات البيئة، والوقت، وغير ذلك.

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

جميع السجلات ترث ضمنيًا من java.lang.Record. وبالتالي، فإن a record، على الرغم من معاملتها كـ a class، لا يمكنها أن ترث من أي فئة أخرى.

جميع الأنواع المُعدّدة (enums) في جافا ترث ضمنيًا من فئة أخرى java.lang.Enum<E>. لذا، enumعلى الرغم من أن النوع المُعدّد يُعامل كنوع مُعدّد ، إلا أنه لا يمكنه أن يرث من أي فئة أخرى. يتم تقييد classمُعامل النوع على أنه نوع مُعدّد .EEnum<EextendsEnum<E>>

java.lang.Class<T>هي فئة تمثل عنصرًا classأو interfaceكائنًا في التطبيق أثناء التشغيل. لا يمكن إنشاؤها عبر إنشاء مثيل مباشر، بل يتم إنشاؤها بواسطة JVM عند اشتقاق فئة من بايتات .classملف . يمكن الحصول على قيمة حرفية للفئة من خلال استدعاء دالة X.classعلى هذه الفئة X. على سبيل المثال، String.classتُرجع الدالة Class<String>`. يمكن تمثيل فئة غير معروفة يتم نمذجتها على النحو التالي: Class<?>`(حيث ?يشير ` إلى حرف بدل ).`

بينما X.classيبدو أنه يصل إلى حقل باسم " class "، فإنه في الواقع لا يوجد حقل بهذا الاسم ؛ بل يقوم في الحقيقة بتنفيذ التعليمات التي تدفع قيمة ثابتة من مجموعة الثوابت الخاصة بوقت التشغيل للفئة إلى مكدس المعاملات. ^{[ 1 ]}ldc

java.lang.Stringهو نوع السلسلة الأساسي في جافا. وهو غير قابل للتغيير . لا يُنفذ واجهة `for` Iterable<Character>، لذا لا يمكن تكراره في حلقة `for-each`، ولكن يمكن تحويله إلى `true` char[]. تتعامل بعض الطرق مع كل وحدة ترميز UTF-16 كسلسلة نصية، ولكن تتوفر أيضًا charطرق لتحويلها إلى سلسلة نصية int[]تُعتبر فعليًا UTF-32String . يُنفذ واجهة ` for` java.lang.CharSequence، لذا يمكن الوصول إلى عناصر السلسلة النصية باستخدام الطريقة `for` .charStringcharAt()

java.lang.Throwableهو النوع الأساسي لكل ما يمكن طرحه أو التقاطه باستخدام عبارات Java throwو catch. فئاته الفرعية المعروفة مباشرة هي java.lang.Error(للأخطاء الجسيمة التي لا يمكن إصلاحها) و java.lang.Exception(للاستثناءات التي قد تحدث بشكل طبيعي أثناء تنفيذ البرنامج).

java.lang.Mathهي فئة مساعدة تحتوي على وظائف رياضية وثوابت رياضية (مثل Math.sin()، Math.pow()، و Math.PI).

java.lang.IOهي فئة تم تقديمها في Java 25 (كانت موجودة سابقًا في java.io) java.io.IO. وهي تتيح الوصول بشكل أبسط إلى تدفقات الإدخال والإخراج القياسية عبر System.inو System.out.

لكل نوع بدائي فئة تغليف مرتبطة به (انظر الأنواع البدائية ).

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

package org.wikipedia.examples ;استيراد java.util.Random ؛ // تعريف نوع واحدpublic class ImportsTest { public static void main ( String [] args ) { /* السطر التالي مكافئ لـ  * java.util.Random random = new java.util.Random();  * كان سيكون غير صحيح بدون الاستيراد.  */ Random random = new Random (); } }

تم ذكر تعريفات الاستيراد عند الطلب في الكود. يستورد "الاستيراد العام" (أو "الاستيراد الشامل") جميع أنواع الحزمة. بينما يستورد "الاستيراد الثابت" عناصر الحزمة.

/** * يتيح هذا الشكل من استيراد الفئات الوصول إلى جميع الفئات * في حزمة java.util بالاسم، ويمكن استخدامه بدلاً من * تعريف الاستيراد في المثال السابق. */ import java.util.* ;

قد لا يستورد استيراد الأحرف البديلة أي شيء إذا لم تكن هناك رموز موجودة في تلك الحزمة. على سبيل المثال، عبارات مثل "استيراد عام" صحيحة، لكنها لا تفعل شيئًا، لأن جميع الفئات موجودة في حزم داخل حزمة أخرى ؛ لن يستورد هذا النوع من الاستيراد جميع الفئات في الحزمة بشكل متكرر.importjava.*;java

هذا النوع من التصريحات متاح منذ J2SE 5.0 . تسمح تصريحات الاستيراد الثابتة بالوصول إلى الأعضاء الثابتة المُعرَّفة في فئة أو واجهة أو تعليق توضيحي أو تعداد آخر؛ دون تحديد اسم الفئة:

import static java.lang.System.out ; // 'out' هو حقل ثابت في java.lang.Systempublic class HelloWorld { public static void main ( String [] args ) { /* السطر التالي مكافئ لـ  System.out.println("Hi World!");  وكان سيكون غير صحيح بدون تعريف الاستيراد. */ out . println ( "Hello World!" ); } }

تسمح عبارات الاستيراد عند الطلب باستيراد جميع حقول النوع التالي:

/** * يتيح هذا الشكل من التصريح الوصول إلى جميع * الحقول في فئة java.lang.System بالاسم، ويمكن استخدامه بدلاً من * تصريح الاستيراد في المثال السابق. */ import static java.lang.System.* ;

يمكن أيضًا استخدام ثوابت التعداد مع الاستيراد الثابت. على سبيل المثال، يوجد هذا التعداد في الحزمة المسماة screen:

public enum Colors { RED , BLUE , GREEN };

من الممكن استخدام تعريفات الاستيراد الثابتة في فئة أخرى لاسترداد ثوابت التعداد:

استيراد org.wikipedia.screen.ColorName ؛ استيراد ثابت org.wikipedia.screen.ColorName.* ؛public class Dots { /* السطر التالي مكافئ لـ 'ColorName foo = ColorName.RED'،  وكان سيكون غير صحيح بدون الاستيراد الثابت. */ ColorName foo = RED ;void shift () { /* السطر التالي مكافئ لـ  if (foo == ColorName.RED) foo = ColorName.BLUE; */ if ( foo == RED ) { foo = BLUE ; } } }

منذ إصدار Java 25، أصبح بالإمكان استخدام الوحدات النمطية في عبارات الاستيراد لاستيراد جميع الحزم التي تصدرها الوحدة النمطية تلقائيًا. ^{[ 5 ]} ويتم ذلك باستخدام import module. على سبيل المثال، مكافئ لـimportmodulejava.sql;

استيراد java.sql.* ؛ استيراد javax.sql.* ؛ // الصادرات غير المباشرة المتبقية من java.logging و java.transaction.xa و java.xml

وبالمثل ، يستورد جميع الحزم الـ 54 التابعة لـ .importmodulejava.base;java.base

استيراد الوحدة النمطية java.base ؛​/** * يسمح لنا استيراد الوحدة java.base بتجنب استيراد معظم الفئات يدويًا * يتم استخدام الفئات التالية (خارج java.lang): * java.text.MessageFormat * java.util.Date * java.util.List * java.util.concurrent.ThreadLocalRandom */ public class Example { public static void main ( String [] args ) { List < String > colors = List . of ( "Red" , "Orange" , "Yellow" , "Green" , "Blue" , ​​"Indigo" , "Violet" ); IO . println ( MessageFormat . format ( "My favorite colour is {0} and today is {1,date,long}" , colors . get ( ThreadLocalRandom . current (). nextInt ( colors . size ())), new Date () )); } }

تتشابه عبارات if في لغة Java مع تلك الموجودة في لغة C وتستخدم نفس الصيغة:

إذا كان ( i == 3 ) { doSomething (); }

ifقد تتضمن العبارة elseكتلة اختيارية، وفي هذه الحالة تصبح عبارة if-then-else:

إذا كان ( i == 3 ) { نفّذ شيئًا ما (); } وإلا { نفّذ شيئًا آخر (); }

على غرار لغة C، لا تتضمن بنية else-if أي كلمات مفتاحية خاصة، بل تتكون من سلسلة من عبارات if-then-else المنفصلة:

إذا كان ( i == 3 ) { نفّذ شيئًا ما (); } وإلا إذا كان ( i == 2 ) { نفّذ شيئًا آخر (); } وإلا { نفّذ شيئًا مختلفًا (); }

كما يمكن استخدام عامل التشغيل ?: بدلاً من عبارة if البسيطة، على سبيل المثال

int a = 1 ; int b = 2 ; int minVal = ( a < b ) ? a : b ;

يمكن استخدام أنواع البيانات الأولية (مثل `<enum> byte` shortو` char<string>` intو`<string>` ) أو أنواع البيانات المُغلِّفة المُقابلة لها في عبارات `switch` في جافا. بدءًا من J2SE 5.0، أصبح من الممكن استخدام أنواع `enum` . بدءًا من Java SE 7، أصبح من الممكن استخدام السلاسل النصية (String). ^{[ 7 ]} لا يمكن استخدام أنواع البيانات المرجعية الأخرى في عبارات `switch`.longswitch

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

ينتهي رمز كل تسمية بالكلمة breakالمفتاحية. من الممكن حذفها مما يؤدي إلى انتقال التنفيذ إلى التسمية التالية، ولكن عادةً ما يتم الإبلاغ عن تحذير أثناء عملية الترجمة.

switch ( ch ) { case 'A' : doSomething (); // يتم التفعيل إذا كانت قيمة ch تساوي 'A' break ; case 'B' : case 'C' : doSomethingElse (); // يتم التفعيل إذا كانت قيمة ch تساوي 'B' أو ch تساوي 'C' break ; default : doSomethingDifferent (); // يتم التفعيل في أي حالة أخرى break ; }

enum Result { GREAT , FINE , // المزيد من قيم enum }النتيجة result = switch ( ch ) { case 'A' -> النتيجة . GREAT ; case 'B' , 'C' -> النتيجة . FINE ; default -> throw new Exception (); };

النتيجة result = switch ( ch ) { case 'A' : yield Result . GREAT ; case 'B' : case 'C' : yield Result . FINE ; default : throw new Exception (); };

في whileالحلقة، يتم إجراء الاختبار قبل كل تكرار.

بينما ( i ​​< 10 ) { doSomething (); }

في حلقة doالتكرار while، يتم إجراء الاختبار بعد كل تكرار. وبالتالي، يتم تنفيذ الكود دائمًا مرة واحدة على الأقل.

// يتم استدعاء الدالة doSomething() مرة واحدة على الأقل do { doSomething (); } while ( i < 10 );

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

for ( int i = 0 ; i < 10 ; i ++ ) { doSomething (); } // حلقة أكثر تعقيدًا باستخدام متغيرين for ( int i = 0 , j = 9 ; i < 10 ; i ++ , j -= 3 ) { doSomething (); }

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

for (;;) { doSomething (); }

أصبحت حلقات التكرار foreach متاحة منذ J2SE 5.0 . يستخدم هذا النوع من الحلقات مُكرِّرات مُدمجة على المصفوفات والمجموعات لإرجاع كل عنصر في المجموعة المُعطاة. يتم إرجاع كل عنصر ويكون الوصول إليه مُتاحًا ضمن سياق كتلة التعليمات البرمجية. عند تنفيذ الكتلة، يتم إرجاع العنصر التالي حتى لا يتبقى أي عناصر. أُضيفت حلقة for هذه من Java لاحقًا إلى C++11 . على عكس C# ، لا يتضمن هذا النوع من الحلقات كلمة مفتاحية خاصة، بل يستخدم أسلوب كتابة مختلفًا.

for ( int i : intArray ) { doSomething ( i ); }

تُستخدم التسميات لتحديد نقاط في الكود، وتُستخدم بواسطة عبارات break`and` . على الرغم من أن `is` كلمة محجوزة في جافا، إلا أنه لا يمكن استخدامها للانتقال إلى نقاط محددة في الكود (في الواقع، ليس لها أي فائدة على الإطلاق).continuegoto

ابدأ : بعض الطرق ();

breakيخرج هذا الأمر من أقرب حلقة أو switchأمر. ويستمر التنفيذ في الأمر الذي يلي الأمر الذي تم إنهاؤه، إن وجد.

for ( int i = 0 ; i < 10 ; i ++ ) { while ( true ) { break ; } // سيتم الخروج من الحلقة عند هذه النقطة }

من الممكن الخروج من الحلقة الخارجية باستخدام التسميات:

outer : for ( int i = 0 ; i < 10 ; i ++ ) { while ( true ) { break outer ; } } // سيتم الخروج عند هذه النقطة

تُنهي هذه continueالعبارة التكرار الحالي لعبارة التحكم الحالية وتبدأ التكرار التالي. whileتقرأ الحلقة التالية في الكود أدناه الأحرف باستدعاء الدالة getChar()، وتتخطى العبارات في جسم الحلقة إذا كانت الأحرف مسافات.

int ch ; while ( ch == getChar ()) { if ( ch == ' ' ) { continue ; // يتخطى باقي حلقة while }// لن يتم الوصول إلى باقي حلقة while إذا كانت قيمة ch تساوي ' ' doSomething (); }

يمكن تحديد التصنيفات في continueالعبارات breakوالعبارات:

outer : for ( String str : stringsArr ) { char [] strChars = str.toCharArray (); for ( char ch : strChars ) { if ( ch == ' ' ) { /* استمر في الحلقة الخارجية واحصل على السلسلة التالية  من stringsArr */ continue outer ; } doSomething ( ch ) ; } }

تُستخدم هذه returnالعبارة لإنهاء تنفيذ الدالة وإرجاع قيمة. تُكتب القيمة المُرجعة من الدالة بعد الكلمة returnالمفتاحية. إذا أرجعت الدالة أي قيمة أخرى غير القيمة الافتراضية void، فيجب عليها استخدام هذه returnالعبارة لإرجاع قيمة ما.

void doSomething ( boolean streamClosed ) { // إذا كانت قيمة streamClosed صحيحة، يتم إيقاف التنفيذ if ( streamClosed ) { return ; } readFromStream (); }دالة حساب المجموع ( int a , int b ) { int result = a + b ; return result ; }

returnينهي البيان التنفيذ فورًا، باستثناء حالة واحدة: إذا تمت مصادفة البيان داخل tryكتلة وتم استكماله بـ finally، فسيتم تمرير التحكم إلى finallyالكتلة.

void doSomething ( boolean streamClosed ) { try { if ( streamClosed ) { return ; } readFromStream (); } finally { // سيتم استدعاء هذه الدالة أخيرًا حتى لو لم يتم استدعاء readFromStream() freeResources (); } }

تتم إدارة الاستثناءات داخل كتل try-catch

try { // عبارات قد تُطلق استثناءات methodThrowingExceptions (); } catch ( Exception e ) { // تم التقاط الاستثناء ومعالجته هنا reportException ( e ); } finally { // عبارات تُنفذ دائمًا بعد كتل try/catch freeResources (); }

تُنفَّذ التعليمات البرمجية داخل tryالكتلة، وإذا أدى أي منها إلى ظهور استثناء، يتوقف تنفيذ الكتلة وتتولى catchالكتلة معالجة الاستثناء. قد توجد عدة catchكتل، وفي هذه الحالة تُنفَّذ أول كتلة تحتوي على متغير استثناء يتطابق نوعه مع نوع الاستثناء الذي ظهر.

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

استيراد java.net.HttpRetryException ؛ استيراد java.net.http.HttpTimeoutException ؛void makeRequest () throws HttpRetryException , HttpTimeoutException { // ... }void main ( String [] args ) { try { methodThrowingExceptions (); } catch ( HttpRetryException | HttpTimeoutException e ) { // سيتم التقاط ومعالجة كل من HttpRetryException و HttpTimeoutException هنا // في الواقع، هذا يختزل إلى java.io.IOException. reportException ( e ); } }

إذا لم يتطابق أي جزء من التعليمات البرمجية مع نوع الاستثناء المُثار، يتوقف catchتنفيذ الجزء الخارجي (أو الدالة) الذي يحتوي على عبارة try"-" ، ويُمرر الاستثناء إلى أعلى خارج الجزء (أو الدالة) المُحتوي. ينتشر الاستثناء تصاعديًا عبر مكدس الاستدعاءات حتى يتم العثور على جزء مطابق داخل إحدى الدوال النشطة حاليًا. إذا انتشر الاستثناء حتى وصل إلى أعلى دالة دون العثور على جزء مطابق ، يُكتب وصف نصي للاستثناء إلى دفق الإخراج القياسي.catchcatchmaincatch

finallyتُنفَّذ التعليمات البرمجية داخل الكتلة دائمًا بعد كتلتي try`and` catch، سواءً حدث استثناء أم لا، وحتى في حال returnالوصول إلى تعليمة `and`. تُفيد هذه الكتل في توفير تعليمات برمجية للتنظيف مضمونة التنفيذ دائمًا.

الكتلتان catchو finallyاختياريتان، ولكن يجب أن تكون إحداهما على الأقل موجودة بعد tryالكتلة.

tryتُعدّ عبارات `-with-resources` نوعًا خاصًا من عبارات try` catch-` finally، وقد طُرحت كتطبيق لنمط التخلص (dispose) في Java SE 7. في tryعبارة `-with-resources` try، تتبع الكلمة المفتاحية `-` تهيئة مورد واحد أو أكثر، يتم تحريرها تلقائيًا عند tryانتهاء تنفيذ الكتلة. يجب أن تُنفّذ الموارد نمط `-` java.lang.AutoCloseable. tryلا تتطلب عبارات `-with-resources` وجود كتلة `-` catchأو `-` عادية، على عكس عبارات ` -` finallyالعادية .trycatchfinally

استيراد java.beans.XMLEncoder ؛ استيراد java.io.FileOutputStream ؛ استيراد java.io.IOException ؛ استيراد java.util.logging.Level ؛ استيراد java.util.logging.Logger ؛try ( FileOutputStream fos = new FileOutputStream ( " filename " ) ; XMLEncoder xEnc = new XMLEncoder ( fos ) ) { xEnc.writeObject ( object ) ; } catch ( IOException e ) { Logger.getLogger ( Serializer.class.getName ( ) ) . log ( Level.SEVERE , null , e ) ; }​

منذ إصدار Java 9 أصبح من الممكن استخدام المتغيرات المعلنة مسبقاً:

استيراد java.beans.XMLEncoder ؛ استيراد java.io.FileOutputStream ؛ استيراد java.io.IOException ؛ استيراد java.util.logging.Level ؛ استيراد java.util.logging.Logger ؛FileOutputStream fos = new FileOutputStream ( " filename " ) ; XMLEncoder xEnc = new XMLEncoder ( fos ) ; try ( fos ; xEnc ) { xEnc.writeObject ( object ) ; } catch ( IOException e ) { Logger.getLogger ( Serializer.class.getName ( ) ) . log ( Level.SEVERE , null , e ) ; }​

تُستخدم هذه throwالعبارة لإطلاق استثناء وإنهاء تنفيذ الكتلة أو الدالة. ويتم كتابة نسخة الاستثناء المُطلق بعد هذه throwالعبارة.

void methodThrowingExceptions ( Object obj ) { if ( obj == null ) { // يطرح استثناءً من نوع NullPointerException throw new NullPointerException (); } // لن يتم استدعاؤه إذا كان الكائن فارغًا doSomethingWithObject ( obj ); }

في لغة جافا، يتم تمثيل المصفوفات متعددة الأبعاد كمصفوفات من المصفوفات. من الناحية التقنية، يتم تمثيلها كمصفوفات من المراجع إلى مصفوفات أخرى.

int [][] numbers = new int [ 3 ][ 3 ] ; numbers [ 1 ][ 2 ] = 2 ;int [][] numbers2 = {{ 2 , 3 , 2 }, { 1 , 2 , 6 }, { 2 , 4 , 5 }};

نظراً لطبيعة المصفوفات متعددة الأبعاد، يمكن أن تختلف المصفوفات الفرعية في الطول، لذا فإن المصفوفات متعددة الأبعاد ليست بالضرورة مستطيلة الشكل على عكس لغة C:

int [][] numbers = new int [ 2 ][] ; // تهيئة البُعد الأول فقطnumbers [ 0 ] = new int [ 3 ] ; numbers [ 1 ] = new int [ 2 ] ;

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

Foo foo = new Foo ();

يتم الوصول إلى أعضاء كل من النسخ والفئات الثابتة باستخدام .عامل التشغيل (النقطة).

الوصول إلى عضو من أعضاء المثيل: يمكن الوصول إلى أعضاء المثيل من خلال اسم متغير.

String foo = "Hello" ; String bar = foo . toUpperCase ();

الوصول إلى عضو ثابت في فئة: يتم الوصول إلى الأعضاء الثابتة باستخدام اسم الفئة أو أي نوع آخر. لا يتطلب ذلك إنشاء نسخة من الفئة. يتم تعريف الأعضاء الثابتة باستخدام staticالمُعدِّل.

public class Foo { public static void doSomething () { // ... } }// استدعاء الدالة الثابتة Foo.doSomething ( );

المُعدِّلات هي كلمات مفتاحية تُستخدم لتعديل تعريفات الأنواع وأعضاء الأنواع. ومن أبرزها مجموعة فرعية تحتوي على مُعدِّلات الوصول.

• abstract- يحدد أن الفئة تعمل فقط كفئة أساسية ولا يمكن إنشاء مثيل لها.
• static- يستخدم فقط للفئات الأعضاء، ويحدد أن الفئة العضو لا تنتمي إلى مثيل محدد من الفئة الحاوية.
• final- الفئات التي تم وضع علامة عليها بأنها finalلا يمكن توسيعها ولا يمكن أن يكون لها أي فئات فرعية.
• strictfp- يحدد أن جميع عمليات الفاصلة العائمة يجب أن تتم وفقًا لمعيار IEEE 754 ويحظر استخدام الدقة المحسنة لتخزين النتائج الوسيطة.

// بشكل افتراضي، جميع الطرق في جميع الفئات ملموسة، ما لم يتم استخدام الكلمة المفتاحية abstract. abstract class Demo { // قد تتضمن الفئة المجردة طرقًا مجردة، والتي ليس لها تنفيذ. public abstract int sum ( int x , int y );// قد تتضمن الفئة المجردة أيضًا طرقًا ملموسة. public int product ( int x , int y ) { return x * y ; } }// بشكل افتراضي، جميع الدوال في جميع الواجهات مجردة، إلا إذا تم استخدام الكلمة المفتاحية default. interface DemoInterface { int getLength (); // يمكن استخدام الكلمة المفتاحية abstract هنا، على الرغم من أنها غير مجدية تمامًا // يمكن استخدام الكلمة المفتاحية default في هذا السياق لتحديد دالة ملموسة في واجهة default int product ( int x , int y ) { return x * y ; } }

final class Final { // ... }// فئة مشتقة ممنوعة تمتد من الفئة النهائية { // ... }

مُعدِّلات الوصول

تُحدد مُعدِّلات الوصول ، أو مُعدِّلات الوراثة ، إمكانية الوصول إلى الفئات والأساليب والأعضاء الآخرين. publicيمكن الوصول إلى الأعضاء المُعَلَّمة بهذه المُعدِّلات من أي مكان. إذا لم يكن للفئة أو أحد أعضائها أي مُعدِّلات، يُفترض الوصول الافتراضي.

public class Foo { int baz () { return 0 ; }فئة خاصة Bar {} }

يوضح الجدول التالي ما إذا كان الكود الموجود داخل فئة ما لديه حق الوصول إلى الفئة أو الطريقة اعتمادًا على موقع الفئة التي يتم الوصول إليها والمعدِّل الخاص بالفئة أو عضو الفئة التي تم الوصول إليها:

المعدل	نفس الفئة أو فئة متداخلة	فئة أخرى داخل نفس الحزمة	فئة موسعة داخل حزمة أخرى	غير ممتد داخل عبوة أخرى
private	نعم	لا	لا	لا
افتراضي (حزمة خاصة)	نعم	نعم	لا	لا
protected	نعم	نعم	نعم	لا
public	نعم	نعم	نعم	نعم

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

class Foo { String str ;// دالة البناء بدون وسائط Foo () {}// دالة البناء ذات الوسيط الواحد Foo ( String str ) { this . str = str ; } }

يبدو المُنشئ مُشابهًا للدالة، ولكنه في الواقع عبارة عن كتل تهيئة للكائن، ولا يُمكن استدعاؤه مُباشرةً بواسطة استدعاء دالة (على عكس لغة C++ ، حيث تُعتبر المُنشئات دوال أعضاء خاصة ). ^{[ 16 ]} مع ذلك، في بايت كود JVM ، يظهر المُنشئ تحت اسم <init>"دالة تهيئة الكائن"، ويتم تمييزه void(وبالتالي لا يُضيف أي كائن ناتج إلى مكدس معاملات JVM عند اكتمال التنفيذ). ^{[ 17 ]}

المُهيئات هي كتل من التعليمات البرمجية تُنفذ عند إنشاء فئة أو نسخة منها. يوجد نوعان من المُهيئات: المُهيئات الثابتة ومُهيئات النسخ .

تقوم المُهيئات الثابتة بتهيئة الحقول الثابتة عند إنشاء الصنف. ويتم تعريفها باستخدام staticالكلمة المفتاحية:

class Foo { static { // التهيئة } }

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

class Foo { { // التهيئة } }

بما أن جافا تعتمد على آلية جمع البيانات المهملة، فلا توجد دوال تدمير~X() أو deleteعوامل تشغيل. مع ذلك، لكل كائن دالة finalize()تُستدعى قبل جمع البيانات المهملة، ويمكن تجاوزها لتنفيذ الإنهاء. لكن لا توجد ضمانات بشأن الخيط الذي سيستدعي finalize()الدالة لأي كائن معين، أو حتى ما إذا كانت ستُستدعى أصلاً. دوال الإنهاء غير حتمية (على عكس دوال التدمير في لغة C++)، وقد finalize()يؤدي تحرير الموارد الحيوية في استدعاء إلى سلوك غير متوقع. ^{[ 18 ]} كما تم توفير فئة أخرى، java.lang.ref.Cleanerتم تقديمها في جافا 9، لتوفير شبكات أمان منخفضة المستوى لاستعادة الموارد غير المتعلقة بالذاكرة، مثل المؤشرات الأصلية، ومُعرّفات الملفات، والمآخذ. ^{[ 19 ]}

يجب أن تكون جميع التعليمات البرمجية في جافا ضمن دوال . الدوال تشبه الدوال العادية، إلا أنها تنتمي إلى فئات. تحتوي الدالة على قيمة مُعادة، واسم، وعادةً ما تحتوي على بعض المعاملات التي يتم تهيئتها عند استدعائها مع بعض الوسائط. على غرار لغة C++، فإن الدوال التي لا تُعيد أي قيمة يكون نوع إرجاعها مُعلنًا كـ `null` void. على عكس لغة C++، لا يُسمح للدوال في جافا أن تحتوي على قيم افتراضية للمعاملات ، وعادةً ما يتم تحميل الدوال بشكل زائد.

class Foo { int bar ( int a , int b ) { return ( a * 2 ) + b ; }// دالة مُحمّلة بنفس الاسم ولكن بمجموعة وسائط مختلفة int bar ( int a ) { return a * 2 ; } }

يتم استدعاء الطريقة باستخدام .الترميز على كائن، أو في حالة الطريقة الثابتة، يتم استدعاؤها أيضًا على اسم فئة.

Foo foo = new Foo ( ); int result = foo.bar ( 7 , 2 ); // يتم استدعاء دالة غير ثابتة على fooint finalResult = Math.abs ( result ) ; // استدعاء دالة ثابتة

تشير الكلمة throwsالمفتاحية إلى أن الدالة تُطلق استثناءً. يجب إدراج جميع الاستثناءات التي تم التحقق منها في قائمة مفصولة بفواصل.

استيراد java.io.File ؛ استيراد java.io.IOException ؛ استيراد java.util.zip.DataFormatException ؛// يشير إلى إمكانية حدوث استثناءات IOException و DataFormatException void operatOnFile ( File f ) throws IOException , DataFormatException { // ... }

public class Base { public void foo () { // ... }public final void bar () { // ... }public static void baz () { // ... }public static final void qux () { // ... } }public class Derived extends Base { // حسنًا، تجاوز Base::foo() @Override public void foo () { // ... }// ممنوع @Override public void bar () { // ... }// حسنًا، تم تجاوز Base::baz() @Override public static void baz () { // ... }// ممنوع @Override public static void qux () { // ... } }

// الأرقام تمثل الوسائط المتغيرة void printReport ( String header , int ... numbers ) { // تظهر الأرقام كـ int[] System . out . println ( header ); for ( int num : numbers ) { System . out . println ( num ); } }// استدعاء دالة printReport ذات الوسائط المتغيرة ( "بيانات التقرير" , 74 , 83 , 25 , 96 );

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

class Foo { double bar ; }

يمكن تهيئة الحقول مباشرةً عند تعريفها.

class Foo { double bar = 2.3 ; }

في لغة جافا، لا يمكن للفئات أن ترث إلا من فئة واحدة . يمكن اشتقاق فئة من أي فئة غير مُعَلَّمة بـ ` final. يُعلن عن الوراثة باستخدام extendsالكلمة المفتاحية `. يمكن للفئة أن تشير إلى نفسها باستخدام الكلمة thisالمفتاحية `، وإلى فئتها الأصلية المباشرة باستخدام الكلمة superالمفتاحية `.

class Foo {}class Foobar extends Foo {}

إذا لم يحدد الصنف صنفه الأصلي، فإنه يرث ضمنيًا من java.lang.Objectالصنف الأصلي. وبالتالي، فإن جميع الأصناف في جافا هي أصناف فرعية من Objectالصنف الأصلي.

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

class Foo { public Foo ( int n ) { // قم بشيء ما باستخدام n } }class Foobar extends Foo { private int number ; // لا تحتوي الفئة الأصلية على مُنشئ بدون مُعاملات // لذلك علينا تحديد مُنشئ الفئة الأصلية الذي سنستخدمه وكيفية استخدامهpublic Foobar ( int number ) { super ( number ); this . number = number ; } }

class Operation { public int doSomething () { return 0 ; } }class NewOperation extends Operation { @Override public int doSomething () { return 1 ; } }

package org.wikipedia.examples ;public class MyAbstractClass { private static final String hello ;static { System.out.printf ( " % s : static block runtime%n" , MyAbstractClass.class.getName ( ) ) ; hello = String.format ( " hello from % s " , MyAbstractClass.class.getName ( ) ) ; }{ System.out.printf ( " % s : instance block runtime% n " , MyAbstractClass.class.getName ( ) ) ; }public AbstractClass ( ) { System.out.printf ( " % s : constructor runtime%n " , MyAbstractClass.class.getName ( ) ) ; }public static void hello () { System . out . println ( hello ); } }

package org.wikipedia.examples ;public class MyCustomClass extends MyAbstractClass {static { System.out.printf ( " % s : static block runtime% n " , MyCustomClass.class.getName ( ) ) ; }{ System.out.printf ( " % s : instance block runtime%n " , MyCustomClass.class.getName ( ) ) ; }public CustomClass () { System . out . printf ( "%s: constructor runtime%n" , MyCustomClass . class . getName ()); }public static void main ( String [] args ) { MyCustomClass nc = new MyCustomClass (); hello (); MyAbstractClass . hello (); // صالحة أيضًا } }

org.wikipedia.examples.MyAbstractClass: وقت تشغيل الكتلة الثابتة org.wikipedia.examples.MyCustomClass: وقت تشغيل الكتلة الثابتة org.wikipedia.examples.MyAbstractClass: كتلة مثيل وقت التشغيل org.wikipedia.examples.MyAbstractClass: وقت تشغيل المُنشئ org.wikipedia.examples.MyCustomClass: كتلة مثيل وقت التشغيل org.wikipedia.examples.MyCustomClass: وقت تشغيل المُنشئ مرحباً من org.wikipedia.examples.MyAbstractClass 

أُضيفت هذه الميزة اللغوية في J2SE 5.0 . من الناحية التقنية، تُعدّ التعدادات نوعًا من الأصناف التي تحتوي على ثوابت تعدادية ضمن بنيتها. يُعرّف كل ثابت تعدادي نسخةً من نوع التعداد. لا يمكن إنشاء نسخ من أصناف التعداد في أي مكان آخر سوى داخل صنف التعداد نفسه.

enum Season { WINTER , SPRING , SUMMER , AUTUMN , }

يُسمح لثوابت التعداد بامتلاك دوال إنشاء، والتي يتم استدعاؤها عند تحميل الفئة:

public enum Season { WINTER ( "بارد" ), SPRING ( "أكثر دفئًا" ), SUMMER ( "حار" ), AUTUMN ( "أكثر برودة" );الموسم ( وصف السلسلة ) { هذا.الوصف = الوصف ؛ }​​وصف السلسلة النصية النهائية الخاصة ؛public String getDescription () { return description ; } }

يمكن أن تحتوي التعدادات على أجسام فئات، وفي هذه الحالة يتم التعامل معها كفئات مجهولة تمتد من فئة التعداد:

public enum Season { WINTER { @Override String getDescription () { return "cold" } }, SPRING { @Override String getDescription () { return "warmer" ; } }, SUMMER { @Override String getDescription () { return "hot" ; } }, FALL { @Override String getDescription () { return "cooler" ; } };abstract String getDescription (); }

تُنفَّذ الواجهة بواسطة فئة باستخدام implementsالكلمة المفتاحية `interface`. يُسمح بتنفيذ أكثر من واجهة، وفي هذه الحالة تُكتب الواجهات بعد implementsالكلمة المفتاحية `interface` في قائمة مفصولة بفواصل. يجب على الفئة التي تُنفِّذ واجهةً ما إعادة تعريف جميع توابعها، وإلا فيجب تعريفها كفئة مجردة.

واجهة RequestListener { int requestReceived (); }class ActionHandler implements ActionListener , RequestListener { public void actionSelected ( int action ) { // ... }public int requestReceived () { // ... } }// استدعاء الدالة المُعرَّفة بواسطة الواجهة // يمكن تمثيل ActionHandler كـ RequestListener... RequestListener listener = new ActionHandler (); // ...وبالتالي من المعروف أنه يُنفِّذ الدالة requestReceived() listener.requestReceived ( ) ;

أُضيفت هذه الميزات مع إصدار Java SE 8. تُصبح الواجهة تلقائيًا واجهةً وظيفيةً إذا كانت تُعرّف طريقةً واحدةً فقط (باستثناء الطرق الموروثة java.lang.Object). في هذه الحالة، يُمكن تمثيل التنفيذ بتعبير لامدا بدلًا من تنفيذه في فئة جديدة، مما يُبسّط كتابة التعليمات البرمجية بأسلوب البرمجة الوظيفية . يُمكن إضافة تعليق java.lang.FunctionalInterfaceتوضيحي اختياري إلى الواجهات الوظيفية، يُخبر المُصرّف بالتحقق مما إذا كانت الواجهة تُطابق تعريف الواجهة الوظيفية.

// واجهة وظيفية @FunctionalInterface interface Calculation { int calculate ( int someNumber , int someOtherNumber ); }// دالة تقبل هذه الواجهة كمعامل int runCalculation ( Calculation calculation ) { return calculation . calculate ( 1 , 2 ); }// استخدام تعبير لامدا لاستدعاء الدالة runCalculation (( number , otherNumber ) -> number + otherNumber );// الكود المكافئ الذي يستخدم فئة مجهولة بدلاً من ذلك runCalculation ( new Calculation () { @Override public int calculate ( int someNumber , int someOtherNumber ) { return someNumber + someOtherNumber ; } })

لا يلزم تحديد أنواع معاملات دالة لامدا بشكل كامل، ويمكن استنتاجها من الواجهة التي تُنفذها، ولكن لا يوجد مكان لتحديد نوع القيمة المُعادة من دالة لامدا بشكل صريح (إذ يُستنتج هذا النوع تلقائيًا). يمكن كتابة جسم دالة لامدا بدون كتلة الجسم أو عبارة returnإذا كانت مجرد تعبير. كذلك، بالنسبة للواجهات التي تحتوي على معامل واحد فقط في الدالة، يمكن حذف الأقواس الدائرية. ^{[ 24 ]}

// نفس الاستدعاء كما في الأعلى، ولكن مع تحديد الأنواع بالكامل وكتلة نصية runCalculation (( int number , int otherNumber ) -> { return number + otherNumber ; });// واجهة وظيفية ذات دالة تأخذ مُعاملًا واحدًا فقط interface StringExtender { String extendString ( String input ); }// تهيئة متغير من هذا النوع باستخدام تعبير لامدا StringExtender extender = input -> input + " Extended" ;