آموزش برنامه نویسی جاوا (بخش بیستم: سازنده و مخرب در جاوا)

استاندارد

سازنده یا Constructor

در هنگام ساخت یک شی از یک نمونه کلاس، می توان متغیر های یک شی را مقداردهی اولیه کرد.

تابع سازنده (Constructor) تابعی است که در حین نمونه گرفتن از یک کلاس یک مرتبه اجرا می شود. زیرا بسیار ساده تر و دقیق تر آن است که کلیه تنظیمات در زمان ایجاد اولیه شی انجام شود.

از این تابع بیشتر برای مقداردهی کردن متغییر ها و فیلدهای یک کلاس در هنگام ساخت یک شی، استفاده می شود.

معمولا بعضی از اعضای کلاس قبل از استفاده نیاز به مقداردهی دارندکه همان طور که گفته شد، اين عمل توسط سازنده (constractor) انجام می گیرد که به شیء اين امکان را می دهد که هنگام ايجاد مقداردهی شود.

سازنده تابعی است هم اسم کلاس که وقتی یک نمونه از کلاس گرفته می شود اتوماتیک فراخوانی می شود.

سازنده نام همان کلاسی را که در آن قرار گرفته اختیار نموده و از نظر صرف و نحو مشابه یک روش است.

وقتی یکبار سازنده ای را تعریف نمایید، بطور خودکار بلافاصله پس از ایجاد یک شی و قبل از اینکه عملگر new تکمیل شود، فراخوانی خواهد شد.

سازندگان کمی بنظر عجیب می آیند زیرا فاقد نوع برگشتی و حتی فاقد void هستند.

در زبان های شی گرا مثل سی شارپ و جاوا چون همه چیز بر پایه شی گرایی و کلاس هست شما وقتی یک کلاس می سازید میتونید با استفاده از سازنده ها متغیر ها رو مقدار دهی کنید.

وقتی شما یکی شی از کلاس مورد نظرتون می سازین(new می کنید!) کامپایلر به سراغ سازنده ی شما می رود که اگه نباشه سازنده ی پیش فرض فراخونی میشه که بدون پارامتره و شما میتونید از سازنده استفاده کرده و اونطوری که دلتون می خواد متغیر هاتون رو مقدار دهی کنید و از همون اول برای شی ساخته شدتون بفرستید .

تابع سازنده می تواند دارای پارامتر باشد بنابراين زمان ايجاد شیء می توان به متغيرهای عضو مقادير اوليه داد. برای ارسال آرگومان به تابع سازنده بايد هنگام تعريف شیء مقدار آرگومان بعد از نام شیء درون پرانتز قرار گيرد.

یک کلاس می تواند دارای چند سازنده با پارامترهای مختلف باشد. بهتر است همیشه حداقل یک سازنده حتی اگر خالی باشد ساخته شود.

برای تابع سازنده مقدار برگشتی ذکر نمی شود (حتی Void).

برای درک بیشتر به مثال زیر توجه نمایید:

public class JavaApplication1 {

static class myClass{
    private int a;
    private char b;
// تابع سازنده
    myClass(){
    this.a=1; // مقدار دهی به متغیر در تابع سازنده
    this.b='a'; // مقدار دهی به متغیر در تابع سازنده
    }
}    
    public static void main(String[] args) {
        myClass newObject = new myClass(); // ایجاد شی
        System.out.print(newObject.a);
        System.out.print(newObject.b);
    } 
}

خروجی کد بالا، 1a می باشد. زیرا شی به هنگام ساخت توسط سازنده ی خودش مقدار دهی می شود.

همچنین سازنده می تواند مقادیری را نیز به صورت پارامتر ورودی در هنگام ساخت شی ، از شی بگیرد.

برای این کار کافیست، در تابع سازنده، پارامتر ورودی در داخل پرانتز، بنویسیم. سپس در هنگام ساخت شی، مقادیر ورودی به آن پارامتر ها را بدهیم تا سازنده بتواند مقدار دهی متغیرهای شی را انجام دهد.

مثال زیر، چگونگی ساخت سازنده با استفاده از پارامتر ورودی را به شما نشان می دهد:

public class JavaApplication1 {

static class myClass{
    int a;
    char b;
// ساخت تابع سازنده
    myClass(int m, char n){
        a = m;
        b = n;
    }
}    
    public static void main(String[] args) {
        myClass newObject = new myClass(5,'m'); // مقدار دهی اولیه فیلدهای شی با استفاده از سازنده
        System.out.print(newObject.a); // خروجی مقدار 5 را نشان می دهد
        System.out.print(newObject.b); را نشان می دهد m خروجی مقدار

    } 
}

constructor مشخص می کند که هنگام ایجاد شیئی از نوع کلاس ، چه اتفاقی رخ می دهد . constructor های خاص خودشان را در تعریف کلاس مشخص می کنند. اما ، اگر constructor به طور صریح مشخص نشود ، در آن صورت جاوا آن را به طور خودکار تامین می کند. در خصوص کلاس ذکر شده در بخش قبل نیز، همین طور است.

مخرب یا Destructor

تابع مخرب کلاس (destructor) کم و بیش عکس سازنده عمل می کند. یک مخرب وقتی فراخوانی می شود که یک شی از بین می رود.

در ++C یک مخرب مشابه سازنده ساخته می شود فقط قبل از اسم آن علامت مد (~)قرار می گیرد.

تابع مخرب اتوماتیک وقتی متغیر شیء از حوزه دسترسی خارج می شود (برای متغیرهای سراسری وقتی از تابع اصلی خارج می شود و برای متغیر محلی هنگام خروج از بلاک تابع) فراخوانی می شود.

مشابه سازنده ها تابع مخرب نيز نوع برگشتی ندارد.

توابع مخرب یا destructor کاربرد زیادی در مدیریت حافظه برنامه های نوشته شده در ++C دارند.

عموما در مورد کلاسهای طراحی شده، با استفاده از این متد به آزاد سازی حافظه پرداخته میشود.

اما در زبانی مانند جاوا که مدیریت حافظه در اختیار ماشین مجازی میباشد، استفاده از این تابع چندان منطقی نیست، با این حال امکان پیاده سازی آن با استفاده از تابع finalize فراهم شده است.

برای انجام این کار در کلاس مربوطه یک تابع به نام finalize پیاده سازی گشته و سیستم Garbage Collector در زمان اتمام استفاده از کلاس و آزاد سازی تمام ارجاعات آن، تابه finalize را فراخوانی مینماید.

از آنجا که زمان عملکرد Grabage Collector نا مشخص است، با استفاده از دستورات gc و runFinalization میتوان ماشین مجازی را ملزم به آزاد سازی حافظه (جمع آوری زباله ها از حافظه) نمود.

مثال زیر نحوه انجام این کار را نشان میدهد:

import java.util.ArrayList;
 
public class Samples  {
    public static void main(String[] args){
        long mem = Runtime.getRuntime().freeMemory();
 
        SampleClass c1 = new SampleClass();
        SampleClass c2 = new SampleClass();
        SampleClass c3 = new SampleClass();
 
        System.out.println(String.format("Used memory: %d KB", (mem - Runtime.getRuntime().freeMemory())/1024));
        mem = Runtime.getRuntime().freeMemory();
 
        c1 = c2 = c3 = null;
 
        System.gc();
        System.runFinalization();
 
        System.out.println(String.format("Released memory: %d KB", (Runtime.getRuntime().freeMemory() - mem)/1024));
    }
}
 
class SampleClass {
    private ArrayList<Double> _obj;
 
    public SampleClass() {
        _obj = new ArrayList<Double>();
        for (int i=0; i<1000000; i++)
            _obj.add(Math.random());
 
        System.out.println("Created");
    }
 
    public void finalize() {
        _obj.clear();
        _obj = null;
        System.out.println("Finalized");
    }
 
}

آموزش برنامه نویسی جاوا (بخش دهم: آرایه های دو بعدی و چند بعدی)

استاندارد

آرایه هایی که تاکنون بررسی میکردیم، فقط یک بعدی بودند. مثلا اگر آرایه ای که در بخش هشتم بررسی کردیم را مشاهده کنید، می بینید که به ازای هر سطر از آن جدول، یک مقدار وجود دارد. حال فرض کنید، بتوانیم در هر سطر یک آرایه یک بعدی دیگر قرار دهیم. پس اگر یک آرایه داشته باشیم که 5 سطر داشته باشد ( 5 خانه) و در هر خانه یک آرایه یک بعدی دیگر مثلا 6 سطر (6 خانه)، در واقع به تعداد 5*6=30 خانه آرایه داریم.

به این گونه آرایه ها، آرایه دو بعدی می گوییم. برای درک بهتر آرایه دو بعدی به شکل زیر توجه نمایید:

در شکل بالا، یک آرایه داریم که دارای 3 سطر و 4 ستون است. پس به تعداد 12 خانه، می توانیم مقدار بدهیم. مشاهده می کنید که مثلا خانه اول در سطر اول، با [0][0]a مشخص شده است. یا در سطر شماره 1 و ستون شماره 2 ، مکان آن خانه از آرایه با [2][1]a مشخص شده است.

در این جا این سوال پیش می آید که چگونه می توان آرایه دو بعدی را تعریف نمود. در مورد تعریف آرایه های یک بعدی، دیدیم که می توان آن ها را به صورت زیر تعریف نمود.

int[] OurArray = new int[تعداد خانه ها];

حال اگر بخواهیم یک آرایه دو بعدی را تعریف نماییم، به صورت زیر عمل می کنیم:

int[][] OurArray = new int[تعداد خانه های بعد دوم][تعداد خانه های بعد اول];

در مثال بالا مشاهده می کنید که پس از تعریف نوع متغیر، از دو عدد [] استفاده نمودیم. این دو عدد مشخص می کند که آرایه ما دو بعدی است. در قسمت بعدی نام آرایه را مشخص می کنیم. سپس بعد از تساوی در سمت راست، عملگر new و دوباره نوع متغیر، و تعداد خانه های بعد اول و سپس تعداد خانه های بعد دوم را در داخل [] معرفی می کنیم.

پس در کد زیر، یک آرایه دو بعدی که در بعد اول، 5 خانه و در بعد دوم 6 خانه وجود دارد داریم.

int[][] OurArray = new int[5][6];

به زبانی دیگر 5 سطر و 6 ستون داریم. که به طور کلی 30 عدد خانه را می توان برای آرایه OurArray متصور شد.

استفاده از آرایه های دو بعدی و بعضا چندبعدی، کار ما را بسیار آسان می کنند. مثلا فرض کنید که یک آرایه دو بعدی از نوع رشته تعریف کرده ایم. در بعد اول، اسامی افرادی که در قسمت اداری کار می کنند نوشته می شود. در بعد دوم اسامی افرادی که در قسمت مالی کار می کنند نوشته می شود و در بعد سوم اسامی افرادی که در قسمت خدمات ، و در بعد چهارم اسامی مدیران نوشته می شود. یعنی با چیزی شبیه به جدول زیر مواجه هستیم:

ستون سوم ستون دوم ستون اول
فدایی میرزایی طاهری سطر اول (اداری)
ذبیحی کریمی موسوی سطر دوم (مالی)
قلزم رجبی اصغری سطر سوم (خدماتی)
قیصری برومند فاطمی سطر چهارم (مدیران)

حال اگر بخواهیم اسامی افراد بالا را در یک آرایه دوبعدی، مقداردهی نماییم به صورت زیر عمل می کنیم:

ابتدا یک آرایه دو بعدی که در بعد اول دارای 4 خانه و در بعد دوم 3 خانه دارد ، از نوع رشته (String) معرفی می کنیم.

String[][] Edare = new String [4][3];

اگر بخواهیم اسامی را درون آرایه بالا معرفی کنیم یک شیوه به صورت زیر است:

Edare[0][0]="طاهری";
Edare[0][1]="میرزایی";
Edare[0][2]="فدایی";

Edare[1][0]="موسوی";
Edare[1][1]="کریمی";
Edare[1][2]="ذبیحی";

Edare[2][0]="اصغری";
Edare[2][1]="رجبی";
Edare[2][2]="قلزم";

Edare[3][0]="فاطمی";
Edare[3][1]="برومند";
Edare[3][2]="قیصری";

مشاهده می کنید که ابتدا خانه های سطر اول، که در بعد اول از آرایه یعنی خانه شماره 0، را مقدار دهی کردیم. سپس خانه های سطر دوم و …

شیوه دیگر مقدار دهی چیزی شبیه به شیوه مقدار دهی دومی که در بخش آرایه یک بعدی تعریف نمودیم، است.  مثلا فرض کنید بخواهیم در سطر اول اعداد 1 تا 3 و در سطر دوم اعداد 4 تا 6 را معرفی کنیم.

به صورت زیر عمل می کنیم:

int [][] Array2bodi = {{1,2,3},{4,5,6}};

دقت کنید که یک کروشه کلی در قسمت سمت راست وجود دارد که در داخل آن دو کروشه دیگر که با ویرگول، از هم جدا شده اند نیز وجود دارد. هر کدام از آن کروشه ها دارای سه مقدار هستند. پس در بعد اول از آرایه بالا، 2 خانه و در بعد دوم از آرایه بالا 3 خانه وجود دارند که با اعداد 1 تا 3 و 4 تا 6 مقداری دهی شده است.

آرایه دو بعدی و حلقه For

اگر بخواهیم آرایه بالا را در خروجی چاپ کنیم به چه صورت عمل می کنیم؟

می توان با یک حلقه For تو در تو این کار را به سادگی انجام داد. از آنجاییکه آرایه بالا دو بعدی است، پس یک حلقه For تو در تو دوتایی لازم داریم.

حلقه اول برای سطر ها (بعد اول) و حلقه دوم برای ستون ها (بعد دوم) به کار می رود. سپس در قسمتی که می خواهیم آرایه دو بعدی ما چاپ شود، در خانه اول از متغیر شمارنده ای که برای حلقه اول استفاده کردیم، استفاده می کنیم. و در خانه دوم از متغیر شمارنده ای که برای حلقه دوم استفاده کردیم، استفاده می کنیم.

int [][] Array2bodi = {{1,2,3},{4,5,6}};

	for(int i=0;i<2;i++)
		for(int j=0;j<3;j++)
			System.out.print(Array2bodi[i][j]);

نتیجه خروجی کد بالا به شرح زیر می باشد.

123456

آرایه سه بعدی و بالاتر

اگر کار با آرایه دو بعدی را به خوبی یاد گرفته باشید، می توانید آرایه سه بعدی و بالاتر را نیز به آسانی یاد بگیرید.

یک آرایه سه بعدی به صورت زیر تعریف می شود:

int [][][] Array3bodi = new int [تعداد خانه های بعد سوم][تعداد خانه های بعد دوم][تعداد خانه های بعد اول];

برای محاسبه تعداد کل خانه ها کافی است که تعداد خانه های هر بعد را در هم ضرب کنید.

مثلا آرایه سه بعدی زیر را در نظر بگیرید.

int [][][] Array3bodi = new int [5][4][3];

آرایه بالا، در واقع دارای 5*4*3 خانه یعنی 60 خانه می باشد.

اگر بخواهیم یک آرایه چهار بعدی تعریف کنیم نیز می توان یک بعد اضافی تعریف نمود.

برای مثال آرایه زیر یک آرایه چهار بعدی است که در بعد اول دارای 5 خانه، در بعد دوم 4 خانه و در بعد سوم ، 3 خانه، در بعد چهارم 6  خانه دارد.

int [][][][] Array4bodi = new int [5][4][3][6];

به همین ترتیب می توانید آرایه با ابعاد بالاتر تعریف نمایید که معمولا کاربردی ندارند. و شما در برنامه های خود به ندرت پیش می آید که بخواهید از آرایه با ابعاد بالاتر از سه بعد، استفاده کنید.

آموزش برنامه نویسی جاوا (بخش نهم: کار با آرایه ها در جاوا)

استاندارد

آرایه ها و حلقه در جاوا

در بخش قبلی مشاهده کردید که برای اختصاص دادن یک مقدار به آرایه، باید شماره خانه آن آرایه ای را که می خواهید به آن مقدار دهید را به عنوان مشخصه ی اندیس آرایه تعریف کنید. سپس مقداری که می خواهید را به آن خانه از آرایه بدهید. راه دیگر تعریف مقادیر برای آرایه، استفاده از کروشه بود.

ولی اگر مقادیر، زیاد باشند باید چی کار کنیم؟ اگر اعدادی که می خواهیم به یک آرایه اختصاص دهیم زیاد باشند، استفاده از روش های قبلی کاری سخت است.

به عنوان مثال یک برنامه ی قرعه کشی را در نظر بگیرید که باید اعداد 1 تا 30 را به موقعیت های یک array اختصاص دهد. به جای تایپ یک لیست طولانی از موقعیت ها و مقادیر array ، می توانید از یک loop استفاده کنید. در اینجا کدی را مشاهده می کنید که این کار را انجام می دهد:

public class Main {
	public static void main(String[] args) {

			int[] OurArray;
			OurArray = new int[30];
			for(int i=0;i<OurArray.length;i++){
				OurArray[i]= i+1;
				System.out.print(OurArray[i]);		
			}
	}
}

اگر دقت کنید متوجه می شوید که در شرط for ، این حلقه تا مقدار OurArray.length می چرخد. یعنی OurArray.length در واقع طول یا تعداد خانه های آرایه ما را مشخص می کند.

Length یک ویژگی از آبجکت های array می باشد که می توانید برای به دست آوردن اندازه ی array از آن استفاده کنید ( تعداد موقعیت هایی که دارد). بنابراین، زمانی که مقدار در متغیر i کمتر از اندازه ی array می باشد، این loop به چرخش متداول خود ادامه خواهد داد.

 این کد باعث می شود که تمام 30 خانه ی آرایه ما با استفاده از حلقه پر شود. و شماره های 1 تا 30 به آن داده می شود.

بدیهی است که اگر می خواستیم شماره های دیگری می توانستیم به آن بدهیم. ولی اگر شماره هایی که در یک آرایه پر می شود از الگوی خاصی پیروی نکند، مجبوریم همانند بخش قبلی آن ها را دستی پر کنیم.

مرتب سازی آرایه ها در جاوا

متودهای داخلی دیگر جاوا به شما اجازه می دهند تا array های خود را مرتب سازید. برای استفاده از متود مرتب سازی array ها، ابتدا نیاز به مراجعه به یک کتابخانه ی جاوا به نام Arrays دارید. شما این کار را با عبارت import انجام می دهید.

عبارت import زیر را اضافه کنید (بالای کلاس Main):

import java.util.Arrays;

فرض کنیم کد جاوای ما به صورت زیر باشد:

import java.util.Arrays;

public class Main {
	public static void main(String[] args) {

			int[] OurArray;
			OurArray = new int[7];
			OurArray[0]=5;
			OurArray[1]=3;
			OurArray[2]=9;
			OurArray[3]=8;
			OurArray[4]=7;
			OurArray[5]=1;
			OurArray[6]=2;

	}
}

آرایه OurArray با اعداد بالا پر شده است که اگر طبق کد زیر خروجی Print از آن بگیریم

for(int i=0;i<OurArray.length;i++){
    System.out.print(OurArray[i]);
			}

خروجی زیر را مشاهده می کنیم:

5398712

اعداد بالا خانه های پر شده ی آرایه را به ما نشان می دهند.

کد زیر که از همان کتابخانه ای که آن را Import کرده بودیم، آمده است، آرایه ما را مرتب می کند.

Arrays.sort(OurArray);

حال اگر از آرایه خروجی بگیرید، مشاهده می کنید که آرایه ما به ترتیب زیر پر شده است:

1235789

آموزش برنامه نویسی جاوا (بخش هشتم: آرایه ها در جاوا)

استاندارد

در ابتدا به این سوال پاسخ می دهیم که یک array چیست؟

تاکنون با متغیرهایی کار کردید که فقط یک مقدار را در خود حفظ می کنند. متغیرهای صحیح که تنظیم می کردیم، فقط یک عدد را حفظ می کنند و متغیرهای رشته نیز فقط یک رشته از متن را در خود دارند.

یک array (ردیف) ، روشی برای حفظ بیشتر از یک مقدار در یک زمان می باشد که در واقع شبیه لیستی از آیتم ها می باشد. یک array را می توان به عنوان ستون هایی در یک صفحه ی گسترده در نظر گرفت. در واقع آرایه یک سری خانه را که پشت سر هم قرار گرفته اند مشخص می کند. به آن ها فضا می دهد. این فضا بر اساس نوع متغیر آرایه شما است.

مثلا اگر یک آرایه از نوع int با 4 خانه مشخص کنید، ارایه 4 خانه به اندازه فضای int ، مشخص می کند. و پشت سر هم قرار می دهد. حال می توانید در این خانه ها مقدار هایی که می خواهید را بدهید.

می توانید تصوری که از آرایه داشته باشید به شکل زیر نیز باشد:

 

array value row
8 0
4 1
6 2
5 3
2 4

همان طور که در جدول بالا مشاهده می کند، آرایه برای هر ردیف، یک مقدار عددی دارد. هر ردیف با یک شماره عددی مشخص می شود که مقدار آن در ستون رو به روی آن نوشته شده است. در جدول بالا، مشاهده می کنید که ردیف ها از شماره 0 شروع شده و تا شماره 4 ادامه دارد.

حال بیایید آرایه ای که در جدول بالا مشاهده می کنید را به صورت کد جاوا بنویسیم. آرایه بالا عدد است پس ما هم یک متغیر عددی از نوع int اعلام می کنیم. ولی تنها تفاوتی که متغیر int ی که قبلا معرفی کردیم، وجود دارد اینست که یک جفت کروشه پس از int می نویسیم.

مثال:

int[] OurArray;

ولی آرایه جدولی ما در بالا، 4 سطر بیش تر ندارد. پس دستور بالا فقط به کامپایلر می گوید که ما قصد تنظیم یک array از نوع عدد صحیح (int) را داریم. این خط تعداد موقعیت هایی را که array باید حفظ کند، اعلام نمی کند. برای انجام کاری که گفته شد، باید یک array object جدید تنظیم کنیم. همانند چیزی که برای تعریف شی از یک نوع کلاس در بخش قبلی دیدیم.

برای مشخص کردن تعداد موقعیت های آرایه به ترتیب زیر عمل می کنیم:

OurArray = new int[5];

شما با نام array شروع کرده اید که با علامت تساوی دنبال می شود. پس از علامت تساوی به لغت کلیدی new و سپس مجددا نوع داده ی خود، نیاز دارید. پس از نوع داده یک جفت کروشه قرار می گیرد. بین کروشه ها نیاز به اندازه ی array دارید. اندازه در واقع تعداد موقعیت هایی است که array باید حفظ کند.

برای ساده تر و خلاصه تر نوشتن می توانید دو خط کد بالا را به صورت زیر نیز بنویسید:

int[] OurArray = new int[5];

عدد 5 معرف تعداد خانه های آرایه است. یعنی ما 5 خانه داریم که از شماره 0 تا 4 هستند. دقت نمایید که شماره 5 قابل استفاده نیست.

بنابراین ما به جاوا اعلام می کنیم که یک array را با 5 موقعیت در آن تنظیم کند. پس از اجرای این خط، جاوا مقادیر پیش فرض را برای array اختصاص خواهد داد.

از آنجایی که ما یک array مقدار صحیح تنظیم کرده ایم، مقادیر پیش فرض برای همه ی 5 موقعیت 0 خواهد بود.

حال سوالی که پیش می آید اینست که ستون دوم در جدول بالا که مربوط به مقادیر هر سطر آرایه است را چگونه معرفی کنیم؟

کد زیر باعث می شود که به سطر اول از آرایه OurArray مقدار 8 را بدهیم. همان گونه که برای یک متغیر تکی int قبلا مقدار دهی میکردیم، در اینجا نیز به همین ترتیب پیش می رویم. تنها تفاوت اینست که شماره آن سطر یا خانه ای که می خواهیم به آن مقدار بدهیم، را باید مشخص کنیم.

OurArray[0]=8;

برای مقدار دادن به بقیه سطرها یا خانه های آرایه نیز به همین ترتیب عمل می کنیم:

OurArray[1]=4;
OurArray[2]=6;
OurArray[3]=5;
OurArray[4]=2;

روش دیگر مقدار دهی به آرایه به صورت زیر است:

int OurArray2[]={5,4,8,6};

این نوع تعریف به صورت اتوماتیک خودش تعداد خانه های آرایه را تعیین می کند. که در مثال بالا همانند اینست در واقع [3]OurArray2 است. یعنی 4 خانه که از شماره 0 تا سه هستند.

این متود در حال تنظیم یک array با استفاده از کروشه ها بعد از علامت تساوی، می باشد. در بین کروشه ها مقادیری را تایپ می کنید که array خواهد گرفت. اولین مقدار در موقعیت 0 و دومین مقدار در موقعیت 1 و غیره خواهد بود. توجه داشته باشید که هنوز پس از int نیاز به کروشه دارید، اما نیازی به لغت کلیدی new یا تکرار نوع داده و یا کروشه ها ندارید.

می توانید یک آرایه از انواع متغیرهای دیگر نیز تعریف نمایید. مثلا برای متغیر String می توان آرایه ای شبیه به زیر را تعریف نمود و سپس مقدار دهی کرد:

String month[]={"mehr","aban","azar","dey","bahman","esfand"};

با استفاده از تعریف بالا یک آرایه با تعداد 6 خانه که از شماره 0 تا 5 هستند، معرفی شده و سپس مقدار دهی می شود.

برای گرفتن خروجی از آرایه به سادگی میتوانید با مشخص کردن خانه آن آرایه، از آن خروجی بگیرید.

System.out.print(month[4]);

کد بالا خروجی “bahman” را چاپ می کند، زیرا به خانه شماره 4 آرایه اشاره می کند.

آموزش برنامه نویسی جاوا (بخش پنجم: عبارات کنترل کننده حلقه ها)

استاندارد

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

دستور Break

دستور break در زبان جاوا دو کاربرد دارد.

  1. وقتی که در اجرای حلقه به خط break می نویسیم حلقه در همان نقطه تمام شده و خارج می شود. و برنامه از خط بعد از حلقه ادامه پیدا می کند.
  2. در بلوک switch مورد استفاده قرار می گیرد که شرط case ها از یکدیگر جدا باشد که این بخش را در مطالب آینده توضیح خواهیم داد.

این دستور در واقع فقط یک کلمه است که به شکل زیر نوشته می شود:

Break;

برای مثال می توانید کد زیر را ببینید:

public static void main(String[] args) {

	      for(int i=1;i<50;i=i+1){
	         System.out.print("i is : " + i );
	       if(i==6)
			   break;
	         System.out.print("\n");
	      }
	}

خروجی کد بالا به شرح زیر است:

i is : 1
i is : 2
i is : 3
i is : 4
i is : 5
i is : 6

در حلقه بالا گفتیم که وقتی i برابر 6 شد، از حلقه خارج (Break) شو.

دستور continue

دستور Continue در همه حلقه ها قابل استفاده است. و کاربرد آن بدین صورت است که در هرجای حلقه که این دستور وجود داشته باشد، ادامه اجرا لغو و به ابتدای حلقه برمی گردیم. دقت داشته باشید که اگر در داخل حلقه for قرار داشته باشیم بخش update پس از رسیدن به continue اجرا خواهد شد و سپس شرط حلقه چک می شود. همچنین اگر در حلقه while یا do…while باشد وقتی به دستور continue می رسیم به ابتدای حلقه رفته و شرط حلقه چک می شود. شکل نوشتاری این دستور به شکل زیر است:

continue;

برای درک بهتر به مثال زیر توجه فرمایید:

public static void main(String[] args) {
		// TODO Auto-generated method stub

	      for(int i=1;i<10;i=i+1){

		       if(i==6)
				   continue;

	         System.out.print("i is : " + i );

	         System.out.print("\n");
	      }
	}

خروجی برنامه بالا به این صورت است:

i is : 1
i is : 2
i is : 3
i is : 4
i is : 5
i is : 7
i is : 8
i is : 9

همان طور که می بینید عدد 6 برای i نشان داده نشده است، زیرا وقتی به این عدد می رسیم حلقه به ابتدای اجرای خود می رود و چیزی چاپ نمی کند.

شکل پیشرفته حلقه for

در نسخه 5 جاوا یک حلقه for جدید معرفی شد. این حلقه برای پیمایش مجموعه ها و لیست ها و آرایه ها به کار می رود. به این معنی که تک تک اعضای مجموعه را یکی یکی پیمایش می کند. شکل نوشتاری این حلقه به صورت زیر است:

for(declaration : expression)
{
   //Statements
}

در قسمت declaration باید یک متغیر تعریف کنیم. نوع این متغیر باید متناسب با نوع آیتم های مجموعه مورد نظر باشد. برای مثال اگر قصد پیمایش لیستی از اعداد صحیح داریم این متغیر باید از نوع int باشد.

در قسمت expression باید نام مجموعه مورد نظر که می خواهیم آن را پیمایش کنیم آورده شود. این مجموعه می تواند یک آرایه باشد یا حتی می تواند یک متد باشد که مقدار بازگشتی آن آرایه باشد. برای مثال به کد زیر دقت کنید:

public static void main(String[] args) {
	      int [] numbers = {10, 20, 30, 40, 50};

	      for(int x : numbers ){
	         System.out.print( x );
	         System.out.print(",");
	      }
	      System.out.print("\n");
	      String [] names ={"Gsm", "Developers", "Team", "Site"};
	      for( String name : names ) {
	         System.out.print( name );
	         System.out.print(",");
	      }
	}

 

خروجی بالا را می توانید در مثال زیر مشاهده نمایید:

10,20,30,40,50,
Gsm,Developers,Team,Site,

آموزش برنامه نویسی جاوا (بخش چهارم: حلقه های تکرار)

استاندارد

کدها در زبانهای برنامه نویسی مانند جاوا به ترتیب و خطی اجرا می شوند. به این معنی که از متد main شروع شده و خط به خط اجرا می شوند. حال ممکن است که حالاتی پیش بیاید که بخواهیم یک قسمت از کد چند بار اجرا شود. زبان های برنامه نویسی راه های مختلفی فراهم کرده اند که این نوع اجرا خطی را تغییر دهد. یکی از این راه ها حلقه های تکرار(loop) هستند. حلقه ها می توانند که یک سری دستورات را چندین بار اجرا کنند.

زبان برنامه نویسی جاوا حلقه های متفاوتی برای استفاده دارد که هرکدام می تواند در شرایط مربوط به خود مفید و کاربردی باشد که عبارتند از:

حلقه For ،حلقه While، حلقه Do While…

کار با حلقه ها بسیار جالب است و مطمئن باشید که در اکثر برنامه هایی که می نویسید حلقه های تکرار را به کار خواهید گرفت پس یکی از پرکاربرد ترین موضوعات برنامه نویسی حلقه ها هستند.

1- حلقه For

هر وقت تعداد تکرارهایمان را بدانیم و یا تعداد تکرار به تعداد مشخصی که آن تعداد در برنامه معلوم می شود، باشد، از حلقه For استفاده می کنیم.

شکل نوشتاری حلقه  For به شکل زیر است:

for(initialization; Boolean_expression; update)
{
   //قطعه کد تکرار شونده
}

بخش های مختلف حلقه For را در الگوریتم بالا شرح می دهیم:

بخش initialization: این بخش فقط یک بار اجرا شده و باعث می شود که مقدمات اجرای حلقه فراهم شود. معمولا در آن متغیر معرفی می شود تا با آن متغیر بتوانیم تعداد حلقه های تکرار را مشخص کنیم.

بخش Boolean_expression: این بخش یک بخش کنترل است که اگر مقدار آن true باشد، حلقه ادامه پیدا کرده و در صورت false شدن از حلقه خارج می شویم.

بخش update: پس از هر بار اجرای حلقه، بخش update اجرا می شود. مثلا در این قسمت هر بار پس از اجرای حلقه یکی به مقدار متغیر اضافه شده تا وقتی شرط وسط نقض شود، از حلقه خارج شویم.

برای درک بهتر به مثال زیر توجه فرمایید:

public class Test {

   public static void main(String args[]) {

      for(int i = 30; i < 35; i = i+1) {
         System.out.print("value of i : " + i );
         System.out.print("\n");
      }
   }
}

نتیجه خروجی مثال بالا به ترتیب زیر است:

value of i is : 30

value of i is : 31

value of i is : 32

value of i is : 33

value of i is : 34

2- حلقه While

حلقه While برای مواقعی است که بخواهیم تا وقتی شرط خاصی درست است حلقه اجرا شود، و سپس درست در هنگامی که آن شرط نقض می شود، از حلقه خارج شویم.

while(عبارت شرطی)
{
   //دستورات حلقه که باید تکرار شوند
}

دستوری که در حلقه می نویسیم می تواند یک خط کد باشد و یا یک بلاک از کدهای چند خطی باشد. در قسمت عبارت شرطی می توانیم از یک متغیر که می خواهیم با نقض شدنش از حلقه خارج شویم باشد و یا چندین عبارت باشد!

برای درک بهتر به مثال زیر توجه فرمایید:

public class Test {

   public static void main(String args[]) {
      int i = 30;

      while( i < 35) {
         System.out.print("value of i : " + i );
         i++;
         System.out.print("\n");
      }
   }
}

نتیجه خروجی مثال بالا به ترتیب زیر است:

value of i is : 30

value of i is : 31

value of i is : 32

value of i is : 33

value of i is : 34

همان طور که مشاهده می کنید، حلقه While در کد بالا همانند حلقه For عمل می کند. ولی همیشه این دو مثل یک دیگر نبوده و خیلی از اوقات نمی توان از هر دو استفاده کرد. با تکرار و تمرین در برنامه نویسی می توان کاملا به مبحث حلقه ها تسلط پیدا نمود.

3- حلقه Do ... While

این حلقه همان حلقه While است با این تفاوت که ابتدا کد داخل حلقه اجرا می شود و سپس شرط داخل حلقه برای ادامه ی تکرار حلقه چک می شود.

در حلقه While معمولی که در قسمت دوم دیدیم ممکن است که کد داخل حلقه While به دلیل آن که شرطش درست نباشد، اجرا نشود و حلقه While حتی یک بار هم تکرار نشود.

do
{
  //بدنه حلقه
} while(شرط حلقه);

برای درک بهتر به مثال زیر توجه فرمایید:

public class Test {

   public static void main(String args[]){
      int i = 30;

      do{
         System.out.print("value of i : " + i );
         i++;
         System.out.print("\n");
      }while( i < 35 );
   }
}

نتیجه خروجی مثال بالا به ترتیب زیر است:

value of i is : 30

value of i is : 31

value of i is : 32

value of i is : 33

value of i is : 34

3- حلقه های تو در تو

گاهی اوقات لازم است که در یک حلقه، یک یا چند حلقه دیگر هم استفاده نمود.

معروفترین مثال برنامه نویسی در مورد حلقه های تودرتو، نمایش جدول ضرب اعداد است:

public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int  i,j;

		for ( i = 1; i<=10 ; i++ )
		{
		    for ( j = 1; j<=10 ; j++ )
		    	System.out.print(i*j + "\t");
		    System.out.print("\n");
		}
	}

خروجی مثال بالا به شرح زیر است:

در ابتدا، برنامه وارد حلقه اول شده و شرط را بررسی می کند و با درستی آن به اجرای دستورات حلقه می پردازد. اینجا برای حلقه آکولاد وجود دارد پس تمامی دستورات درون بلوک به ترتیب اجرا می شوند.

سطر بعدی هم یک حلقه است یعنی حلقه جاری به ازای تعداد تکرار حلقه اول باید تکرار شود و در هر تکرار از حلقه بالا به تعداد تکرار خود نیز تکرار می شود، شرط آن بررسی شده و با درستی شرط به انجام دستورات حلقه می پردازد. به دلیل عدم وجود آکولاد برای این حلقه، تنها سطر بعدی دستور حلقه داخلی است و تا نقیض شدن شرط حلقه آن سطر اجرا می شود. در این مثال 10 بار حلقه درونی تکرار می شود و با هر بار تکرار فاصله ای بعد از نمایش عدد مورد نظر هم قرار می دهد.

سپس برنامه با اجرای دستور بعدی به خط جدید می رود. از حلقه اول 9 بار تکرار دیگر مانده، پس این رویه تکرار شده تا برنامه کامل گردد. در آخر وقتی i برابر با 11 می شود از حلقه بیرونی خارج شده و برنامه به پایان می رسد.

مثال ستاره:

می خواهیم در خروجی ستاره های زیر چاپ شوند:

*
**
***
****
*****
******
*******
********
*********
**********

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int  i,j;

		for ( i = 1; i<=10 ; i++ )
		{
		    for ( j = 1; j<=i ; j++ )
		    	System.out.print("*");
	    	System.out.print("\n");

		}
	}

دقت کنید که در شرط حلقه دوم، یعنی قسمت دوم از حلقه For که برای چک کردن شرط است، از عدد ثابتی استفاده نکردیم و از متغیر حلقه ی قبلی که خود در هر بار گردش حلقه، افزایش پیدا می کند، استفاده کرده ایم. بدین ترتیب با افزایش متغیر حلقه اول یعنی i، حلقه دوم به تعداد بیشتری گردش می کند و در نتیجه به تعداد بیشتری چاپ می شود.

می توان از حلقه های تو در تو، استفاده های زیادی نمود و به تعدادنامحدودی حلقه For به کار برد ولی این کار ممکن است برنامه شما را پیچیده کند و یا حتی نیازی نباشد که مثلا ده حلقه For در برنامه به کار ببریم. پس بسته به نیاز شما در برنامه نویسی از تعداد مشخصی حلقه For استفاده کنید.

آموزش برنامه نویسی جاوا (بخش سوم: عملگر ها)

استاندارد

جاوا یک محیط عملگر غنی را فراهم کرده است . اکثر عملگرهای آن ر ا می توان در چهار گروه طبقه بندی نمود که عبارت اند از : حسابی (arithmetic) ، رفتاربیتی (BitWise) ، رابطه ای (Relational) و منطقی (Logical) .

کارکرد عملگرها در جاوا مشابه با ++C/C است.

1- عملگرهای حسابی

عملگرهای حسابی در عبارات ریاضی استفاده می شوند و طریقه استفاده از آنها بهمان روش جبری است. عملوندهای مربوط به عملگرهای حسابی باید از نوع عددی باشند .

نمی توانید از این عملگرها روی نوع استفاده کنید ، اما روی انواع Char قابل استفاده هستند ، زیرا نوع Char در جاوا بطور ضروری زیر مجموعه ای از int است.

نام عملگر معنی مثال مقدار عبارت مثال
+ جمع 13+7 20
تفریق 8-4 4
منفی -6 -6
* ضرب 3*5 15
/ تقسیم 20/5 4
% باقی مانده تقسیم 8%3 2

عملگرهای حسابی اصلی عبارت اند از: جمع، تفریق، ضرب، تقسیم. مثال: کد زیر یک متغیر از نوع int معرفی می کند. و به آن مقدار 6 را می دهد. در خط دوم یک متغیر از نوع int انتخاب می کند و مقدار آن را برابر جمع متغیر قبلی با عدد 4 می کند. حاصل متغیر دوم برابر 10 است.

int a=6;
int b=a+4;
//b=10

میتوان تعداد بیشتری متغیر و عملوند را در یک خط به کار برد:

int a=5;
int b=7;
int c=3;
int d = a*b*c;
// d=105

عملگر تعیین باقیمانده یعنی % ، باقیمانده یک عملیات تقسیم را برمی گرداند. این عملگر برای انواع عدد اعشاری و انواع عدد صحیح قابل استفاده است. ( اما در ++C/C این عملگر فقط در مورد انواع عدد صحیح کاربرد دارد. )

برنامه بعدی نشان دهنده عملگر % می باشد.

int x = 42;
double y = 42.3;
float z = x%10;
float v = y%10;

در کد بالا مقدار z برابر با 2 و مقدار v برابر با 2.3 است.

جاوا عملگرهای ویژه ای را تدارک دیده که با استفاده از آنها می توان یک عملیات حسابی را با یک انتساب ترکیب نمود. احتمالا می دانید که دستوراتی نظیر مورد زیر در برنامه نویسی کاملا رایج هستند:

a = a + 4;

در جاوا ، می توانید این دستور را بصورت دیگری دوباره نویسی نمایید:

a += 4;

این روایت جدید از عملگر انتساب =+ استفاده می کند هر دو دستورات یک عمل واحد را انجام می دهند : آنها مقدار a را 4 واحد افزایش می دهند.

عبارت عملگر متغیر عملگرهای انتساب دو مزیت را بوجود می آورند.

اول اینکه آنها یک بیت از نوع بندی را برای شما صرفه جویی می کنند، زیرا آنها کوتاه شده شکل قبلی هستند.

دوم اینکه آنها توسط سیستم حین اجرای جاوا بسیار کاراتر از اشکال طولانی خود پیاده سازی می شوند. بهمین دلایل، در اکثر برنامه های حرفه ای نوشته شده با جاوا این عملگرهای انتساب را مشاهده می کنید.

2- عملگرهای افزایشی و کاهشی

علامات ++ و — عملگرهای افزایشی و کاهشی جاوا هستند.

همانگونه که خواهید دید، این عملگرها خصلتهای ویژه ای دارند که بسیار جالب توجه است. بحث درباره این عملگرها را از نحوه کار آنها شروع می کنیم. عملگر افزایشی، عملوند خود را یک واحد افزایش می دهد. عملگر کاهشی نیز عملوند خود را یک واحد کاهش می دهد.

به عنوان مثال، دستور زیر را می توان به صورتی دیگر نوشت:

x=x+1;

دستور بالا با استفاده از عملگر افزایشی:

x++;

همچنین دستور

x=x-1;

را می توان با استفاده از عملگر افزایشی به صورت زیر نوشت:

x--;

این عملگرها از آن جهت که هم بشکل پسوند جایی که بعد از عملوند قرار می گیرند و هم بشکل پیشوند جایی که قبل از عملوند قرار می گیرند ظاهر می شوند کاملا” منحصر بفرد هستند.

هنگامیکه عملگرهای افزایشی و کاهشی بخشی از یک عبارت بزرگتر هستند، آنگاه یک تفاوت ظریف و در عین حال پرقدرت بین دو شکل وجود خواهد داشت. در شکل پیشوندی، عملوند قبل از اینکه مقدار مورد استفاده در عبارت بدست آید، افزایش یا کاهش می یابد. در شکل پسوندی ، ابتدا مقدار استفاده در عبارت بدست می آید، و سپس عملوند تغییر می یابد.

به عنوان مثال:

x = 50;
y = ++x;

در این حالت ، همانطوریکه انتظار دارید y معادل 51 می شود. چون افزایش قبل از این که x به y انتساب بیاید، اتفاق می افتد.

اما وقتی که بصورت زیر نوشته می شوند:

x = 50;
y = x++;

در این عبارت، مقدار y برابر با 50 خواهد بود. سپس بعد از آن که مقدار y مشخص می شود، مقدار x به 51 می رسد.

3- عملگر انتساب

کار اصلی این عملگر نسبت دادن مقدار عبارت سمت راست (عملوند راست) به متغیر (عملوند) سمت چپ خود است. با توجه به تعریف بالا عملیات نسبت دادن یک مقدار به یک متغیر خود یک عبارت ریاضی است زیرا دارای مقدار است. همین خاصیت باعث می‌شود که بتوانیم چندین عملگر انتساب را زنجیروار به هم متصل نموده و چندین عبارت را در یک عبارت ساده‌تر نوشت. به مثال زیر دقت کنید:

int x = y = z = 8;

با توجه به خاصیت عملگر انتساب، عبارت فوق در زبان جاوا معتبر بوده و معنای آن این است که هر سه متغیر x و y و z دارای مقدار اولیه 8 هستند.

تغییر دادن مقدار یک متغیر با استفاده از مقدار فعلی متغیر فرایند بسیار متداولی در برنامه نویسی جاوا است. به همین منظور و برای سادگی عملیات و خوانایی بیشتر کد، چندین عملگر انتساب جدید در زبان جاوا وجود دارند که در جدول زیر به همراه مثال آمده‌اند:

معادل مثال عملگر
x= x+y x+=y +=
x= x – y x -= y -=
x = x*y x*=y *=
x= x/y x/=y /=

4- عملگرهای مقایسه ای

جاوا عملگرهایی برای مقایسه متغیرها (Variables)، متغیرها و متغیرهای لفظی (Literals) و سایر انواع داده‌ها در برنامه دارد. حاصل این عملگرها یک متغیر بولین است که همواره دارای مقدار true یا false است. جدول زیر شامل فهرست کامل عملگرهای مقایسه‌ای جاوا و مثال‌هایی از هر کدام است:

عملگر معنی مثال توضیح مثال
== تساوی x==8  اگر x برابر با 8 باشد، حاصل عبارت True و در غیر این صورت، حاصل false است.
!= نامساوی x!=8 اگر x برابر 8 باشد حاصل عبارت false و در غیر اینصورت true است.
< کوچکتر x<3 اگر x کوچکتر از سه باشد، true و در غیر اینصورت false است.
> بزرگتر x>3 اگر x بزرگتر از سه باشد true و در غیر این صورت false است.
<= کوچکتر مساوی x <= 3 اگر x کوچکتر از سه و یا مساوی با سه باشد true و در غیر این صورت false است.
>= بزرگتر مساوی  x => 3 اگر x بزرگتر از سه و یا مساوی با آن باشد، true و در غیر اینصورت false است.

5- عملگرهای رفتار بیتی یا منطقی

عملگرهای رفتار بیتی The Bitwise operators جاوا چندین عملگر رفتار بیتی تعریف نموده که قابل اعمال روی انواع عدد صحیح شامل long, int, short , char , byte می باشد.

عبارت‌هایی که حاصل آن‌ها یک مقدار بولی (boolean) است، می‌توانند با هم ترکیب شده و عبارت‌های پیچیده‌تری بسازند. برای ترکیب این عبارت‌ها می‌توان از عملگرهای منطقی استفاده کرد. این عملگرها عبارتند از «و» (AND)، «یا» (OR)، «مخالف» (NOT) و «یای انحصاری» (XOR) و …

عملگر نتیجه
& ANDمنطقی
| OR  منطقی
^ XOR منطقی
|| OR اتصال کوتاه
&& AND اتصال کوتاه
! NOT یگانی منطقی
&= AND و تخصیص
|= OR و تخصیص
^= XOR و تخصیص
== مساوی است با
!= مخالف است با
?: If-then-else سه تایی

جدول زیر سه عملگر منطقی مهم جاوا را بررسی کرده و توضیحات و مثال برای هرکدام از آن‌ها آورده است.

عملگر معنی مثال توضیح مثال
& AND (و) A & B  در صورتی که هر دو عبارت درست باشند، مقدار True و در غیر اینصورت مقدار False را بر میگرداند.
| Or (یا) A|B تنها کافیست که حداقل یکی از دو عبارت درست باشد تا مقدار True را برگرداند و در غیر این صورت مقدار False را بر میگرداند.
^ یای انحصاری (XOR) A^B فقط و فقط در صورتی مقدار بازگشتی عبارت درست (true) است که یکی از دو عبارت صحیح و دیگری غلط باشد. اگر هر دو عبارت درست (true) یا هر دو عبارت غلط (false) باشند، مقدار بازگشتی عبارت غلط (false) خواهد شد.
! Not (مخالف) A! اگر A مقدار True داشته باشد، مقدار False و اگر مقدار False داشته باشد مقدار True را بر میگرداند.

آموزش برنامه نویسی جاوا (بخش دوم: انواع داده ها و متغیر ها)

استاندارد

متغیرها اشاره کننده هایی به قسمتی از حافظه کامپیوتر هستند که در آن مقداری نهفته است. بطور مثال وقتی می گوییم int value=2 یعنی متغیر value از جنس int ( اعداد صحیح بین -2,147,483,648 تا 2,147,483,647 ) است که نیاز به اشغال 32بیت یا همان 4 بایت از حافظه دارد. متغیر value فقط به آدرس اولین بایت از این حافظه مورد نیاز اشاره می کند. با استفاده از عملگر تساوی ( = ) می گوییم که مقدار این فضا ( که 4 بایت است ) 2 باشد.

هر گاه متغیر value را بخوانیم، داریم مقدار حافظه متصل شده به این متغیر را می خوانیم. نیاز نیست خیلی نگران چگونگی عملکرد جاوا در خواندن و نوشتن متغیرها باشید اما خوب بود که بدانید معنی واقعی یک متغیر چیست.

با توجه به توضیح فوق می توانیم متغیرهایی از جنس های مختلف ( محدود اعدادی که ساپورت می کند، نوع اعدادی که ساپورت می کند و … ) داشته باشیم.

برای تعریف کردن متغیرها با نوع های مختلف کد زیر می تواند به شما کمک کند.

01            byte    aValue = 1;
02            short   bValue = 1;
03            int     cValue = 1;
04            long    dValue = 1;
05            float   eValue = 2.0f;
06            double  fValue = 2.0d;
07            boolean gValue = false;
08            char    hValue = 'A';

اگر چه مثالهای قبلی از ثابت ها بعنوان مقدار ده اولیه استفاده کرده اند اما جاوا امکان مقداردهی اولیه بصورت پویا را نیز فراهم آورده است. این موضوع با استفاده از هر عبارتی که در زمان اعلان متغیر باشد، انجام می گیرد.

بعنوان مثال ، در زیر برنامه کوتاهی را مشاهده می کنید که طول ضلع یک مثلث قائم الزاویه را با داشتن طول دو ضلع مقابل محاسبه می کند:

class DynInit {
public static void main(String args[] ){
double a = 3.0, b = 4.0;
// c is dynamically initialized
double c = Math.sqrt(a * a + b * b);
System.out.println("Hypotenuse is " + c);
}
}

نگاهی از نوع بایت به متغیرها !

false , true boolean
one byte , integer byte
16bits, one character char
4bytes, single-precision float
2bytes, integer short
8bytes, double-precision double
8bytes, integer long
4bytes, integer int
Return type where no value is required void
N byte String

متغیر از نوع Integer

اعداد صحیح یا همان Int ها رایج ترین نوع متغیرهای استفاده شده در زبان های برنامه نویسی هستند.

هرگاه متغیری را به صورت Int تعریف می کنیم، فقط می تواند اعداد صحیح را بپذیرد.

int decimal = 100;

لازم به ذکر است که به صورت پیش فرض همه ما از اعداد صحیح در مبنای ده استفاده می کنیم که دو مبنای دیگر یعنی مبنای هشت و مبنای شانزده نیز می توانند به عنوان متغیر Int تعریف شوند.

برای تعریف اعداد در مبنای 16 از 0x در ابتدای عدد استفاده می کنیم.

int hex = 0x64;

همچنین در جاوای 7 به بعد نیز، امکان معرفی مبنای باینری نیز فراهم شده است. برای تعریف اعداد در مبنای 2 در ابتدای عدد از 0b استفاده می شود.

int bin = 0b1100100;

نکته:

short برای اعداد صحیح کوچک و long برای اعداد صحیح بزرگ مورد استفاده قرار می گیرد.

متغیر از نوع Float

ارقام اعشاری معرف مقادیر دهدهی با اجزائ کسری می باشند. آنها را می توان به شکل استاندارد یا به شکل علامتگذاری علمی بیان نمود. نشانه گذاری استاندارد شامل یک جز عدد صحیح است که بعد از آن یک نقطه و بعد از آن جز کسری عدد قرار می گیرد.

بعنوان مثال 3.0 یا 0.5775 یا 8.55854458577 معرف نشانه گذاری استاندارد معتبر در ارقام اعشاری هستند.

برای معرفی متغیر از نوع float می توانید از دستور زیر به عنوان مثال، استفاده نمایید:

float ashar = 5.2461;

نکته:

برای اعداد اعشاری بزرگ از نوع double استفاده می شود.

متغیر از نوع Boolean

هر متغیری که از نوع Boolean معرفی می شود فقط می تواند دو مقدار “false” و یا “true” را بپذیرد. این دو مقدار منطقی هستند. بعدا می توان استفاده های زیادی از آن ها نمود. لازم به ذکر است در جاوا true برابر با 1 نیست. همچنان که false نیز معادل با 0 نیست.

متغیر از نوع Character

کاراکترهای جاوا در مجموعه کاراکتر کدهای جهانی نمایه سازی شده اند . آنها مقادیر 16بیتی هستند که قابل تبدیل به اعداد صحیح بوده و با عملگرهای عدد صحیح نظیر عملگرهای اضافه و کسر نمودن اداره می شوند. یک کاراکتر لفظی همواره داخل یک علامت ‘ ‘ معرفی می شود. کلیه کاراکترهای ASCII قابل رویت می توانند بطور مستقیم به داخل این علامت وارد شوند.

مثال:

char ch = 'a';

متغیر از نوع String

متغیر رشته ای در جاوا نظیر سایر زبانهای برنامه نویسی مشخص می شوند قرار دادن یک دنباله از کاراکترها بین یک جفت از علامات نقل قول ، در زیر نمونه هایی از متغیر رشته ای را مشاهده می کنید.

“Hello world”
“tow\nlines”
“\”This is in quotes\”

مثال:

string message = "hello world";

آموزش برنامه نویسی جاوا (مقدمه)

استاندارد

در کدهایی که برای اپلیکیشن های اندرویدی می نویسیم به زبان جاوا احتیاج داریم. پس یادگیری زبان برنامه نویسی جاوا تقریبا الزامی ست و کمک بسیاری در نوشتن کدهایی که برای اپلیکیشن های اندرویدی می نویسیم می کند.

در این بخش ابتدا کمی در مورد جاوا توضیح می دهیم.

جاوا (به انگلیسی: Java) یک زبان برنامه‌نویسیِ شیءگرا است که برای نخستین بار توسط جیمز گاسلینگ در شرکت سان مایکروسیستمز ایجاد گردید و در سال ۱۹۹۵ به عنوان بخشی از سکوی جاوا منتشر شد. زبان جاوا شبیه به ++C است اما مدل شیءگرایی آسان‌تری دارد و از قابلیت‌های سطح پایین کمتری پشتیبانی می‌کند. یکی از قابلیت‌های بنیادین جاوا این است که مدیریت حافظه را بطور خودکار انجام می‌دهد. ضریب اطمینان عملکرد برنامه‌های نوشته‌شده به این زبان نسبت به زبانهای نسل اول C بالا است و وابسته به سیستم‌عامل خاصی نیست. برنامه‌های جاوا به صورت بایت کد (کامپایل) می‌شوند که توسط واسط JVM به کدهای ماشین اجرا می‌شوند؛ و در صورت وجود JVM مانند سایر زبانهای مبتنی بر آن وابسته به سیستم‌عامل خاصی نیستند. (منبع : ویکی پدیا)

در حقیقت بسیاری از خصلتهای زبان جاوا از دو زبان C و ++C مشتق شده یا با آنها مرتبط است. علاوه بر این، تولید جاوا بطور عمیقی متاثر از روال پالایش و تطبیقی است که طی سه دهه گذشته برای زبانهای برنامه نویسی موجود پیش آمده است. بهمین دلایل بهتر است سیر مراحل و نیروهایی که منجر به تولد جاوا شده را بررسی نماییم. هرنوع ابتکار و فکر جدید در طراحی زبانها براساس نیاز به پشت سر نهادن یک مشکل اصلی است که زبانهای قبلی از حل آن عاجز مانده اند. جاوا نیز بهمین ترتیب متولد شد.

جاوا برای نوشتن انواع برنامه‌های کاربردی مناسب است. با جاوا می‌توان انواع برنامه‌های زیر را نوشت:

  • برنامه‌های تحت وب
  • برنامه‌نویسی سیستم‌های کوچک مانند تلفن همراه، رایانه جیبی و …
  • برنامه‌های کاربردی بزرگ (Enterprise)
  • برنامه‌های رومیزی (Desktop)
  • و غیره.

سیستم‌عامل: تا سال ۲۰۰۴ net. تنها بر روی پلت فرم ویندوز اجرا می‌شد و برخی ویندوز را سیستم‌عامل غیرقابل اعتمادی در برنامه‌نویسی Enterprise می‌دانستند. ولی جاوا از این نظر انتخاب خوبی محسوب می‌شد.
قابلیت حمل: جاوا بر روی سکوهای رایانش گوناگونی قابل اجرا است، از ATM و ماشین رختشویی گرفته تا سرورهای سولاریس با قابلیت پشتیبانی از 1024 CPU برای پردازشقابلیت حمل: جاوا بر روی سکوهای رایانش گوناگونی قابل اجرا است، از ATM و ماشین رختشویی گرفته تا سرورهای سولاریس با قابلیت پشتیبانی از 1024 CPU برای پردازش.

قابلیت حمل: جاوا بر روی سکوهای رایانش گوناگونی قابل اجرا است، از ATM و ماشین رختشویی گرفته تا سرورهای سولاریس با قابلیت پشتیبانی از 1024 CPU برای پردازش.

جاوا از نظر ساختار بسیار شبیه زبان C و ++C است. و این به هیچ وجه تصادفی نیست. C زبانی است ساخته یافته و ++C زبانی شی گرا است. مهم تر از همه آنست که ++C زبان خیلی از برنامه نویسان در دنیا است.

برنامه نویسی شی گرا هسته اصلی جاوا است . در حقیقت کلیه برنامه های جاوا شی گرا هستند . بر خلاف ++C که در آن امکان گزینش شی گرایی وجود دارد روشهای OOP (شی گرایی)، آن چنان با زبان برنامه نویسی جاوا پیوستگی دارند که حتی قبل از نوشتن یک برنامه ساده جاوا نیز باید از روش های OOP استفاده نمود.

OOP مخفف Object Oriented Programming می باشد. بهمین دلیل این بخش را با بحث جنبه های نظری OOP آغاز می کنیم.

3 اصل OOP

کلیه زبانهای برنامه نویسی شی ئگرا مکانیسمهایی را در اختیار شما قرار میدهند تا مدل شی ئگرا را پیاده سازی نمایید.

این مدل شامل کپسول سازی (Encapsulation)، وراثت (Inheritance) و چند شکلی (polymorphism) می باشد.

هر یک از بخش های بالا و به طور کلی مفهوم وراثت در برنامه نویسی، نیاز به توضیحاتی دارد که ترجیح داده می شود در اینجا از توضیح آنها چشم پوشی شود. اگر می خواهید آن موارد را بخوانید بهتر است به کتب موجود در این زمینه مراجعه کنید.

ریزبرنامه ها applets

از جاوا برای تولید دو نوع برنامه می توان استفاده نمود: برنامه های کاربردی (applications) و ریزبرنامه ها (applets)

یک برنامه کاربردی برنامه ای است که روی رایانه شما و تحت نظارت یک سیستم عامل اجرا می شود. بدین ترتیب یک برنامه کاربردی ایجاد شده توسط جاوا مشابه برنامه های ایجاد شده توسط C و ++C خواهد بود.

هنگامیکه از جاوا برای تولید برنامه های کاربردی استفاده میکنیم تفاوتهای زیادی بین این زبان و سایر زبانهای برنامه نویسی مشاهده نمی کنیم اما ویژگی جاوا برای تولید ریز برنامه ها دارای اهمیت زیادی است.

یک ریز برنامه (applets) یک برنامه کاربردی است که برای انتقال و حرکت روی اینترنت و اجرا توسط یک مرورگر قابل انطباق با جاوا طراحی شده است. یک ریز برنامه در حقیقت یک برنامه ظریف جاوا است که بطور پویا در سراسر اینترنت قابل بارگذاری باشد. درست مثل یک تصویر، یک فایل صوتی یا یک قطعه ویدئویی.

تفاوت اصلی در اینست که ریزبرنامه یک برنامه کاربردی هوشمند است و شباهتی با یک تصویر متحرک یا فایل رسانه ای ندارد . بعبارت دیگر این برنامه قادر به عکس العمل در برابر ورودی کاربر و ایجاد تغییرات پویا است.

ریز برنامه های جاوا بسیار جالب و هیجان انگیزند و قادرند دو مشکل اصلی یعنی امنیت و قابلیت حمل را پشت سر بگذارند.

اپلت‌ها امکانات فراوانی برای نوشتن برنامه‌های تحت وب در اختیار برنامه‌نویسان قرار می‌دهند.

البته وجود ماشین مجازی جاوا برای اجرای اپلت لازم است. اپلت‌ها نظیر فناوری سیلورلایت شرکت مایکروسافت هستند که برنامه‌نویسان را قادر می‌سازد تا امکاناتی را به مرورگر کاربر بیفزایند. البته تفاوت این دو در امنیت می‌باشد به گونه‌ای که سیلورلایت به دلیل اینکه در محیطی به نام جعبه شنی (sandbox) اجرا می‌شوند امن هستند ولی اپلتها فاقد چنین امنیتی هستند و به سادگی هدف حملات استاندارد Social Engineering Toolkit در Kali Linux واقع می‌شوند.

قابلیت های جاوا

  • ساده
  •  شىء گرا
  • (Portable) قابل انتقال
  • (Distributed) توزیع شده
  • کارایى بالا
  • (Interpreted) ترجمه شده
  • Multithreaded (چند نخی)
  • پویا
  • (Secure)  ایمن
  • جاوا مجانی ولی Open Source نیست.