TEJHOST: مشغلي جافا Java Operators

مشغلي جافا Java Operators

يتم استخدام مشغلي جافا Java Operators لمعالجة أنواع البيانات البدائية. ويمكن تصنيف مشغلي جافا كأحادي "unary" أو ثنائي "binary" أو ثلاثي "ternary" ، بمعني أنها تتخذ واحد أو اثنين أو الثلاث حجج "arguments" على التوالي. ويجوز للمشغل الأحادي "unary operator" المثول أمام حجته "argument" (اختصار "prefix" ) أو بعد حجته ("postfix"). المشغل الثنائي أو الثلاثي يظهر بين حججه"arguments".

مشغلي جافا Java Operators ينقسموا إلى 8 فئات مختلفة :

ينقسم مشغلي جافا Java Operators إلى ثماني فئات مختلفة : الاحالة "assignment" ، و الحسابي "arithmetic" ، العلائقية "relational" ، المنطقية "logical" ، و المختصة بالبت "bitwise" ، مركب الاحالة "compound assignment" ، الشرطي "conditional" ، والنوع "type".

Assignment Operators =

Arithmetic Operators - + * / % ++ --

Relational Operators > < >= <= == !=

Logical Operators && || & | ! ^

Bit wise Operator & | ^ >> >>>

Compound Assignment Operators += -= *= /= %= <<= >>= >>>=

Conditional Operator ?:

مشغلي الاحالة Assignment operators

بيان مشغلي الاحالة Assignment operators لجافا لديه هذا التركيب "syntax":

variable = expression

إذا كانت القيمة موجودة بالفعل في المتغير فسيتم تجاوزها بواسطة عامل الاحالة (=).

public class AssignmentOperatorsDemo {
   public AssignmentOperatorsDemo( ) {
     
//    Assigning Primitive Values
    int j, k;
    j = 10;       // j gets the value 10.
    j = 5;        // j gets the value 5. Previous value is overwritten.
    k = j;        // k gets the value 5.
    System.out.println("j is : "+j);
    System.out.println("k is : "+k);
     
//    Assigning References
    Integer i1 = new Integer("1");
    Integer i2 = new Integer("2");
    System.out.println("i1 is : "+i1);
    System.out.println("i2 is : "+i2);
    i1 = i2;
    System.out.println("i1 is : "+i1);
    System.out.println("i2 is : "+i2);
     
//    Multiple Assignments
    k = j = 10;       // (k = (j = 10))
    System.out.println("j is : "+j);
    System.out.println("k is : "+k);
 
   }
   public static void main(String args[]){
    new AssignmentOperatorsDemo();
   }
}

المشغلين الحسابيين Arithmetic operators

جافا يوفرثمانية عوامل الحسابية. و هم الجمع ، الطرح ، الضرب ، القسمة، مودولو "modulo" (أو ما تبقى) ، التزايد "increment" (أو إضافة 1) ، وإنقاص decrement (أو طرح 1) ، والنفي "negation". ويظهر البرنامج أدناه أمثلة توضح مختلف العوامل الحسابية في جافا.

عند استعمال المشغل + فيتم تحديد نوع العملية التي يقوم بها من نفس نوع المعاملات. فعندما يكون واحد من المعاملات كائن سلسلة "String object" ، فيتم تحويل المعامل الأخرى ضمنيا لتمثيل سلسلة "String" ويتم تنفيذ تسلسل السلسلة.

1	`String message =` `100` `+` `"Messages";` `//"100 Messages"`

public class ArithmeticOperatorsDemo {
   public ArithmeticOperatorsDemo( ) {
      int x, y = 10, z = 5;
      
      x = y + z;
      System.out.println("+ operator resulted in "+x);
      x = y - z;
      System.out.println("- operator resulted in "+x);
      x = y * z;
      System.out.println("* operator resulted in "+x);
      x = y / z;
      System.out.println("/ operator resulted in "+x);
      x = y % z;
      System.out.println("% operator resulted in "+x);
      x = y++;
      System.out.println("Postfix ++ operator resulted in "+x);
      x = ++z;
      System.out.println("Prefix ++ operator resulted in "+x);
      x = -y;
      System.out.println("Unary operator resulted in "+x);
       
//      Some examples of special Cases
       
      int tooBig   = Integer.MAX_VALUE + 1;    // -2147483648 which is Integer.MIN_VALUE.
      int tooSmall = Integer.MIN_VALUE - 1;    //  2147483647 which is Integer.MAX_VALUE.
       
      System.out.println("tooBig becomes "+tooBig);
      System.out.println("tooSmall becomes "+tooSmall);
       
      System.out.println( 4.0 / 0.0);          // Prints:  Infinity
      System.out.println(-4.0 / 0.0);          // Prints: -Infinity
      System.out.println(0.0 / 0.0);         // Prints: NaN
       
      double d1 = 12 / 8;   // result: 1 by integer division. d1 gets the value 1.0.
      double d2 = 12.0F / 8;    // result: 1.5
       
      System.out.println("d1 is "+d1);
      System.out.println("d2 iss "+d2);
 
   }
   
   public static void main(String args[]){
    new ArithmeticOperatorsDemo();
   }
}

المشغلين العلائقيين Relational operators

يتم استخدام المشغلين العلائقيين "Relational operators" في جافا لمقارنة 2 أو أكثر من الكائنات. جافا يوفر ستة مشغلين العلائقيين:

أكبر من (>)، و أقل من (<)، و أكبر من أو يساوي (>=)، و أقل من أو يساوي (<=)، و متساوية (==) ، وغير متساوية (!=).

جميع المشغلين العلائقيين "Relational operators" هم ثنائيين "binary" ، والمعاملات الخاصة بهم هي تعبيرات رقمية "numeric expressions".

يتم تطبيق التعزيز الرقمي الثنائي "Binary numeric promotion" على معاملات لهذه العوامل "operators". نتائج التقييم تكون في قيمة منطقية "boolean value". المشغلين العلائقيين "Relational operators" لديهم أسبقية أقل من المشغلين الحسابيين "arithmetic operators" ، ولكن أعلى من مشغلي الاحالة "assignment operators" . ويُظهر البرنامج أدناه مثال يوضح مختلف المشغلين العلائقيين "Relational operators" في جافا.

public class RelationalOperatorsDemo {
 
   public RelationalOperatorsDemo( ) {
 
      int x = 10, y = 5;
 
      System.out.println("x > y : "+(x > y));
 
      System.out.println("x < y : "+(x < y));
 
      System.out.println("x >= y : "+(x >= y));
 
      System.out.println("x <= y : "+(x <= y));
 
      System.out.println("x == y : "+(x == y));
 
      System.out.println("x != y : "+(x != y));
 
   }
 
   public static void main(String args[]){
 
         new RelationalOperatorsDemo();
 
   }
 
}

المشغلين المنطقيين Logical operators

المشغلين المنطقيين Logical operators يقومون بإرجاع قيمة صحيحة أو خاطئة "true or false" استنادا إلى حالة المتغيرات "Variables". هناك ستة مشغلين منطقية أو قيمة منطقية "logical or boolean". و هم AND و AND الشرطي و OR و OR الشرطي و OR الحصري و NOT. يجب على كل حجة "argument" منطقية لمشغل منطقي ان يكون نوع بياناتها منطقي boolean ، ويكون نوع بيانات النتيجة دائما منطقي boolean. ويظهر البرنامج أدناه مثال يوضح مختلف المشغلين المنطقيين Logical operators في جافا.

public class LogicalOperatorsDemo {
 
   public LogicalOperatorsDemo( ) {
 
   boolean x = true;
 
      boolean y = false;
 
      System.out.println("x & y : "+(x & y));
 
      System.out.println("x && y : "+(x && y));
 
      System.out.println("x | y : "+(x | y));
 
      System.out.println("x || y: "+(x || y));
 
      System.out.println("x ^ y : "+(x ^ y));
 
      System.out.println("!x : "+(!x));
 
   }
 
   public static void main(String args[]){
 
      new LogicalOperatorsDemo();
 
   }
 
}

بالنظر إلى أن x و y تمثل تعبيرات قيمة منطقية "boolean expressions" ، يتم تعريف العوامل المشغلين المنطقيين في الجدول أدناه.

x	y	!x	x & y x && y	x \| y x \|\| y	x ^ y
true	true	false	true	true	false
true	false	false	false	true	true
false	true	true	false	true	true
false	false	true	false	false	false

مشغلين المختصين بالبت Bitwise operators

جافا يوفر مشغلين المختصين بالبت Bitwise operators للتعامل مع محتويات المتغيرات على مستوى بت bit.

يجب أن تكون هذه المتغيرات من نوع البيانات الرقمية (char, short, int, أو long). جافا يوفر سبعة مشغلين المختصين بالبت Bitwise operators. و هم AND و OR ، و Exclusive-OR و Complement و Left-shift و Signed Right-shift و Unsigned Right-shift. ويظهر البرنامج أدناه مثال يوضح مختلف مشغلين المختصين بالبت Bitwise operators في جافا.

public class BitwiseOperatorsDemo {
 
   public BitwiseOperatorsDemo( ) {
 
  int x = 0xFAEF; //1 1 1 1 1 0 1 0 1 1 1 0 1 1 1 1
 
  int y = 0xF8E9; //1 1 1 1 1 0 0 0 1 1 1 0 1 0 0 1
 
  int z;
 
      System.out.println("x & y : "+(x & y));
 
      System.out.println("x | y : "+(x | y));
 
      System.out.println("x ^ y : "+(x ^ y));
 
      System.out.println("~x : "+(~x));
 
      System.out.println("x << y : "+(x << y));
 
      System.out.println("x >> y : "+(x >> y));
 
      System.out.println("x >>> y : "+(x >>> y));
 
      //There is no unsigned left shift operator
 
   }
 
   public static void main(String args[]){
 
         new BitwiseOperatorsDemo();
 
   }
 
}

ويظهر نتيجة لتطبيق للمشغلين المختصين بالبت Bitwise operators بين اثنين من بت "bits" المقابلة في المعاملات في الجدول أدناه.

A	B	~A	A & B	A \| B	A ^ B
1	1	0	1	1	0
1	0	0	0	1	1
0	1	1	0	1	1
0	0	1	0	0	0

Output

3,0,3

/*
 
 * The below program demostrates bitwise operators keeping in mind operator precedence
 
 * Operator Precedence starting with the highest is -> |, ^, &
 
 */
 
public class BitwisePrecedenceEx {
 
       public static void main (String[] args) {
 
          int a = 1 | 2 ^ 3 & 5;
 
          int b = ((1 | 2) ^ 3) & 5;
 
          int c = 1 | (2 ^ (3 & 5));
 
          System.out.print(a + "," + b + "," + c);
 
       }
 
}

مشغلين المركب Compound operators

Syntax:

مشغلين المركب Compound operators تُحدث اختصارات في عمليات البرمجة المشتركة. جافا لديها أحد عشر من مشغلين مركب الاحالة "compound assignment".

التركيب Syntax:

argument1 operator = argument2

مثال:

x += 3;
y *= x;

العبارة أعلاه هي نفسها: argument1 = argument1 operator argument2 . ويظهر البرنامج أدناه مثال يوضح مختلف مشغلين مركب Compound operators.

public class CompoundOperatorsDemo {
 
   public CompoundOperatorsDemo() {
 
      int x = 0, y = 5;
 
      x += 3;
 
      System.out.println("x : "+x);
 
      y *= x;
 
      System.out.println("y :  "+y);
 
      /*Similarly other operators can be applied as shortcuts. Other
 
      compound assignment operators include boolean logical
 
      , bitwiseand shift operators*/
 
   }
 
   public static void main(String args[]){
 
         new CompoundOperatorsDemo();
 
   }
 
}

المشغلين الشرطيين Conditional operators

المشغل الشرطي "Conditional operator" هو المشغل ثلاثي الوحيد (مشغل يأخذ ثلاث حجج "arguments" ) في جافا. المشغل يقوم بتقيم الحجة الأولى فإذا كانة صحيح "true" فيقوم بتقيم الحجة الثانية. إذا كانت الحجة الأولى قُيّمت بـ false سيتم تقييم الحجة الثالثة. المشغل الشرطي "Conditional operator" هو تعبير الذي يعادل البيان if-else . يمكن للتعبير الشرطي ان يتداخل و المشغل الشرطي "Conditional operator" التابع لها من اليمين إلى اليسار : (a?b?c?d:e:f:g) يقيم كـ (a?(b?(c?d:e):f):g)

ويظهر البرنامج أدناه مثال يوضح المشغل ثلاثي في جافا.

public class TernaryOperatorsDemo {
 
   public TernaryOperatorsDemo() {
 
         int x = 10, y = 12, z = 0;
 
         z = x > y ? x : y;
 
         System.out.println("z : "+z);
 
   }
 
   public static void main(String args[]){
 
         new TernaryOperatorsDemo();
 
   }
 
}

/*
 
 * The following programs shows that when no explicit parathesis is used then the conditional operator
 
 * evaluation is from right to left
 
 */
 
public class BooleanEx1 {
 
static String m1(boolean b){return b?"T":"F";}
 
      public static void main(String [] args) {
 
          boolean t1 = false?false:true?false:true?false:true;
 
          boolean t2 = false?false:(true?false:(true?false:true));
 
          boolean t3 = ((false?false:true)?false:true)?false:true;
 
          System.out.println(m1(t1) + m1(t2) + m1(t3));
 
      }
 
}

Output

FFT

تحويل النوع يسمح بتغيير قيمة البيانات البدائية من نوع إلى آخر. عملية التحويل تحدث بشكل صريح ، كما هو محدد في البرنامج ، أو ضمنا، عن طريق جافا نفسها. جافا تسمح بتحويلات اتساع النوع "type widening" وتضييق النوع "type narrowing".

تحويلات جافا يمكن أن تحدث بواسطة الطرق التالية :

باستخدام مشغل cast operator (تعزيز واضح)
باستخدام المشغلين الحسابيين Arithmetic operators يستخدم مع الحجج من أنواع بيانات مختلفة (تعزيز الحساب)
يتم تعيين قيمة من نوع معين إلى متغير من نوع مختلف (تعزيز الاحالة)

مشغل الاسبقية Operator Precedence

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

postfix	[] . () expr++ expr–
unary	++expr –expr +expr -expr ! ~
creation/caste	new (type)expr
multiplicative	* / %
additive	+ -
shift	>> >>>
relational	< <= > >= instanceof
equality	== !=
bitwise AND	&
bitwise exclusive OR	^
bitwise inclusive OR	\|
logical AND	&&
logical OR	\|\|
ternary	?:
assignment	= “op=”

مثال

في عملية مثل

result = 4 + 5 * 3

يتم تقييم (5 * 3) أولا ويتم إضافة النتيجة إلى 4 الذي سيعطينا قيمة النتيجة النهائية 19. علما بأن '*' يأخذ أسبقية أعلى من "+" وفقا للمخطط الموضح أعلاه. هذا النوع من أسبقية مشغل على آخر ينطبق على جميع مشغلين.

الصفحات

الأربعاء، 17 أكتوبر 2012

مشغلي جافا Java Operators

مشغلي جافا Java Operators

مشغلي الاحالة Assignment operators

المشغلين الحسابيين Arithmetic operators

المشغلين العلائقيين Relational operators

المشغلين المنطقيين Logical operators

مشغلين المختصين بالبت Bitwise operators

مشغلين المركب Compound operators

المشغلين الشرطيين Conditional operators

مشغل الاسبقية Operator Precedence

ليست هناك تعليقات:

إرسال تعليق