القائمة الرئيسية

الصفحات

جافا

المتغيرات والعوامل في جافا

إنشاء أول برنامج في جافا

سنقوم الآن بإنشاء برنامج بسيط مهمته فقط طباعة الجملة Welcome to java world.

في المثال التالي قمنا بتسمية البرنامج Main و إستخدمنا الأمر System.out.println() لطباعة الجملة التي نريد عرضها.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // هنا قمنا بعرض الجملة
	  System.out.println("Welcome to java world");

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  Welcome to java world


مبادئ العرض الأساسية

عليك مراعاة المبادئ التالية عند استخدام دوال الطباعة.

  • لعرض رقم, ضعه كما هو في دالة الطباعة.

  • لعرض قيمة متغير, ضعه كما هو في دالة الطباعة.

  • لعرض حرف أو كلمة أو نص, يجب وضعه بين " ".



معلومة تقنية

ملف الجافا الذي يحتوي على الكلاس Main يجب أن يكون من نفس الإسم و يكون إمتداده .java.
أي يجب أن يكون إسمه Main.java.

مفهوم الـ Concatenation

Concatenation تعني سلسلة باللغة العربية. برمجياً تعني دمج عدة أشياء مع بعضها سواء كانت نصوص أو أرقام و جعلها تبدو شيئاً واحداً.

هنا قمنا بإنشاء برنامج يحتوي على أمر طباعة واحد, في هذا الأمر قمنا بدمج ثلاث كلمات و رقم, و عرضناهم مع بعضها كجملة واحدة.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // هنا قمنا بدمج ثلاث كلمات و رقم, و عرضناهم مع بعضهم كجملة واحدة
	  System.out.println("Welcome " + "to " + "java " + 101);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  Welcome to java 101

دوال العرض

في جافا يوجد ثلاث دوال يمكنك استخدامهم للطباعة, ذكرناهم في الجدول التالي.

الدالة مع تعريفها
1 System.out.print() دالة تستخدم لعرض أي شيء نضعه في داخلها سواء نص, رقم أو قيمة متغير.
2 System.out.println() تستخدم أيضاً لعرض أي شيء نضعه في داخلها سواء نص, رقم أو قيمة متغير.
الفرق بينها و بين الدالة السابقة أنها تعرض أي شيء نطبعه بعدها على سطر جديد.
3 System.out.printf() تستخدم أيضاً لعرض أي شيء نضعه في داخلها سواء نص, رقم أو قيمة متغير.
فكرة هذه الدالة تختلف عن الدالتين السابقتين, و استخدامها مختلف أيضاً. تم تصميمها لتحقيق مبدأ الـ Concatenation بطريقة مختلفة فقط.
هنا كل شيء تريد عرضه عليك حجز مكان له.
عند عرض عدد صحيح, أي نوعه int, إستخدم الرمز %d لتحجز مكان له في دالة العرض.
عند عرض عدد بفاصلة عشرية, أي نوعه float, إستخدم الرمز %f لتحجز مكان له في دالة العرض.
عند عرض نص عادي String, إستخدم الرمز %s لتحجز مكان له في دالة العرض.

ملاحظة: لا تقلق أبداً في حال لم تفهم الدالة System.out.printf() لأننا أصلاً لم نشرح في هذا الدرس أنواع البيانات int, float و String التي ذكرناها في الجدول, لكننا حاولنا شرحها بتفصيل في الأمثلة.

أمثلة شاملة حول دوال العرض

في المثال التالي قمنا بعرض ثلاث أشياء باستخدام الدالة print().

المثال الأول

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // هنا قمنا بعرض نص
	  System.out.print("Welcome to java world");

	  // هنا قمنا بعرض رقم
	  System.out.print(1000);

	  // بعدها قمنا بعرض قيمته x هنا قمنا بتعريف متغير إسمه
	  int x = 123;
	  System.out.print(x);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  Welcome to java world1000123

إذاً الدالة print() تعرض أي شيء نضعه فيها.


هنا قمنا بكتابة نفس البرنامج السابق, لكننا استخدمنا الدالة println() بدلاً من الدالة print().

المثال الثاني

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // هنا قمنا بعرض نص
	  System.out.println("Welcome to java world");

	  // هنا قمنا بعرض رقم
	  System.out.println(1000);

	  // بعدها قمنا بعرض قيمته x هنا قمنا بتعريف متغير إسمه
	  int x = 123;
	  System.out.println(x);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  Welcome to java world
	  1000
	  123

إذاً الدالة println() تعرض أي شيء نضعه فيها, بالإضافة إلى ذلك تجعل أي شيء نعرضه بعدها ينزل على سطر جديد.


في المثال التالي قمنا بدمج النص الموجود في الدالة printf() مع رقم.
إنتبه: يجب وضع فاصلة قبل كل متغير أو قيمة سيتم إستبدالها.

المثال الثالث

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // 10 قيمته x هنا قمنا بتعريف متغير إسمه
	  int x = 10;

	  // بعدها سيتم عرض كامل محتوى دالة الطباعة %d مكان الـ x هنا سيتم وضع قيمة المتغير
	  System.out.printf("The value of x is: %d", x);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  The value of x is: 10

في المثال التالي قمنا بدمج النص الموجود في الدالة printf() مع رقمين, الأول نوعه int و الثاني نوعه float.
تذكر: يجب وضع فاصلة قبل كل متغير أو قيمة سيتم إستبدالها.

المثال الثالث

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // 10 قيمته x هنا قمنا بتعريف متغير إسمه
	  int x = 10;

	  // 10.55 قيمته y هنا قمنا بتعريف متغير إسمه
	  float y = 10.55f;

	  // بعدها سيتم عرض كامل محتوى دالة الطباعة %f مكان الـ y و قيمة المتغير %d مكان الـ x هنا سيتم وضع قيمة المتغير
	  System.out.printf("x = %d   and   y = %f", x, y);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  x = 10   and   y = 10.550000

مفهوم المتغيرات 

متغير: تعني variable في اللغة الإنجليزية, الآن نريدك أن تفهم المتغيرات على أنها فقط أماكن يتم حجزها في الذاكرة لتخزين بيانات أثناء تشغيل البرنامج.
النوع الذي نعطيه للمتغير يجعل نظام التشغيل يحدد نوع البيانات الذي يمكن تخزينه في المساحة المحجوزة لهذا المتغير في الذاكرة.


البيانات في جافا نوعين:

  • Primitive Data Types و تعني أنواع البيانات البدائية.

  • Reference/Object Data Types و تعني أنواع البيانات المرجعية.

أنواع البيانات البدائية

هناك ثمانية أنواع بدائية في جافا و هي:
byte - short - int - long - float - double - boolean - char.


النوع byte

  • هذا النوع يمثل عدد صحيح يتألف من 8 bit.

  • أقل قيمة يمكن تخزينها فيه هي -2^7 و هذا يساوي -128.

  • أكثر قيمة يمكن تخزينها فيه هي 2^7 - 1 و هذا يساوي +127.

  • إذا لم نضع أي قيمة, توضع القيمة 0 كقيمة إفتراضية.

  • النوع byte يستخدم لتخزين عدد صغير الحجم لا يحتوي على فاصلة عشرية, أي لتخزين عدد صحيح.


مثال

byte a = 123;
	  byte b = -70;


النوع short

  • هذا النوع يمثل عدد صحيح يتألف من 16 bit.

  • أقل قيمة يمكن تخزينها فيه هي -2^15 و هذا يساوي -32,768.

  • أكثر قيمة يمكن تخزينها فيه هي2^15 - 1 و هذا يساوي +32,767.

  • إذا لم نضع أي قيمة, توضع القيمة 0 كقيمة إفتراضية.

  • النوع short يستخدم لتخزين عدد متوسط الحجم لا يحتوي على فاصلة عشرية, أي لتخزين عدد صحيح.


مثال

short a = 12345;
	  short b = -7000;


النوع int

  • هذا النوع يمثل عدد صحيح يتألف من 32 bit.

  • أقل قيمة يمكن تخزينها فيه هي -2^31 و هذا يساوي -2,147,483,647.

  • أكثر قيمة يمكن تخزينها فيه هي 2^31 - 1 و هذا يساوي +2,147,483,646.

  • إذا لم نضع أي قيمة, توضع القيمة 0 كقيمة إفتراضية.

  • النوع int يستخدم لتخزين عدد كبير لا يحتوي على فاصلة عشرية, أي لتخزين عدد صحيح.


مثال

int a = 1234567;
	  int b = -700000;


النوع long

  • هذا النوع يمثل عدد صحيح يتألف من 64 bit.

  • أقل قيمة يمكن تخزينها فيه هي -2^63 و هذا يعني -9,223,372,036,854,775,808.

  • أكثر قيمة يمكن تخزينها فيه هي 2^63 - 1 و هذا يعني +9,223,372,036,854,775,807.

  • إذا لم نضع أي قيمة, توضع القيمة 0L كقيمة إفتراضية.

  • النوع long يستخدم لتخزين عدد كبير جداً لا يحتوي على فاصلة عشرية, أي لتخزين عدد صحيح حجمه كبير جداً.


مثال

long a = 1234567L;
	  long b = -700000L;


النوع float

  • هذا النوع يمثل عدد بفاصلة عشرية يتألف من 32 bit.

  • أقل و أكبر قيمة يمكن تخزينها فيه تحدد بنظام ( single-precision 32-bit IEEE 754 floating point )

  • إذا لم نضع أي قيمة, توضع القيمة 0.0f كقيمة إفتراضية.

  • النوع float يستخدم لتخزين عدد كبير بفاصلة عشرية.


مثال

float a = 12.05f;
	  float b = -8.123f;


النوع double

  • هذا النوع يمثل عدد بفاصلة عشرية يتألف من 64 bit.

  • أقل و أكبر قيمة يمكن تخزينها فيه تحدد بنظام ( double-precision 64-bit IEEE 754 floating point )

  • إذا لم نضع أي قيمة, توضع القيمة 0.0d كقيمة إفتراضية.

  • النوع double يستخدم لتخزين عدد كبير جداً بفاصلة عشرية.


مثال

double a = 50.98794d;
	  double b = -100.1d;


النوع boolean

  • هذا النوع يمثل معلومة تتألف من 1 bit.

  • يستطيع أن يحتوي إما على القيمة true أو على القيمة false.

  • إذا لم نضع أي قيمة, توضع القيمة false كقيمة إفتراضية.

  • النوع boolean يستخدم في الشروط.


مثال

boolean check = true;
	  boolean found = false;


النوع char

  • هذا النوع يمثل معلومة تتألف من 16 bit.

  • أقل قيمة يمكن تخزينها فيه هي 0.

  • أكثر قيمة يمكن تخزينها فيه هي 65,535.

  • و يستطيع أن يحتوي على أي حرف أو رمز كقيمة.

  • إذا لم نضع أي قيمة, يوضع اليونيكود '\u0000' كقيمة إفتراضية. و هذا اليونيكود يمثل أصغر قيمة يمكن وضعها في النوع char.

  • النوع char يستخدم لتخزين حرف واحد, و يستخدم في الشروط.


مثال

char a = 0;
	  char b = 1234;
	  char letterA = 'A';

أنواع البيانات المرجعية

  • أي نوع أصله كائن من كلاس يعتبر من البيانات المرجعية.

  • أي نوع نضع الكلمة new عندما نقوم بتعريفه, يعتبر من البيانات المرجعية.

  • جميع أنواع المصفوفات في جافا تعتبر من البيانات المرجعية.

  • إذا لم نضع أي قيمة, توضع القيمة null كقيمة إفتراضية, و التي تعني فارغ.


أمثلة

String website   = "www.harmash.com";
	  String[] names   = new String[10];
	  int[] numbers    = new int[100];
	  float[] notes    = new float[5];
	  char[] alphabets = new char[26];
	  Scanner input    = new Scanner(System.in);

في الدرس التالي ستتعلم جميع الأساليب التي تستطيع اتباعها لتعريف المتغيرات.

المتغيرات في جافا | Java variables

أساليب تعريف المتغيرات في جافا

في البداية أنواع المتغيرات هي نفسها أنواع البيانات البدائية التي ذكرناها في الدرس السابق و هي:
byte - short - int - long - float - double - boolean - char

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


تعريف عدة متغيرات من نفس النوع بدون قيم

•في حال كنت تريد تعريف عدة متغيرات من نفس النوع بدون قيم.

int a;
	  int b;
	  int c;

•تستطيع تعريفهم هكذا.

int a, b, c;


 تعريف عدة متغيرات من نفس النوع و إعطائهم قيم مباشرةً عند إنشائهم.

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

int a = 10;
	  int b = 20;
	  int c = 30;

•تستطيع تعريفهم هكذا.

int a=10, b=20, c=30;


طريقة تعريف عدة متغيرات من نفس النوع

•في حال كنت تريد تعريف عدة متغيرات من نفس النوع و لكن طبيعتهم مختلفة و بدون قيم.

int a;
	  int b[];
	  int c[][];

•تستطيع تعريفهم هكذا.

int a, b[], c[][];


طريقة تعريف المصفوفة بعدة طرق

•تستطيع تعريف المصفوفة بعدة طرق كالتالي.

•الطريقة الأولى

int[] a;

•الطريقة الثانية

int []a;

•الطريقة الثالثة

int a[];

•الشيء الذي علينا الإنتباه له هو أنك إذا كنت تريد تعريف مصفوفة و متغير من نفس النوع, لا تستخدم الطريقة الأولى.
•السبب أنك إذا كتبت int[] سيتم إعتبار كل إسم تضعه بعد الفاصلة يمثل مصفوفة و ليس متغير عادي.

int[] a, b, c;

•إذاً هنا a و b و c جميعهم يمثلون مصفوفات ذات بعد واحد.


ملاحظة
• نفس المبدأ ينطبق على المصفوفات الأكثر من بعد واحد.

ملاحظات  عن المتغيرات في جافا

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

  • عملية تعريف متغير بدون إعطائه قيمة تسمى Declaration.

  • عملية إعطاء قيمة لمتغير تم إنشاؤه سابقاً تسمى Assigning.

  • عملية تعريف متغير و إعطائه قيمة مباشرةً عند إنشائه تسمى Initialisation.


أمثلة

•هنا سنفعل Declare لمتغير جديد, أي سنقوم بتعريف متغير جديد بدون إعطائه قيمة أولية.

int a;

•هنا سنفعل Assign لمتغير, أي سنقوم بإعطاء قيمة لمتغير كان في الأصل موجوداً.

a = 10;

•هنا سنفعل Initialise لمتغير جديد, أي سنقوم بإنشاء متغير جديد و إعطائه قيمة أولية.

double Sum = 0;

إرشادات مهمة لمعالجة الأخطاء في جافا

بعد أن فهمت المصطلحات الأساسية الخاصة بالمتغيرات, سنقوم الآن بإعطائك بعض الأمثلة التي تحتوي على أخطاء مقصودة لتعليمك كيف تعرف طبيعة الخطأ و بالتالي كيف تصلح الخطأ بنفسك.

المثال الأول

•هنا سنفعل Declare لمتغير جديد, ثم سنقوم بعرض قيمته و هو فارغ.

int a;

	  System.out.println(a);

•لاحظ الصورة التالية لتفهم كيف يقوم برنامج Netbeans بإبلاغك بالخطأ قبل أن تقوم بتشغيل البرنامج.


•إذاً المشكلة الوحيدة هنا أننا حاولنا عرض محتوى متغير فارغ.

•و البرنامج بكل بساطة أخبرنا أن المشكلة هنا سببها المتغير a لأننا لم نفعل له initialise, و وضع تحته خط أحمر للتنبيه, لأنه إذا بقي هذا الخط ظاهراً و قمنا بتشغيل البرنامج, فسيظهر لنا خطأ, و يخبرنا في أي سطر وجده و ما الذي سببه.


•إذاً لإصلاح هذا الخطأ علينا فقط إعطاء المتغير a قيمة قبل أن نعرض قيمته.

•لا تقلق من الجملة Variable is not used لأنها تعني فقط أننا حتى الآن لم نستخدم هذا المتغير, أي يمكننا الإستغناء عنه.



المثال الثاني

•أحياناً ينسى المبرمج و يستخدم مباشرةً إسم متغير دون أن يكون قد قام بتعريف هذا المتغير, أي نسيَ أن يفعل له Declare.
هنا سنقوم بعرض قيمة متغير غير موجود إطلاقاً.

System.out.println(a);

•في هذا الحالة سيظهر لك هذه الرسالة إذا وضعت الماوس فوق اللمبة.


•إذاً المشكلة هنا أنه لم يعرف ما هو a, و هذا يعني أنك نسيت تعريف المتغير a قبل أن تضعه في الدالة.


مفهوم العوامل في جافا

العوامل ( operators ) عبارة عن رموز لها معنى محدد, و يمكننا تقسيم العوامل إلى 5 مجموعات أساسية كالتالي:

  • Arithmetic Operators

  • Comparison Operators

  • Logical Operators

  • Bitwise Operators

  • Assignment Operators


هناك أيضاً عوامل أخرى, سنراها في آخر الدرس.

العوامل التي تستخدم في العمليات الحسابية (Arithmetic Operators)

إسم العامل رمزه مثال شرح الكود
Assignment = a = b أعطي a قيمة b
Addition + a + b أضف قيمة b على قيمة a
Subtraction - a - b إطرح قيمة b من قيمة a
Unary plus + +a أضرب قيمة a بالعامل +
Unary minus - -a أضرب قيمة a بالعامل -
Multiplication * a * b أضرب قيمة a بقيمة b
Division / a / b أقسم قيمة a على قيمة b
Modulo % a % b للحصول على آخر رقم يبقى عندما نقسم قيمة a على قيمة b
Increment ++ a++ لإضافة 1 على قيمة a و تستخدم في الحلقات
Decrement -- a-- لإنقاص 1 من قيمة a و تستخدم في الحلقات

هنا وضعنا مثال لكل عامل موجود في الجدول

العامل = (Assignment Operator)

العامل = يستخدم لإعطاء قيمة للمتغير.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 5;       // 5 القيمة a أعطينا المتغير
	  int b = a;       // a قيمة المتغير b أعطينا المتغير

	  System.out.println( "a = " +a );
	  System.out.println( "b = " +b );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 5
	  b = 5


العامل + (Addition Operator)

العامل + يستخدم لإضافة قيمة على قيمة, أي في عمليات الجمع.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 3;
	  int b = 4;

	  int c = a + b;   // c = 3 + 4 = 7

	  System.out.println( "c = " +c );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  c = 7


العامل - (Subtraction Operator)

العامل - يستخدم لإنقاص قيمة من قيمة, أي في عمليات الطرح.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 3;
	  int b = 4;

	  int c = a - b;   // c = 3 - 4 = -1

	  System.out.println( "c = " +c );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  c = -1


العامل + (Unary-Plus Operator)

يعني ضرب القيمة بالعامل +.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // b لها في المتغير Unary-Plus قيمة أكبر من صفر, ثم وضعنا قيمة الـ a هنا وضعنا في المتغير
	  int a = 10;
	  int b = +a;           // b = +(10) = 10

	  System.out.println( "b = " + b );


	  // b لها في المتغير Unary-Plus قيمة أصغر من صفر, ثم وضعنا قيمة الـ a هنا وضعنا في المتغير
	  a = -10;
	  b = +a;           // b = +(-10) = -10

	  System.out.println( "b = " + b );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  b = 10
	  b = -10


العامل - (Unary-Minus Operator)

يعني ضرب القيمة بالعامل -.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // b لها في المتغير Unary-Minus قيمة أكبر من صفر, ثم وضعنا قيمة الـ a هنا وضعنا في المتغير
	  int a = 10;
	  int b = -a;           // b = -(10) = -10

	  System.out.println( "b = " + b );


	  // b لها في المتغير Unary-Minus قيمة أصغر من صفر, ثم وضعنا قيمة الـ a هنا وضعنا في المتغير
	  a = -10;
	  b = -a;           // b = -(-10) = 10

	  System.out.println( "b = " + b );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  b = -10
	  b = 10


العامل * (Multiplication Operator)

العامل * يستخدم لضرب قيمة بقيمة, أي في عمليات الضرب.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 6;
	  int b = 5;

	  int c = a * b;     // c = 6 * 5 = 30

	  System.out.println( "c = " +c );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  c = 30


العامل / (Division Operator)

العامل / يستخدم لقسمة قيمة على قيمة, أي في عمليات القسمة.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 8;
	  int b = 5;

	  int c = a / b;     // c = 8 / 5 = 1

	  System.out.println( "c = " +c );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  c = 1

•ملاحظة: سبب عدم ظهور أي أرقام بعد الفاصلة هو أننا عرفنا المتغيرات كأعداد صحيحة int.



العامل % (Modulo Operator)

العامل % يقال له الـ Modulo و يسمى Remainder في الرياضيات و هو آخر رقم يبقى من عملية القسمة.
إذاً نستخدم الـ Modulo للحصول على آخر رقم يبقى من عملية القسمة.
و له فوائد كثيرة, فمثلاً يمكننا إستخدامه لمعرفة ما إذا كان الرقم مفرد أو مزدوج ( أي Even or Odd ) و هذا شرحناه بتفصيل في مادة الخوارزميات.

في هذا المثال سنقوم بتخزين الرقم الذي يبقى من القسمة في المتغير c.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 8;
	  int b = 5;

	  int c = a % b;     // c = 8 % 5 = 3

	  System.out.println( "c = " +c );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  c = 3


العامل ++ (Increment Operator)

العامل ++ يستخدم لزيادة قيمة المتغير واحداً, و هذا الأسلوب يستخدم كثيراً في الحلقات لزيادة قيمة العداد واحداً في كل دورة بكود أقل.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 5;

	  a++;     // a = 5 + 1 = 6

	  System.out.println( "a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 6


العامل -- (Decrement Operator)

العامل -- يستخدم لإنقاص قيمة المتغير واحداً, و هذا الأسلوب يستخدم كثيراً في الحلقات لإنقاص قيمة العداد واحداً في كل دورة بكود أقل.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 5;

	  a--;     // a = 5 - 1 = 4

	  System.out.println( "a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 4

العوامل التي تستخدم في المقارنات (Comparison Operators)

إسم العامل رمزه مثال شرح الكود
Equal to == (a == b) هل قيمة a تساوي قيمة b ؟
إذا كان الجواب نعم فإنها ترجع true
Not equal to != (a != b) هل قيمة a لا تساوي قيمة b ؟
إذا كان الجواب نعم فإنها ترجع true
Greater than > (a > b) هل قيمة a أكبر من قيمة b ؟
إذا كان الجواب نعم فإنها ترجع true
Less than < (a < b) هل قيمة a أصغر من قيمة b ؟
إذا كان الجواب نعم فإنها ترجع true
Greater than
or Equal to		 >= (a >= b) هل قيمة a أكبر أو تساوي قيمة b ؟
إذا كان الجواب نعم فإنها ترجع true
Less than
or Equal to		 <= (a <= b) هل قيمة a أصغر أو تساوي قيمة b ؟
إذا كان الجواب نعم فإنها ترجع true

هنا وضعنا مثال لكل عامل موجود في الجدول

العامل == (Equal To Operator)

العامل == يستخدم لتنفيذ كود معين إذا كانت قيمة المتغير الأول تساوي قيمة المتغير الثاني.

عندما نضعه في الشرط فإنه يعني هل قيمة المتغير الأول تساوي قيمة المتغير الثاني؟

  • إذا كانت تساويها سيكون الجواب true و بالتالي سينفذ الكود.

  • أما إذا لم تكن تساويها سيكون الجواب false و بالتالي لن ينفذ الكود.


مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 10;
	  int c = 20;

	  // سيتم تنفيذ أمر الطباعة b تساوي قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a == b )
	  {
	  System.out.println("a = b");
	  }

	  // سيتم تنفيذ أمر الطباعة c تساوي قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a == c )
	  {
	  System.out.println("a = c");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = b

•نلاحظ أنه نفذ أمر الطباعة الموضوع في الشرط الأول لأن جواب الشرط كان true. و لم ينفذ أمر الطباعة الموضوع في الشرط الثاني لأن جواب الشرط كان false.



العامل != (Not Equal To Operator)

العامل != يستخدم لتنفيذ كود معين إذا كانت قيمة المتغير الأول لا تساوي قيمة المتغير الثاني.

عندما نضعه في الشرط فإنه يعني هل قيمة المتغير الأول لا تساوي قيمة المتغير الثاني؟

  • إذا كانت لا تساويها سيكون الجواب true و بالتالي سينفذ الكود.

  • أما إذا كانت تساويها سيكون الجواب false و بالتالي لن ينفذ الكود.


مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 10;
	  int c = 20;

	  // سيتم تنفيذ أمر الطباعة b لا تساوي قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a != b )
	  {
	  System.out.println("a != b");
	  }

	  // سيتم تنفيذ أمر الطباعة c لا تساوي قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a != c )
	  {
	  System.out.println("a != c");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a != c

•نلاحظ أنه نفذ أمر الطباعة الموضوع في الشرط الثاني لأن جواب الشرط كان true. و لم ينفذ أمر الطباعة الموضوع في الشرط الأول لأن جواب الشرط كان false.



العامل > (Greater Than Operator)

العامل > يستخدم لتنفيذ كود معين إذا كانت قيمة المتغير الأول أكبر من قيمة المتغير الثاني.

عندما نضعه في الشرط فإنه يعني هل قيمة المتغير الأول أكبر من قيمة المتغير الثاني؟

  • إذا كانت أكبر منها سيكون الجواب true و بالتالي سينفذ الكود.

  • إذا لم تكن أكبر منها سيكون الجواب false و بالتالي لن ينفذ الكود.


مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 5;

	  // سيتم تنفيذ أمر الطباعة b أكبر من قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a > b )
	  {
	  System.out.println("a > b");
	  }

	  // سيتم تنفيذ أمر الطباعة a أكبر من قيمة المتغير b الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( b > a )
	  {
	  System.out.println("b > a");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a > b

•نلاحظ أنه نفذ أمر الطباعة الموضوع في الشرط الأول لأن جواب الشرط كان true. و لم ينفذ أمر الطباعة الموضوع في الشرط الثاني لأن جواب الشرط كان false.



العامل < (Less Than Operator)

العامل < يستخدم لتنفيذ كود معين إذا كانت قيمة المتغير الأول أصغر من قيمة المتغير الثاني.

عندما نضعه في الشرط فإنه يعني هل قيمة المتغير الأول أصغر من قيمة المتغير الثاني؟

  • إذا كانت أصغر منها سيكون الجواب true و بالتالي سينفذ الكود.

  • إذا لم تكن أصغر منها سيكون الجواب false و بالتالي لن ينفذ الكود.


مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 5;

	  // سيتم تنفيذ أمر الطباعة b أصغر من قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a < b )
	  {
	  System.out.println("a < b");
	  }

	  // سيتم تنفيذ أمر الطباعة a أصغر من قيمة المتغير b الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( b < a )
	  {
	  System.out.println("b < a");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  b < a

•نلاحظ أنه نفذ أمر الطباعة الموضوع في الشرط الثاني لأن جواب الشرط كان true. و لم ينفذ أمر الطباعة الموضوع في الشرط الأول لأن جواب الشرط كان false.



العامل >= (Greater Than or Equal To Operator)

العامل >= يستخدم لتنفيذ كود معين إذا كانت قيمة المتغير الأول أكبر أو تساوي قيمة المتغير الثاني.

عندما نضعه في الشرط فإنه يعني هل قيمة المتغير الأول أكبر أو تساوي قيمة المتغير الثاني؟

  • إذا كانت أكبر منها أو تساويها سيكون الجواب true و بالتالي سينفذ الكود.

  • إذا لم تكن أكبر منها أو تساويها سيكون الجواب false و بالتالي لن ينفذ الكود.


مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 5;
	  int b = 5;
	  int c = 10;

	  // سيتم تنفيذ أمر الطباعة b أكبر أو تساوي قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a >= b )
	  {
	  System.out.println("a >= b");
	  }

	  // سيتم تنفيذ أمر الطباعة c أكبر أو تساوي قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a >= c )
	  {
	  System.out.println("a >= c");
	  }

	  // سيتم تنفيذ أمر الطباعة a أكبر أو تساوي قيمة المتغير c الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( c >= a )
	  {
	  System.out.println("c >= a");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a >= b
	  c >= a

•نلاحظ أنه نفذ أمر الطباعة الموضوع في الشرط الأول و الثالث لأن جواب الشرط كان true. و لم ينفذ أمر الطباعة الموضوع في الشرط الثاني لأن جواب الشرط كان false.



العامل <= (Less Than or Equal To Operator)

العامل <= يستخدم لتنفيذ كود معين إذا كانت قيمة المتغير الأول أصغر أو تساوي قيمة المتغير الثاني.

عندما نضعه في الشرط فإنه يعني هل قيمة المتغير الأول أصغر أو تساوي قيمة المتغير الثاني؟

  • إذا كانت أصغر منها أو تساويها سيكون الجواب true و بالتالي سينفذ الكود.

  • إذا لم تكن أصغر منها أو تساويها سيكون الجواب false و بالتالي لن ينفذ الكود.


مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 5;
	  int b = 5;
	  int c = 10;

	  // سيتم تنفيذ أمر الطباعة b أصغر أو تساوي قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a <= b )
	  {
	  System.out.println("a <= b");
	  }

	  // سيتم تنفيذ أمر الطباعة c أصغر أو تساوي قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a <= c )
	  {
	  System.out.println("a <= c");
	  }

	  // سيتم تنفيذ أمر الطباعة a أصغر أو تساوي قيمة المتغير c الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( c <= a )
	  {
	  System.out.println("c <= a");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a <= b
	  a <= c

•نلاحظ أنه نفذ أمر الطباعة الموضوع في الشرط الأول و الثاني لأن جواب الشرط كان true. و لم ينفذ أمر الطباعة الموضوع في الشرط الثالث لأن جواب الشرط كان false.

العوامل التي تستخدم في وضع شروط منطقية (Logical Operators)

إسم العامل رمزه مثال شرح الكود
AND && (a && b) هل قيمة a و b تساويان true ؟
هنا يجب أن يتم تحقيق الشرطين ليرجع true
OR || (a || b) هل قيمة a أو b أو كلاهما تساويان true ؟
هنا يكفي أن يتم تحقيق شرط واحد من الشرطين ليرجع true
NOT ! !a هل قيمة a لا تساوي true ؟
إذا كان الجواب نعم فإنها ترجع true

هنا وضعنا مثال لكل عامل موجود في الجدول

العامل && (AND Operator)

العامل && يستخدم لتنفيذ كود معين إذا تحقق الشرط الأول و الشرط الثاني.

  • أي إذا كانت نتيجة الشرط الأول تساوي true و نتيجة الشرط الثاني تساوي true سينفذ الكود.

  • إذا لم تكن نتيجة كلا الشرطين تساوي true لن ينفذ الكود.


المثال الأول

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 20;

	  // تساوي 20 سيتم تنفيذ أمر الطباعة b تساوي 10, و قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a == 10 && b == 20 )
	  {
	  System.out.println("The first and the second conditions return true");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  The first and the second conditions return true

•نلاحظ أنه نفذ أمر الطباعة لأن جواب الشرطين الموضوعين في الجملة if هو true.


المثال الثاني

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 20;

	  // تساوي 50 سيتم تنفيذ أمر الطباعة b تساوي 10, و قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a == 10 && b == 50 )
	  {
	  System.out.println("The first and the second conditions return true");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

•نلاحظ أنه لم ينفذ أمر الطباعة لأن جواب الشرط الثاني الموضوع في الجملة if هو false.



العامل || (OR Operator)

العامل || يستخدم لتنفيذ كود معين إذا تحقق على الأقل واحد من الشروط الموضوعة.
إذاً هنا يكفي أن يرجع أحد الشرطين القيمة true حتى يتم تنفيذ الأوامر الموضوعة.


المثال الأول

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 20;

	  // تساوي 50 سيتم تنفيذ أمر الطباعة b تساوي 10, أو قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a == 10 || b == 50 )
	  {
	  System.out.println("One of the conditions return true");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  One of the conditions return true

•نفذ أمر الطباعة لأن جواب الشرط الأول الموضوع في الجملة if هو true.


المثال الثاني

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 20;

	  // تساوي 50 سيتم تنفيذ أمر الطباعة b تساوي 50, أو قيمة المتغير a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( a == 50 || b == 50 )
	  {
	  System.out.println("One of the conditions return true");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

•نلاحظ أنه لم ينفذ أمر الطباعة لأن جواب الشرط الأول و الثاني الموضوعين في الجملة if هو false.



العامل ! (NOT Operator)

العامل ! يستخدم لتنفيذ كود معين إذا لم يتحقق أي شرط تم وضعه.
أي إذا أرجع الشرط أو جميع الشروط الموضوعة القيمة false سيتم تنفيذ الأوامر الموضوعة.


المثال الأول

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;

	  // لا تساوي 10 سيتم تنفيذ أمر الطباعة a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( !(a == 10) )
	  {
	  System.out.println("The condition return false");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

•لم ينفذ أمر الطباعة لأن جواب الشرط هو true.


المثال الثاني

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;

	  // لا تساوي 20 سيتم تنفيذ أمر الطباعة a الشرط التالي يعني أنه إذا كانت قيمة المتغير
	  if( !(a == 20) )
	  {
	  System.out.println("The condition return true");
	  }

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  The condition return true

•نفذ أمر الطباعة لأن جواب الشرط هو false.

العوامل التي تستخدم للتعامل مع الـ bits (Bitwise Operators)

إسم العامل رمزه مثال شرح الكود
Bitwise AND & a & b العامل & يحسب ناتج جمع الـ bits المشتركة بين a و b
Bitwise OR | a | b العامل | يحسب ناتج جمع الـ bits المشتركة و الغير مشتركة بين a و b
Bitwise XOR ^ a ^ b العامل ^ يحسب ناتج جمع الـ bits الغير مشتركة بين a و b
Bitwise compliment OR ~ ~a العامل ~ يقلب الـ bits التي تساوي 0 إلى 1 و يقلب الـ bits التي تساوي 1 إلى 0,
ثم يضيف عليهم 1 و يحسب ناتج جمعهم, بعدها يضرب الجواب بالعامل ( - ) ثم يعطينا جواب سلبي.
Left shift << a << 2 العامل << يزيح الـ bits من آخر اليسار إلى أول اليمين.
العدد 2 يعني أننا سنزيح آخر إثنين bits و نضعهم في الأول.
Right shift >> a >> 2 العامل >> يزيح الـ bits من أول اليمين إلى آخر اليسار.
العدد 2 يعني أننا سنزيح أول إثنين bits و نضعهم في الأخير.
Zero fill right shift >>> a >>> 2 العامل >>> يزيح الـ bits من أول اليمين ثم يبدلهم بأصفار و يضعهم في آخر اليسار.
العدد 2 يعني أننا سنمسح أول إثنين bits و نضع بدالهم صفرين في الأخير.

هنا وضعنا مثال لكل عامل موجود في الجدول

العامل & (Bitwize AND)

العامل & يحسب ناتج جمع الـ bits المشتركة بين قيمتين.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;      // a = 10 = 00000000000000000000000000001010
	  int b = 75;      // b = 75 = 00000000000000000000000001001011

	  int c = a & b;   // شرحنا كيف سيتم الحصول على الناتج تحت نتيجة التشغيل

	  System.out.print(a+ " & " +b+ " = " +c);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  10 & 75 = 10

• هنا قمنا بتعليم الـ bits المشتركة و التي تم جمعها باللون الاصفر.

a = 10;      // 10 = 00000000000000000000000000001010
b = 75;      // 75 = 00000000000000000000000001001011

c = a & b;   //  c = 00000000000000000000000000001010
             //  c = 10


العامل | (Bitwize OR)

العامل | يحسب ناتج جمع الـ bits المشتركة و الغير مشتركة بين قيمتين.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;      // 10 = 00000000000000000000000000001010
	  int b = 75;      // 75 = 00000000000000000000000001001011

	  int c = a | b;   // شرحنا كيف سيتم الحصول على الناتج تحت نتيجة التشغيل

	  System.out.print(a+ " | " +b+ " = " +c);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  10 | 75 = 75

• هنا قمنا بتعليم الـ bits المشتركة و الغير مشتركة و التي تم جمعها باللون الاصفر.

a = 10;      // 10 = 00000000000000000000000000001010
b = 75;      // 75 = 00000000000000000000000001001011

c = a | b;   //  c = 00000000000000000000000001001011
             //  c = 75


العامل ^ (Bitwize XOR)

العامل ^ يحسب ناتج جمع الـ bits الغير مشتركة بين قيمتين.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;      // 10 = 00000000000000000000000000001010
	  int b = 75;      // 75 = 00000000000000000000000001001011

	  int c = a ^ b;   // شرحنا كيف سيتم الحصول على الناتج تحت نتيجة التشغيل

	  System.out.print(a+ " ^ " +b+ " = " +c);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  10 ^ 75 = 65

• هنا قمنا بتعليم الـ bits الغير مشتركة و التي تم جمعها باللون الاصفر.

a = 10;      // 10 = 00000000000000000000000000001010
b = 75;      // 75 = 00000000000000000000000001001011

c = a | b;   //  c = 00000000000000000000000001000001
             //  c = 65


العامل ~ (Bitwize Compliment OR)

العامل ~ يقلب الـ bits التي تساوي 0 إلى 1 و يقلب الـ bits التي تساوي 1 إلى 0.
بعدها يتم حساب الناتج باتباع مبدأ single precision floating point number.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;     // 10 = 00000000000000000000000000001010
	  int c = ~a;     //  c = 11111111111111111111111111110111 = -11

	  System.out.print("~" +a+ " = " +c);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  ~10 = -11


العامل << (Left Shift)

العامل << يمسح bits من ناحية اليسار ثم يبدل كل bit تم مسحها منهم بصفر و يضعهم من ناحية اليمين.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;       // 10 = 00000000000000000000000000001010
	  int c = a << 2;   // شرحنا كيف سيتم الحصول على الناتج تحت نتيجة التشغيل

	  System.out.print(a+ " << 2 = " +c);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  10 << 2 = 40

• هنا قمنا بتعليم الـ bits التي تم مسحها باللون الاصفر و تعليم الـ bits التي تم إضافتها باللون الأزرق.

a = 10;       // 10 = 00000000000000000000000000001010

c = a << 2;   //  c = 00000000000000000000000000101000 = 40
              //  c = 40


العامل >> (Right Shift)

العامل >> عندها حالتين: قد يكون العدد أكبر من صفر أو أصغر من صفر.

  • إذا كان العدد أكبر من صفر, يمسح bits من ناحية اليمين ثم يبدل كل bit منهم بصفر و يضعهم من ناحية اليسار.

  • إذا كان العدد أصغر من صفر, يمسح bits من ناحية اليمين ثم يبدل كل bit منهم بواحد ليحافظ على إشارة الناقص و يضعهم من ناحية اليسار.


المثال الأول

•الحالة الأولى: إذا كان العدد أكبر من صفر.

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 9;        // 9 = 00000000000000000000000000001001
	  int c = a >> 2;   // شرحنا كيف سيتم الحصول على الناتج تحت نتيجة التشغيل

	  System.out.print(a+ " >> 2 = " +c);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

9 >> 2 = 2

• هنا قمنا بتعليم الـ bits التي تم مسحها باللون الاصفر و تعليم الـ bits التي تم إضافتها باللون الأزرق.

a = 9;        // 9 = 00000000000000000000000000001001

c = a >> 2;   // c = 00000000000000000000000000000010
              // c = 2

المثال الثاني

•الحالة الثانية: إذا كان العدد أصغر من صفر.

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  // Note " >> " converts the number in 32 bits form

	  int a = -9;       // -9 = 11111111111111111111111111111000
	  int c = a >> 2;   // شرحنا كيف سيتم الحصول على الناتج تحت نتيجة التشغيل

	  System.out.print(a+ " >> 2 = " +c);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  -9 >> 2 = -3

• هنا قمنا بتعليم الـ bits التي تم مسحها باللون الاصفر و تعليم الـ bits التي تم إضافتها باللون الأزرق.

a = -9;       // -9 = 11111111111111111111111111110111

c = a >> 2;   //  c = 11111111111111111111111111111101
              //  c = -3


العامل >>> (Zero Fill Right Shift)

العامل >>> يمسح bits من ناحية اليمين ثم يبدل كل bit منهم بصفر و يضعهم من ناحية اليسار.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;        // 10 = 00000000000000000000000000001010
	  int c = a >>> 2;   //  c = 00000000000000000000000000000010 = 2

	  System.out.print(a+ " >>> 2 = " +c);

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  10 >>> 2 = 2

ما هو الفرق بين العامل >>> و العامل >>؟

الفرق بينهما هو أن العامل >>> يحول دائماً آخر bit في العدد إلى 0 و هذا سيجعل الناتج دائماً رقم أكبر أو يساوي 0.

العوامل التي تستخدم لإعطاء قيم للمتغيرات (Assignment Operators)

إسم العامل رمزه مثال شرح الكود
Basic Assignment = a = b ضع قيمة b في a.
Add AND Assignment += a += b أضف قيمة a على قيمة b و خزن الناتج في a
Susbtract AND Assignment -= a -= b أنقص قيمة a من قيمة b و خزن الناتج في a
Multiply AND Assignment *= a *= b أضرب قيمة a بقيمة b و خزن الناتج في a
Divide AND Assignment /= a /= b أقسم قيمة a على قيمة b و خزن الناتج في a
Modulo AND Assignment %= a %= b أقسم قيمة a على قيمة b و خزن آخر رقم يبقى من عملية القسمة في a
Left shift AND Assignment <<= a <<= 2 أزح آخر إثنين bits و ضعهم في الأول ثم خزن الناتج في a
Right shift AND Assignment >>= a >>= 2 أزح أول اثنين bits و ضعهم في الآخر ثم خزن الناتج في a
Bitwise AND Assignment &= a &= b أحسب ناتج جمع الـ bits المشتركة بين a و b و خزن الناتج في a
Bitwise exclusive OR and Assignment ^= a ^= b أحسب ناتج جمع الـ bits الغير مشتركة بين a و b و خزن الناتج في a
Bitwise inexclusive OR and Assignment |= a |= b أحسب ناتج جمع الـ bits المشتركة و الغير مشتركة بين a و b و خزن الناتج في a

هنا وضعنا مثال لكل عامل موجود في الجدول

العامل = (Basic Assign)

العامل = يستخدم لإعطاء قيمة لمتغير.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 10


العامل += (Add and Assign)

العامل += يستخدم لإضافة قيمة ما على قيمة المتغير بكود أقل.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 20;

	  a += b;        // a  =  a + b  =  10 + 20  =  30

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 30


العامل -= (Susbtract and Assign)

العامل -= يستخدم لطرح قيمة ما من قيمة المتغير بكود أقل.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 20;

	  a -= b;           // a  =  a - b  =  10 - 20  =  -10

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = -10


العامل *= (Multiply and Assign)

العامل *= يستخدم لضرب قيمة المتغير بقيمة ما بكود أقل.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 20;

	  a *= b;   // a  =  a * b  =  10 * 20  =  200

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 200


العامل /= (Divide and Assign)

العامل /= يستخدم لقسم قيمة المتغير على قيمة ما بكود أقل.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 100;
	  int b = 20;

	  a /= b;   //   a  =  a / b  =  100 / 20  =  5

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 5


العامل %= (Modulo and Assign)

العامل %= يستخدم لتخزين الباقي من قسمة قيمة المتغير على قيمة ما بكود أقل.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 7;

	  a %= b;   //   a  =  a % b  =  10 % 7  =  3

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 3


العامل <<= (Left shift and Assign)

في المثال التالي, العامل <<= يعني إمسح bits من ناحية اليسار ثم بدل كل bit تم مسحها منهم بصفر و ضعهم من ناحية اليمين ثم ضع الناتج في المتغير من جديد.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  a <<= 2;   //   a  =  a << 2  =  00000000000000000000000000001010 << 2  =  00000000000000000000000000101000  =  40

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 40


العامل >>= (Right shift and Assign)

في المثال التالي, العامل >>= يعني إمسح bits من ناحية اليمين ثم بدل كل bit تم مسحها منهم بصفر و ضعهم من ناحية اليسار ثم ضع الناتج في المتغير من جديد.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  a >>= 2;   //   a  =  a >> 2  =  00000000000000000000000000001010 >> 2  =  00000000000000000000000000000010  =  2

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 2


العامل &= (Bitwise and Assign)

العامل &= يعني أحسب ناتج جمع الـ bits المشتركة بين المتغير a و المتغير b ثم خزن الناتج في المتغير a.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 75;

	  a &= b;   //   a  =  a & b  =  00000000000000000000000000001010  &  00000000000000000000000001001011  =  00000000000000000000000000001010  =  10

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 10


العامل |= (Bitwise exclusive OR and Assign)

العامل |= يعني أحسب ناتج جمع الـ bits المشتركة و الغير مشتركة بين المتغير a و المتغير b ثم خزن الناتج في المتغير a.

مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;
	  int b = 75;

	  a |= b;   //   a  =  a | b  =  00000000000000000000000000001010  |  00000000000000000000000001001011  =  00000000000000000000000001001011  =  75

	  System.out.println( " a = " +a );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  a = 75

عوامل أخرى مهمة في جافا

إسم العامل رمزه إستخدامه
Conditional :? يطلق عليه أيضاً إسم Ternary Operator لأنه يأخذ ثلاث عناصر ليعمل.
يمكن إستعماله بدل جمل الشرط if و else في حال كنت تريد إعطاء قيمة للمتغير.
Instance Of instanceof يستخدم لمعرفة إذا كان الكائن هو نسخة لكلاس معين أم لا.
إذا كان نسخة منه فإنه يرجع true إذا لم يكن منه فإنه يرجع false

هنا وضعنا مثال لكل عامل موجود في الجدول

العامل ?! (Conditional Operator)

العامل ?! يقال له Conditional أو Ternary Operator لأنه يأخذ ثلاث عناصر ليعمل.
يمكن إستعماله بدل جمل الشرط if و else في حال كنت تريد إعطاء قيمة للمتغير.


بناؤه

variable x = (expression) ? value if true : value if false

  • expression:   يمثل الشرط الذي نضعه.

  • value if true:   تمثل القيمة التي ستعطى للمتغير x إذا تحقق الشرط نضعها بعد الرمز ?.

  • value if false:   تمثل القيمة التي ستعطى للمتغير x إذا لم يتحقق الشرط نضعها بعد الرمز :.



المثال الأول

•إذا كانت قيمة المتغير a تساوي 1 سيتم وضع القيمة 20 في المتغير b.
•إذا كانت قيمة المتغير a لا تساوي 1 سيتم وضع القيمة 30 في المتغير b.

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;

	  int b = (a == 1) ?20 :30;

	  System.out.println( "b = " +b );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  b = 30

•نلاحظ أنه تم وضع القيمة 30 في b لأن نتيجة الشرط كانت false.


المثال الثاني

•إذا كانت قيمة المتغير a أكبر من 1 سيتم وضع القيمة 20 في المتغير b.
•إذا كانت لم تكن قيمة المتغير a أكبر من 1 سيتم وضع القيمة 30 في المتغير b.

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  int a = 10;

	  int b = (a > 1) ?20 :30;

	  System.out.println( "b = " +b );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  b = 20

•نلاحظ أنه تم وضع القيمة 20 في b لأن نتيجة الشرط كانت true.



العامل instanceOf (Instance Of Operator)

العامل instanceOf يستخدم لمعرفة الكلاس الذي إشتق منه الكائن أو يمكنك القول لمعرفة أصل الكائن.

  • إذا كان الكائن الموضوع قبل العامل instanceOf مشتق من الكلاس أو الإنترفيس الموضوع بعدها فإنه يرجع true.

  • إذا لم يكن مشتقاً منه فإنه يرجع false.


مثال

Main.java 
	  public class Main {

	  public static void main(String[] args) {

	  String web = "harmash.com";

	  System.out.print( web instanceof String );

	  }

	  }

•سنحصل على النتيجة التالية عند التشغيل.

	  true

•نلاحظ أنه عرض القيمة true لأن المتغير web هو كائن من الكلاس String.


في الدرس التالي سنتعرف على الحلقات الموجودة في جافا.