آرايه ها

يك آرايه گروهي از متغيرهاي يك نوع است كه با يك نام مشترك به آنها ارجاع
مي شود . مي توان آرايه ها را براي هر يك از انواع ايجاد نمود و ممكن است اين
آرايه ها داراي يك يا چندين بعد باشند . براي دسترسي به يك عضو آرايه از نمايه
(index) آن آرايه استفاده مي شود . آرايه ها يك وسيله مناسب براي گروه بندي
اطلاعات مرتبط با هم هستند

نكته : اگر با Cو C++و آشنايي داريد ، آگاه باشيد . آرايه ها در جاوا بطور
متفاوتي نسبت به زبانهاي ديگر كار مي كنند

آرايه هاي يك بعدي

آرايه يك بعدي بطور ضروري فهرستي از متغيرهاي يكنوع است . براي ايجاد يك
آرايه ، بايد يك متغير آرايه از نوع مورد نظرتان ايجاد كنيد . فرم عمومي اعلان
يك آرايه يك بعدي بقرار زير است :

type var-name [ ];

نام متغير نوع

در اينجا type اعلان كننده نوع اصلي آرايه است . نوع اصلي تعيين كننده نوع
داده براي هر يك از اعضائ داخل در آرايه است . بنابراين ، نوع اصلي آرايه تعيين
مي كند كه آرايه چه نوعي از داده را نگهداري مي كند . بعنوان مثال ، در زير
يك آرايه با نام month-days با نوع آرايه اي از عدد صحيح اعلان شده است .

+ int month_days[ ];

اگر چه اين اعلان تثبيت مي كند كه month-days يك متغير آرايه است ، اما بطور
واقعي آرايه اي وجود ندارد . در حقيقت ، مقدار month-days برابر تهي (null)
مي باشد كه يك آرايه بدون مقدار را معرفي مي كند . براي پيوند دادن month-days
با يك آرايه واقعي و فيزيكي از اعداد صحيح ، بايد از يك عملگر new استفاده
نموده و به month-days منتسب كنيد. new يك عملگراست كه حافظه را اختصاص ميدهد. بعداnew " را با دقت بيشتري بررسي مي كنيم ، اما لازم است كه هم اكنون از آن
استفاده نموده و حافظه را براي آرايه ها تخصيص دهيد . فرم عمومي new آنگونه كه
براي آرايه هاي يك بعدي بكار مي رود بقرار زير ظاهر خواهد شد :

array-var=new type [size];

اندازه نوع متغير آرايه

در اينجا type مشخص كننده نوع داده اي است كه تخصيص داده مي شود، size مشخص كننده تعداد اعضائ آرايه است و array-var متغير آرايه است كه به آرايه پيوند مي يابد . يعني براي استفاده از new در تخصيص يك آرايه ، بايد نوع و تعداد
اعضايي كه تخصيص مي يابند را مشخص نماييد . اعضائ آرايه كه توسط new تخصيص مي يابند بطور خودكار با مقدار صفر مقدار دهي اوليه مي شوند . اين مثال يك
آرايه 12 عضوي از اعداد صحيح را تخصيص داده و آنها را به month-days پيوند
مي دهد .

+ month_days = new int[12];

بعد از اجراي اين دستور ، month-days به يك آرايه 12 تايي از اعداد صحيح
ارجاع خواهد نمود . بعلاوه كليه اجزائ در آرايه با عدد صفر مقدار دهي اوليه
خواهند شد .اجازه دهيد مرور كنيم : بدست آوردن يك آرايه مستلزم پردازش دو مرحله اي است.اول بايد يك متغير با نوع آرايه مورد نظرتان اعلان كنيد . دوم بايد حافظه اي كه
آرايه را نگهداري مي كند ، با استفاده از new تخصيص دهيد و آن را به متغير
آرايه نسبت دهيد . بنابراين در جاوا كليه آرايه ها بطور پويا تخصيص مي يابند .
اگر مفهوم تخصيص پويا براي شما ناآشناست نگران نباشيد . اين مفهوم را بعدا"
تشريح خواهيم كرد .

هر بار كه يك آرايه را تخصيص مي دهيد ، مي توانيد بوسيله مشخص نمودن نمايه
آن داخل كروشه [ ] به يك عضو مشخص در آرايه دسترسي پيدا كنيد . كليه نمايه هاي
آرايه ها با عدد صفر شروع مي شوند. بعنوان مثال اين دستور مقدار 28 را به دومين
عضو month-days نسبت مي دهد .

+ month_days[1] = 28;

خط بعدي مقدار ذخيره شده در نمايه 3 را نمايش مي دهد .

+ System.out.println(month_days[3]);

با كنار هم قرار دادن كليه قطعات ، در اينجا برنامه اي خواهيم داشت كه يك
آرايه براي تعداد روزهاي هر ماه ايجاد مي كند .

+ // Demonstrate a one-dimensional array.
+ class Array {
+ public static void main(String args[] ){
+ int month_days[ ];
+ month_days = new int[12];
+ month_days [0] = 31;
+ month_days [1] = 28;
+ month_days [2] = 31;
+ month_days [3] = 30;
+ month_days [4] = 31;
+ month_days [5] = 30;
+ month_days [6] = 31;
+ month_days [7] = 31;
+ month_days [8] = 30;
+ month_days [9] = 31;
+ month_days [10] = 30;
+ month_days [11] = 31;
+ System.out.println("April has " + month_days[3] + " days .");
+ }
+ }

وقتي اين برنامه را اجرا ميكنيد ، برنامه ، تعداد روزهاي ماه آوريل را چاپ
ميكند. همانطوريكه ذكر شد، نمايه هاي آرايه جاوا با صفر شروع مي شوند، بنابراين
تعداد روزهاي ماه آوريل در month-days[3] برابر 30 مي باشد .

اين امكان وجود دارد كه اعلان متغير آرايه را با تخصيص خود آرايه بصورت زير
تركيب نمود

 : + int month_days[ ] = new int[12]

اين همان روشي است كه معمولا" در برنامه هاي حرفه اي نوشته شده با جاوا مشاهده
مي كنيد.مي توان آرايه ها را زمان اعلانشان ، مقدار دهي اوليه نمود . پردازش آن بسيار
مشابه پردازشي است كه براي مقدار دهي اوليه انواع ساده استفاده مي شود . يك
مقدار ده اوليه آرايه فهرستي از عبارات جدا شده بوسيله كاما و محصور شده بين
ابروهاي باز و بسته مي باشد . كاماها مقادير اجزائ آرايه را از يكديگر جدا
مي كنند . آرايه بطور خودكار آنقدر بزرگ ايجاد مي شود تا بتواند ارقام اجزايي
را كه در مقدار ده اوليه آرايه مشخص كرده ايد ، دربرگيرد . نيازي به استفاده از new
وجود ندارد . بعنوان مثال ، براي ذخيره نمودن تعداد روزهاي هر ماه ، كد
بعدي يك آرايه مقدار دهي اوليه شده از اعداد صحيح را بوجود مي آورد :

+ // An improved version of the previous program.
+ class AutoArray {
+ public static void main(String args[] ){
+ int month_days[ ] = { 31/ 28/ 31/ 30/ 31/ 30/ 31/ 31/ 30/ 31/ 30/ 31 };
+ System.out.println("April has " + month_days[3] + " days .");
+ }
+ }

وقتي اين برنامه را اجرا كنيد ، همان خروجي برنامه قبلي را خواهيد ديد .

جاوا بشدت كنترل مي كند تا مطمئن شود كه بطور تصادفي تلاشي براي ذخيره نمودن
يا ارجاع مقاديري خارج از دامنه آرايه انجام ندهيد . سيستم حين اجراي جاوا
كنترل مي كند كه كليه نمايه هاي آرايه ها در دامنه صحيح قرار داشته باشند . ( از
اين نظر جاوا كاملا"با Cاو C++و متفاوت است كه هيچ كنترل محدوده اي در حين اجرا
انجام نمي دهند . ) بعنوان مثال ، سيستم حين اجرا ، مقدار هر يك از نمايه ها به month-days را كنترل مي كند تا مطمئن شود كه بين ارقام 0 و 11 داخل قرار داشته
باشند . اگر تلاش كنيد تا به اجزائ خارج از دامنه آرايه ( اعداد منفي يا اعدادي
بزرگتر از طول آرايه ) دسترسي يابيد، يك خطاي حين اجرا (run-time error) توليد
خواهد شد.در زير يك مثال پيچيده تر مشاهده مي كنيد كه از يك آرايه يك بعدي استفاده
مي كند . اين برنامه ميانگين يك مجموعه از ارقام را بدست مي آورد .

+ // Average an array of values.
+ class Average {
+ public static void main(String args[ ] ){
+ double nums[ ] = {10.1/ 11.2/ 12.3/ 13.4/ 14.5};
+ double result = 0;
+ int i;
+
+ for(i=0; i<5; i++)
+ result = result + nums[i];
+
+ System.out.println("Average is " + result / 5);
+ }
+ }

آرايه هاي چند بعدي

در جاوا آرايه هاي چند بعدي در واقع آرايه اي از آرايه ها هستند . اين قضيه
همانطوريكه انتظار داريد ظاهر و عملكردي مشابه آرايه هاي چندبعدي منظم (regular)
دارد . اما خواهيد ديد كه تاوتهاي ظريفي هم وجود دارند . براي اعلان يك متغير
آرايه چند بعدي ، با استفاده از مجموعه ديگري از كروشه ها هر يك از نمايه هاي
اضافي را مشخص مي كنيد. بعنوان مثال ، عبارت زيرر يك متغير آرايه دو بعدي بنام twoD را اعلان مي كند .

+ int twoD[ ][ ] = new int[4][5];

اين عبارت يك آرايه 4در 5ر را تخصيص داده و آن را به twoD نسبت مي دهد . از
نظر داخلي اين ماتريس بعنوان يك آرايه از آرايه نوع int پياده سازي خواهد شد .

بطور فرضي ، اين آرايه را مي توان بصورت شكل زير نمايش داد .

Right index determines column.
|| || || || ||
\/ \/ \/ \/ \/
|
| [0][4] | [0][3] | [0][2] | [0][1] | [0][0] >
|
| |
| [1][4] | [1][3] | [1][2] | [1][1] | [1][0] >
Left index
determines |
| [2][4] | [2][3] | [2][2] | [2][1] | [2][0] .> row
|
| |
| [3][4] | [3][3] | [3][2] | [3][1] | [3][0] >
Given :int twoD[][] = new int [4][5];

برنامه بعدي هر عضو آرايه را از چپ به راست ، و از بالا به پايين شماره داده
و سپس مقادير آنها را نمايش مي دهد :

+ // Demonstrate a two-dimensional array.
+ class TwoDArray {
+ public static void main(String args[] ){
+ int twoD[][] = new int[4][5];
+ int i/ j/ k = 0;
+
+ for(i=0; i<4; i++)
+ for(j=0; j<5; j++ ){
+ twoD[i][j] = k;
+ k++;
+
+ }
+
+ for(i=0; i<4; i++ ){
+ for(j=0; j<5; j++)
+ System.out.print(twoD[i][j] + " ");
+ System.out.println)(;
+ }
+ }
+ }

خروجي اين برنامه بقرار زير خواهد بود : 0 1 2 3 4

5 6 7 8 9
10 11 12 13 14
15 16 17 18 19

هنگام تخصيص حافظه به يك آرايه چند بعدي ، كافي است فقط حافظه براي اولين
بعد را مشخص نماييد . مي توانيد ابعاد ديگر را جداگانه تخصيص دهيد . بعنوان
مثال ، كد زير حافظه اولين بعد twoD را هنگام اعلان آن تخصيص مي دهد . اين كد
حافظه دومين بعد را بصورت دستي اختصاص مي دهد .

+ int twoD[ ][ ] = new int[4][ ];
+ twoD[0] = new int[5];
+ twoD[1] = new int[5];
+ twoD[2] = new int[5];
+ twoD[3] = new int[5];

اگرچه در اين حالت اختصاص انفرادي حافظه به دومين بعد هيچ مزيتي ندارد، اما
احتمال چنين مزيتهايي وجود دارد . بعنوان مثال ، هنگاميكه ابعاد را بصورت دستي
اختصاص مي دهيد ، نيازي نيست كه همان ارقام براي اجزائ هر بعد را تخصيص دهيد .
همانطوريكه قبلا" گفتيم ، از آنجاييكه آرايه هاي چند بعدي واقعا" آرايه اي از
آرايه ها هستند ، طول هر يك از آرايه ها تحت كنترل شما قرار مي گيرند . بعنوان
مثال ، برنامه بعدي يك آرايه دو بعدي ايجاد مي كند كه در آن اندازه هاي دومين
بعد نامساوي هستند .

+ // Manually allocate differing size second dimension.
+ class TwoDAgain {
+ public static void main(String args[ ] ){
+
+
+ int twoD[ ][ ] = new int[4][ ];
+ twoD[0] = new int[1];
+ twoD[1] = new int[2];
+ twoD[2] = new int[3];
+ twoD[3] = new int[4];
+
+ int i/ j/ k = 0;
+
+ for(i=0; i<4; i++)
+ for(j=0; j
+ towD[i][j] = k;
+ k++;
+ }
+
+ for(i=0; i<4; i++ ){
+ for(j=0; j
+ System.out.print(twoD[i][j] + " ");
+ System.out.println)(;
+ }
+ }
+ }

خروجي اين برنامه بقرار زير مي باشد : 0

1 2
3 4 5
6 7 8 9

آرايه اي كه توسط اين برنامه ايجاد مي شود ، بصورت زير خواهد بود :

| [0][0] |

| [1][0] | [1][1] |

| [2][0] | [2][1] | [2][2] |

| [3][0] | [3][1] | [3][2] | [3][3] |

از آرايه هاي چند بعدي ناجور ( يا نامنظم ) در اكثر برنامه ها استفاده نميشود
زيرا برخلاف آنچه مردم هنگام مواجه شدن با يك آرايه چند بعدي انتظار دارند
رفتار مي كنند . اما اين آرايه ها در برخي شرايط بسيار كارا هستند . بعنوان
مثال ، اگر نياز به يك آرايه دو بعدي خيلي بزرگ داريد كه داراي تجمع پراكنده
باشد ( يعني كه يكي و نه همه اجزائ آن مورد استفاده قرار مي گيرند ) ، آنگاه
آرايه بي قاعده احتمالا" يك راه حل كامل خواهد بود .

اين امكان وجود دارد كه آرايه هاي چند بعدي را مقدار دهي اوليه نمود . براي
اينكار ، فقط كافي است هر يك از مقدار ده اوليه ابعاد را داخل مجموعه ابروهاي
ختص خودش قرار دهيد . برنامه بعدي يك ماتريس ايجاد مي كند كه هر يك از اجزائ
آن شامل حاصلضرب نمايه هاي سطرها و ستونها هستند. همچنين دقت نماييد كه مي توان از عبارات همچون مقادير لفظي داخل مقدار ده اوليه آرايه استفاده نمود .

+ // Initialize a two-dimensional array.
+ class Matrix {
+ public static void main(String args[] ){
+ double m[][] = {
+ { 0*0/ 1*0/ 2*0/ 3*0 };
+ { 0*1/ 1*1/ 2*1/ 3*1 };
+ { 0*2/ 1*2/ 2*2/ 3*2 };
+ { 0*3/ 1*3/ 2*3/ 3*3 };
+ };
+ int i/ j;
+
+ for(i=0; i<4; i++ ){
+ for(j=0 j<4; j++)
+ System.out.print(m[i][j] + " ");
+ System.out.println)(;
+ }
+ }
+ }

پس از اجراي اين برنامه ، خروجي آن بقرار زير خواهد بود : 0 0 0 0

0 1 2 3
0 2 4 6
0 3 6 9

همانطوريكه مشاهده مي كنيد، هر سطر در آرايه همانگونه كه در فهرستهاي مقدار
دهي اوليه مشخص شده ، مقدار دهي اوليه شده است .

مثالهاي بيشتري درباره استفاده از آرايه چند بعدي بررسي مي كنيم . برنامه
بعدي يك آرايه سه بعدي 3x4x5 ايجاد مي كند . سپس حاصل نمايه هاي مربوطه را براي هر عضو بارگذاري مي كند . در نهايت اين حاصل ها را نمايش خواهد داد :

+ // Demonstrate a three-dimensional array.
+ class threeDDatrix {
+ public static void main(String args[] ){
+ int threeD[ ][ ][ ] = new int[3][4][5];
+ int i/ j/ k;
+ for(i=0; i<3; i++)
+ for(j=0; j<4; j++)
+ for(k=0; k<5; k++)
+ threeD[i][j][k] = i * j * k;
+
+ for(i=0; i<3; i++ ){
+ for(j=0; j<4; j++ ){
+ for(k=0; k<5; k++)
+ System.out.print(threeD[i][j][k] + " ");
+ System.out.println)(;
+ }
+ System.out.println)(;
+ }
+ }
+ }

خروجي اين برنامه بقرار زير خواهد بود : 0 0 0 0 0

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12

0 0 0 0 0
0 2 4 6 8
0 4 8 12 16
0 6 12 18 24

دستور زبان جايگزين اعلان آرايه

يك شكل دوم براي اعلان يك آرايه بصورت زير وجود دارد :

type [ ] var-name;

نام متغير نوع

در اينجا كروشه ها بعداز مشخص كننده نوع مي آيند نه بعداز نام متغير آرايه .
بعنوان مثال دو شكل اعلان زير يكسان عمل مي كنند :

+ int a1[ ] = new int[3];
+ int[ ] a2 = new int[3];

دو شكل اعلان زير هم يكسان عمل مي كنند :

+ char twod1[ ][ ] = n

آرايه هاي دوباره ملاقات شده Arrays Revisited

آرايه ها بعنوان اشيائ پياده سازي مي شوند . بهمين دليل ، يك خصلت ويژه وجود
دارد كه مي توانيد از مزيت آن استفاده نماييد . بطور اخص ، اندازه يك آرايه
يعني تعداد اعضايي كه يك آرايه ميتواند نگهداري نمايد را مي توان در متغير
نمونه length پيدا نمود . كليه آرايه ها اين متغير را دارند، و اين متغير هميشه
اندازه آرايه را نگهداري مي كند. در اينجا برنامه اي وجود دارد كه اين خاصيت را
نشان مي دهد :

+ // This program demonstrates the length array member.
+ class Length {
+ public static void main(String args[ ] ){
+ int a1[ ] = new int [10];
+ int a2[ ] = {3/ 5/ 7/ 1/ 8/ 99/ 44/- 10};
+ int a3[ ] = {4/ 3/ 2/ 1};
+
+ System.out.println("length of a1 is " + a1.length);
+ System.out.println("length of a2 is " + a2.length);
+ System.out.println("length of a3 is " + a3.length);

خروجي اين برنامه بقرار زير مي باشد :

length of a1 is 10
length of a2 is 8
length of a3 is 4

همانطوريكه مي بينيد ، اندازه هر يك از آرايه ها بنمايش درآمده است . بياد
بسپاريد كه مقدار length كاري با تعداد اعضايي كه واقعا" مورد استفاده قرار
گرفته اند، نخواهد داشت . اين مقدار فقط منعكس كننده تعداد اعضايي است كه آرايه
براي نگهداري آن طراحي شده است .

در بسياري از شرايط مي توانيد عضو length را در معرض كاربردهاي مناسب قرار
دهيد . بعنوان مثال ، يك روايت توسعه يافته از كلاس stack را در اينجا مشاهده
مي كنيد. احتمالا" بياد داريد كه روايتهاي اوليه اين كلاس هميشه يك پشته ده عضوي
ايجاد مي كرد . روايت بعدي همين برنامه ، به شما امكان ايجاد پشته هايي به هر
اندازه دلخواه را مي دهد . از مقدار stck.length براي ممانعت از وقوع سرريزي
پشته استفاده شده است .

+ // Improved Stack class that uses the length array member.
+ class Stack {
+ private int stck[ ];
+ private int tos;
+
+ // allocate and initialize stack
+ Stack(int size ){
+ stck = new int[size];
+ tos =- 1;
+ }
+
+ // Push an item onto the stack
+ void push(int item ){
+ if(tos==stck.length-1 )// use length member
+ System.out.println("Stack is full.");
+ else
+ stck[++tos] = item;
+ }
+
+ // Pop an item from the stack
+ int pop )({
+ if(tos < 0 ){
+ System.out.println("Stack underflow.");
+ return 0;
+ }
+ else
+ return stck[tos--];
+ }
+ }
+
+ class TestStack2 {
+ public static void main(String args[ ] ){
+ Stack mystack1 = new Stack(5);
+ Stack mystack2 = new Stack(8);
+
+ // push some numbers onto the stack
+ for(int i=0; i<5; i++ )mystack1.push(i);
+ for(int i=0; i<5; i++ )mystack2.push(i);
+
+ // pop those numbers off the stack
+ System.out.println("Stack in mystack1:");
+ for(int i=0; i<5; i++)
+ System.out.println(mystack1.pop))(;
+
+ System.out.println("Stack in mystack2:");
+ for(int i=0; i<8; i++)
+ System.out.println(mystack2.pop))(;
+ }
+ }

دقت كنيد كه برنامه فوق دو پشته ايجاد مي كند : يكي با عمق پنج عضو ، و
ديگري با عمق هشت عضو . همانطوريكه مي بينيد ، اين حقيقت كه آرايه ها اطلاعات length خودشان را نگهداري مي كنند ، ايجاد پشته هايي به اندازه دلخواه را آسان می کند.

ارتقائ خودكار انواع در عبارات Automatic Type promotion in Expressions

علاوه بر انتسابها ، در شرايط ديگري هم تبديلات خاص انواع ممكن است اتفاق
بيفتد : در عبارات . حالتي را در نظر بگيريد كه در يك عبارت ، ميزان دقت لازم
براي يك مقدار واسطه گاهي از دامنه هر يك از عملوندهاي خود تجاوز مي نمايد .
بعنوان مثال ، عبارت زير را در نظر بگيريد :

+ byte a = 40;
+ byte b = 50;
+ byte c = 100;
+ int d = a * b / c;

نتيجه قلم واسطه a*b از دامنه هر يك از عملوندهاي byte خود تجاوز مي نمايد.
براي اداره اين نوع مشكلات ، جاوا بطور خودكار هر يك از عملوندهاي byteو shortو
را هنگام ارزشيابي يك عبارت به int ارتقائ مي دهد . اين بدان معني است كه زير
عبارت a*b با استفاده از اعداد صحيح و نه byte اجرا مي شود. بنابراين عدد 2000
نتيجه عبارت واسطه 50*40 مجاز است ، اگر چه aو bو هر دو بعنوان نوع byte مشخص شده اند .همانقدر كه ارتقائ خودكار مفيداست ، مي تواند سبب بروز خطاهاي زمان كامپايل (compile-time) گردد . بعنوان مثال ، اين كد بظاهر صحيح يك مشكل را بوجود مي آورد .

+ byte b = 50;
+ b = b * 2; // Error! Cannot assign an int to a byte!

اين كد تلاش مي كند تا 50*2 را كه يك مقدار كاملا" معتبر byte است به يك
متغير byte ذخيره كند . اما چون عملوندها بطور خودكار هنگام ارزشيابي عبارت به int
ارتقائ يافته اند ، جواب حاصله نيز به int ارتقائ يافته است . بنابراين
جواب عبارت اكنون از نوع int است كه بدون استفاده از تبديل cast امكان نسبت
دادن آن به يك byte وجود ندارد. اين قضيه صادق است ، درست مثل همين حالت ، حتي اگر مقدار نسبت داده شده همچنان با نوع هدف سازگاري داشته باشد .
در شرايطي كه پيامدهاي سر ريز (overflow) را درك مي كنيد، بايد از يك تبديل
صريح cast نظير مورد زير استفاده نماييد .

+ byte b = 50;
+ b =( byte( )b * 2);

كه مقدار صحيح عدد 100 را بدست مي آورد
قوانين ارتقائ انواع علاوه بر ارتقائ byteو short وبه int جاوا چندين قانون ارتقائ انواع را تعريف كرده كه قابل استفاده در عبارات مي باشند . اين قوانين بصورت زير هستند

اول
اينكه كليه مقادير  byteو shortوبه int ارتقائ مي يابند ، همانگونه كه قبلا"
توضيح داده ايم . آنگاه اگر يك عملوند ، long باشد ، كل عبارت به long ارتقائ
مي يابد . اگر يك عملوند float باشد ، كل عبارت به float ارتقائ مي يابد . اگر
هر يك از عملوندها يك  double باشند ، حاصل آنها double خواهد شد 
برنامه بعدي نشان مي دهد كه چگونه هر يك از مقادير در عبارت ارتقائ مي يابد
تا با آرگومان دوم به هر يك از عملگرهاي دودويي ، مطابقت يابد

+ class Promote {
+ public static void main(String args[ ] ){
+ byte b = 42;
+ char c = 'a';
+ short s = 1024;
+ int i = 50000;
+ float f = 5.67f;
+ double d =. 1234;
+ double result =( f * b )+( i / c( - )d * s);
+ System.out.println((f * b )+ " + " +( i / c )+ " - " +( d * s));
+ System.out.println("result = " + result);
+ }
+ }

اجازه دهيد به ارتقائ انواع كه در اين خط از برنامه اتفاق افتاده ، دقيقتر
نگاه كنيم :

+ double result =( f * b )+( i / c( - )d * s);

در اولين زير عبارت يعني f*b، b، به يك نوع float ارتقائ يافته و جواب زير
عبارت نيز از نوع float خواهد بود . در زير عبارت بعدي يعني i/c، c، به يك نوع int
ارتقائ يافته و جواب آن زير عبارت نيز از نوع int خواهد بود . سپس در زير
عبارت d*s ، مقدار S به نوع double ارتقائ يافته و نوع زير عبارت نيز double
خواهد بود . در نهايت اين سه مقدار واسطه ، float، int،، double، در نظر گرفته
مي شوند . خروجي float بعلاوه int از نوع float خواهد شد . آنگاه اين نتيجه
منهاي آخرين double به نوع double ارتقائ يافته ، كه نوع مربوط به جواب نهايي

نوشته شده توسط پيام در یکشنبه 28 آبان1385

لينك ثابت