واصف
الواصفات هي كلمات رئيسية تضيفها إلى تلك التعريفات لتغيير معانيها. تحتوي لغة جافا على العديد من الواصفات ، بما في ذلك ما يلي:
classname classname من الفئة العامة {// ...} myflag myflag الخاص الثابت ؛ واصفات يمكن الوصول إليها
يوفر Java سلسلة من الواصفات التي يمكن الوصول إليها لتعيين مستويات الوصول من الفئات والمتغيرات والأساليب والمشاركات. مستويات الوصول الأربعة هي كما يلي:
بشكل افتراضي ، مرئي للتغليف. لا يلزم وجود واصف.
واصف لا يمكن الوصول إليه
توفر Java بعض الواصفات التي لا يمكن الوصول إليها لتلبية وظائف أخرى.
المشغلين الأساسيين
توفر Java مجموعة غنية من المشغلين لمعالجة المتغيرات. يمكننا تقسيم جميع مشغلي Java إلى المجموعات التالية:
استخدام عوامل الحساب في التعبيرات الرياضية هو نفسه استخدامها في الجبر. يسرد الجدول التالي مشغلي الحساب:
على افتراض أن هناك 10 متغير إجمالي A و 20 متغير B ، ثم:
مثال
| المشغلين | يصف | مثال |
|---|---|---|
| + | تمت إضافة الإضافة في الطرف الآخر من المشغل | A+B هو 30 |
| - | الطرح يطرح المعامل على اليمين من المعامل على اليسار | أ - ب هو -10 |
| * | يضاعف الضرب القيم في كلا طرفي المشغل | A * B هو 200 |
| / | قسّم المعامل الأيسر على المعامل الأيمن | ب/أ هو 2 |
| ٪ | معامل - قسّم المعامل الأيسر مع المعامل الأيمن وأرجع الباقي | B ٪ A هو 0 |
| ++ | الزيادة تزيد من قيمة المعامل بمقدار 1 | B ++ هو 21 |
| - | انخفاض يطرح 1 لقيمة المعامل | ب 19 |
مثال
| المشغلين | يصف | مثال |
|---|---|---|
| == | تحقق مما إذا كانت قيم معاملات كلا الجانبين متساوية. إذا كانت متساوية ، فإن الحالة صحيحة. | (أ == ب) غير صحيح. |
| ! = | تحقق مما إذا كانت قيم معاملات كلا الجانبين متساوية. إن لم يكن متساويًا ، فإن الحالة صحيحة. | (أ! = ب) صحيح. |
| > | تحقق مما إذا كان المعامل على اليسار أكبر من المعامل على اليمين. إذا كان أكبر ، فإن الحالة صحيحة | (أ> ب) غير صحيح. |
| < | تحقق مما إذا كان المعامل على اليسار أصغر من المعامل على اليمين. إذا كان أصغر ، فإن الحالة صحيحة | (A <B) صحيح. |
| > = | تأكد من أن المعامل على اليسار أكبر من أو يساوي المعامل على اليمين. إذا كان الأمر كذلك ، فإن الحالة صحيحة | (أ> = ب) غير صحيح. |
| <= | تحقق مما إذا كان المعامل على اليسار أقل من أو يساوي المعامل على اليمين. إذا كان الأمر كذلك ، فإن الحالة صحيحة | (A <= B) صحيح. |
يعمل مشغل BIT على معايير الإرسال بين الأنظمة الثنائية ويقوم بعمليات bitwise. لنفترض إذا كان A يساوي 60 ؛ ب يساوي 13 ؛ الآن في شكل ثنائي هم على النحو التالي:
A = 0011 1100B = 0000 1101 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
يسرد الجدول التالي مشغلي بت:
افترض أن هناك 60 متغيرًا صحيحًا A و 13 B ، ثم:
مثال
| المشغلين | يصف | مثال |
|---|---|---|
| & & | نسخة ثنائية ومشغل نسخة واحدة على النتيجة في حالة وجود كلا المعاملين في نفس الوقت | (A & B) هو 12 ، أي 0000 1100 |
| | | النسخ الثنائية أو المشغل ينسخ قليلاً على النتيجة إذا كانت موجودة في أي معامل | (أ | ب) هو 61 ، أي 0011 1101 |
| ^ | يقوم مشغل XOR الثنائي بنسخ البت إذا تم تعيينه على معامل واحد بدلاً من اثنين. | (A ^ B) هو 49 ، أي 0011 0001 |
| ~ | مشغل المكملات الثنائية غير محلي ، و B له تأثير البتات "Flip" | (~ أ) هو -61. نظرًا لأنه رقم ثنائي موقّع ، فإن النموذج المكملة لـ 2 هو 1100 0011 |
| << | مشغل التحول الثنائي اليسار. تنتقل قيمة المعامل على اليسار إلى اليسار وفقًا لعدد البتات المحددة بواسطة المعامل على اليمين. | A << 2 هو 240 ، أي 1111 0000 |
| >> | عامل التحول الأيمن الثنائي. تتحرك قيمة المعامل على اليسار إلى اليمين وفقًا لعدد البتات المحددة بواسطة المعامل على اليمين. | A >> 2 هو 15 أي 1111 |
| >>> | تحرك يمينًا لملء مشغل الصفر. يتم نقل قيمة المعامل الأيسر إلى اليمين وفقًا لعدد البتات المحددة بواسطة المعامل الأيمن ، وتمتلئ القيمة المنقولة بصفر. | A >>> 2 هو 15 ، أي 0000 1111 |
على افتراض أن متغير النظام الرياضي المنطقي A صحيح و B خطأ ، ثم:
مثال
| المشغلين | يصف | مثال |
|---|---|---|
| && | ويسمى المنطق والمشغل. إذا لم يكن كل من المعاملات صفرًا ، فإن الحالة صحيحة. | (A && B) صحيح. |
| || | يسمى المنطق أو المشغل. إذا لم يكن أي من المعاملات صفرًا ، فإن الحالة صحيحة. | (A || B) صحيح. |
| ! | يسمى غير مرغوب فيه منطقي. يتم استخدامه كحالة منطقية من المعاملات الوجه. إذا كان الشرط صحيحًا ، فإن غير المرغوب غير صحيح. | ! (A && B) صحيح. |
مثال
| المشغلين | يصف | مثال |
|---|---|---|
| = | بسيط ومشغل ، قم بتعيين قيمة المعامل على اليمين إلى المعامل على اليسار | C = A + B سيقوم بتعيين قيمة A + B إلى C |
| += | إضافة وتعيين المشغل ، الذي يزيد من المعامل على اليمين إلى المعامل على اليسار ويعين النتيجة إلى المعامل على اليسار | C + = A يساوي C = C + أ |
| -= | مشغل الطرح والتعيين ، الذي يطرح المعامل الأيمن من المعامل الأيسر ويعين النتيجة إلى المعامل الأيسر | C - = A يساوي C = C - أ |
| *= | اضرب ومشغل المهام ، الذي يضاعف المعامل الأيمن مع اليسار ويعين النتيجة إلى المعامل الأيسر | C = A يساوي C = C أ |
| /= | قسمة وملء المهام ، الذي يقسم المعامل الأيمن على اليسار ويعين النتيجة إلى المعامل الأيسر | C / = A يساوي C = C / A |
| ٪ = | يتطلب معامل المعامل والمواجهة من المعامل استخدام اثنين من المعاملات وتعيين النتيجة إلى المعامل على اليسار. | C ٪ = A يساوي C = C ٪ أ |
| << = | عوامل التحول اليسرى والمواجهة | C << = 2 يساوي C = C << 2 |
| >> = | مشغلي التحول الصحيح والمخصصات | C >> = 2 يساوي C = C >> 2 |
| & = | bitwise ومشغلي المهام | C & = 2 يساوي C = C & 2 |
| ^= | Bitwise Xor ومشغلي المهام | C ^ = 2 يساوي C = C ^ 2 |
| | = | bitwise أو تعيين المشغلين | C | = 2 يساوي C = C | 2 |
المشغل الشرطي (؟ :)
وتسمى المشغلات الشرطية أيضا المشغلين الثلاثية. يتكون هذا المشغل من ثلاثة معاملات ويستخدم لتقييم التعبيرات الرياضية المنطقية. الغرض من هذا المشغل هو تحديد القيم التي يجب تعيينها للمتغير. هذا المشغل مكتوب على النحو التالي:
متغير x = (التعبير)؟ القيمة إذا كان صحيحًا: القيمة إذا كانت خاطئة
هنا مثال:
اختبار الفئة العامة {public static void main (String args []) {int a ، b ؛ أ = 10 ؛ ب = (أ == 1)؟ 20: 30 ؛ System.out.println ("قيمة B IS:" + B) ؛ ب = (أ == 10)؟ 20: 30 ؛ System.out.println ("قيمة B IS:" + B) ؛ }}سيؤدي هذا إلى ما يلي:
قيمة B هي: 30 Value of B هي: 20
رمز مثيل
يستخدم هذا المشغل فقط للمتغيرات المرجعية للكائن. يتحقق هذا المشغل ما إذا كان الكائن نوعًا فريدًا (نوع أو نوع واجهة). يتم كتابة مشغل مثيل: على النحو التالي:
(متغير مرجع الكائن) مثيل (نوع الفئة/الواجهة)
إذا كان الكائن الموجود على يسار المشغل المشار إليه بواسطة المتغير هو نوع أو نوع الواجهة إلى اليمين عن طريق تمرير IS-A ، والنتيجة صحيحة. هنا مثال:
اختبار الفئة العامة {public static void main (String args []) {String name = "James" ؛ // سيعود التالي إلى TRUE لأن الاسم هو نوع السلسلة Boolean Result = name estructionof string ؛ System.out.println (نتيجة) ؛ }}هذا سوف ينتج عنه النتائج التالية:
انسخ الرمز على النحو التالي: صحيح
سيظل هذا المشغل يعود إلى True إذا كان الكائن الذي يتم مقارنته هو مهمة متوافقة مع النوع الصحيح. هنا مثال آخر: Class Class {} Class Car Expression {public static void main (string args []) {motion a = new car () ؛ نتيجة منطقية = مثيل السيارة ؛ System.out.println (نتيجة) ؛ }}هذا سوف ينتج عنه النتائج التالية:
حقيقي
أولوية مشغل Java
أولوية المشغل تحدد تجميع المصطلحات في التعبير. إنه يؤثر على كيفية تقييم التعبير. المشغل معين له أولوية أعلى من المشغلين الآخرين ؛ على سبيل المثال: يكون لمشغل الضرب أولوية أعلى من مشغل الإضافة:
على سبيل المثال ، x = 7+3 2 ؛ هنا يتم تعيين X إلى 13 ، وليس 20 ، لأن المشغل أولوية أعلى من المشغل +، لذلك يعمل أولاً على الضرب 3*2 ، ثم يضيف 7.
هنا ، يكون المشغلون ذوي الأولوية الأعلى على أعلى مستوى في هذا الجدول ، ويظهر أولئك الذين لديهم أدنى أولوية في الأسفل. في التعبير ، كلما تم تقييم مشغل الأولوية الأعلى أولاً.
| عطوف | المشغلين | الأهمية |
|---|---|---|
| لاحقة | () []. (DOT Operator) | من اليسار إلى اليمين |
| دولار واحد | ++ - -! ~ | من اليمين إلى اليسار |
| الضرب | */ ٪ | من اليسار إلى اليمين |
| المضافة | + - | من اليسار إلى اليمين |
| يحول | >> >>> << | من اليسار إلى اليمين |
| علاقة | >> = <<= | من اليسار إلى اليمين |
| متساوي | ==! = | من اليسار إلى اليمين |
| بت و | & & | من اليسار إلى اليمين |
| موقف غير عادي أو | ^ | من اليسار إلى اليمين |
| بت أو | | | من اليسار إلى اليمين |
| المنطق و | && | من اليسار إلى اليمين |
| منطقي أو | || | من اليسار إلى اليمين |
| شرطي | ؟: | من اليمين إلى اليسار |
| تكليف | = += -= *= /= ٪ = >> = << = & = ^== | من اليمين إلى اليسار |
| فاصلة | و | من اليسار إلى اليمين |