Liansharj
 

تابلو اعلانات بستن این دسته بندی

:: طراحی محوطه و فضای سبز با نرم افزار Deluxe :: برای مشاهده آموزش اینجا کلیک کنید.

:: آموزش اتوکد ۲۰۱۲ مقدماتی - سطح دو :: برای مشاهده آموزش اینجا کلیک کنید.

:: طرح تقویت واژگان انگلیسی یا 504 واژه ضروری :: برای شرکت در طرح تقویت واژگان انگلیسی با استفاده از 504 واژه ضروری اینجا کلیک کنید.

:: آموزشگاه CEH :: آموزش و پیشرفت گروهی مدرک CEH (هک قانونمند) . برای شرکت در این طرح اینجا کلیک کنید.

:: Steganography Challenges (Number 8) :: برای شرکت در مسابقه استگانوگرافی اینجا کلیک کنید.


پیپرز
تبلیغات شما در این مکان

صفحه 2 از 2 نخستنخست 12
نمایش نتایج: از 11 به 16 از 16

موضوع: آموزش جاوا (از پایه)

  1. #11


    Strange آواتار ها


    رشته کارشناسی
    مهندسی کامپیوتر
    پوینت
    1,175
    ارسال تشكر
    940
    تشكر شده 1,222 بار در 295 پست

    درسنامه نهم

    String :

    String را به خاطر دارید؟ آیا یادتون هست که گفتم این را به عنوان type درنظر بگیرید؟
    دلیل اینکه می توان از آن به عنوان type استفاده کرد را هم بعدتر گفتم: " می توان هر کلاس را یک type درنظر گرفت." و همین طور هم می توان از method ها و attribute های آن کلاس استفاده نمود.
    بنابراین درصورت نیاز می توان کلاسی متناسب با نیازمان ایجاد کنیم و و از آن شی بسازیم و استفاده کنیم.

    اگر دقت کنید، می بینید که از String بدون اینکه کلاسی برایش بنویسیم، استفاده کرده ایم. فکر می کنید دلیل این کار چیست؟
    کلاس String قبلا نوشته شده و پیاده سازی شده است. بنابراین می توانید از آن استفاده کنید.
    شما می توانید از هر کلاسی که قبلا پیاده سازی شده، استفاده کنید. تنها مسئله ای که وجود دارد، این است که آیا بهش دسترسی دارید یا خیر. مثلا درمورد String، چون در آدرس java.lang قرار گرفته و این پکیج و همه کلاس های موجود در آن به طور خودکار، درهمه کلاس ها import می شوند؛ مشکلی نیست و راحت می توانید از آن استفاده کنید. اما درصورتی که نیاز به استفاده از کلاس از پیش تعریف شده و ازپیش پیاده سازی شده ای داشتید که هم پکیج نبودند، می توانید آن را import کنید. (مثل حالتی که خودتان کلاسی مینوشتید و از آن استفاده می کردید)
    برای آشنا شدن با کلاس های ازپیش تعریف شده، می توانید به سایت Oracle سر بزنید.
    [تنها کاربران قادر به مشاهده لینک ها هستند]شما را با پکیج java.lang آشنا می کند. با کلیک روی هر کلاس در این پکیج می توانید با توابع و متغیرهایش بیشتر آشنا شوید.
    آن جا کلاس Object را هم ملاقات خواهید کرد! (در درسنامه قبل به آن اشاره شد)

    درمورد توابع و فیلدهای آماده و ازپیش تعیین شده، حتما مطالعه کنید. چون کاربردهای زیادی دارند.
    مثلا برای انجام عملیات ریاضی می توانید به پکیج Math در java.lang مراجعه کنید و توابعی مثل تابع sqrt (برای گرفتن جذر عدد) را به شکل زیر صدا بزنید.
    کد:
    		Math.sqrt(arg0)


    آرایه ها:

    همان طور که احتمالا مطلع هستید،از آرایه ها برای نگه داری تعداد زیادی داده با type مشترک استفاده می شود. بنابراین شما می توانید در یک آرایه، هرتعدادِ ازپیش تعیین شده int یا char یا Object یا String یا هر type دیگری بریزید. دقت کنید که در یک آرایه فقط یکی از این type ها می تواند قرار بگیرد.

    برای تعریف آرایه از دستورات زیر استفاده کنید.
    کد:
    Type [] arrayName = new type[n];
    type arrayName[]={element 0,element 1,…element n-1};
    مثال:

    کد:
    int intEx[]={3,65,0,-7,814};
    فرمتی که در این مثال استفاده شده، آرایه ای به اندازه عناصری که در آکولاد نوشته ایم، می سازد.سپس عناصر را به ترتیبی که نوشته ایم وارد آرایه می کند.
    به طور مشخص، برای این مثال، در خانه صفرم آرایه intEx ، عدد 3 وجود دارد؛ در خانه سوم آن عدد 7- و...
    پس با این فرمت، هم آرایه ساختیم هم آن را مقدار دهی کرده ایم.
    کد:
    char chList[]=new char[6];
    or
    char chList[];
    chList=new char[6];
    دومورد بالا، هم ارز یک دیگرند. خط اول هم زمان با متغیری که برای اشاره به آرایه تعریف کرده ایم، آرایه را نیز با new کردن، ایجاد کرده ایم.
    اما مدل دوم، خط اول فقط متغیری بدون مقدار، ازجنس char تعریف کرده ایم. این خط دوم است که chList ساخته می شود.درواقع chList به آرایه ای اشاره می کند که 6 خانه دارد.
    اما هنوز آرایه را مقداردهی نکرده ایم. برای دادن مقدار به عنصر 4ام آن می نویسیم:
    کد:
    chList[4]='f';
    همین طور بقیه را می توانیم مقدار دهی کنیم.
    اگر مقادیری که می خواهید درآرایه ذخیره کنید، ترتیب مشخص یا قاعده خاصی دارند، می توانید از حلقه ها برای راحتی و سرعت بیشتر استفاده کنید.


    کد:
    Node []nClass=new Node[200];
    آخرین مثال هم آرایه ای با طول 200ساخته که هر عنصر آن از جنس کلاس Node است.

    نکاتی درمورد آرایه:

    1.تعداد عناصر آرایه، از پیش تعیین شده وغیرقابل تغییر است.
    2.محل قرار گرفتن [] در Type arrayName می تواند قبل یا بعد از arrayName باشد.
    3.برای آرایه با n عنصر، اندیس(عددی که در کروشه برای دسترسی به عنصر می نویسیم) ، می تواند از 0 تا n-1 باشد.
    4.آرایه با ابعاد بیشتر هم وجود دارد. 2بعدی، 3 بعدی و... . نکته خاص و متفاوتی برای آن وجود ندارد. فقط اینکه برای تعریف آرایه با بعد n ، باید تعداد جفت کروشه ها را برای وارد کردن آن بعد، n برابر کرد.مثلا آرایه دوبعدی به این شکل:
    کد:
    int [][]twoD=new int[10][8];
    آرایه دارای 10 سطر و 8 ستون است.



    Casting:

    این بخش را با یک سوال شروع می کنم.
    به نظر شما، آیا می شود هر متغیری را در متغیر دیگر ذخیره نمود؟
    مثلا اگر:
    کد:
    String s="Vacation" ;
    int i=6;
    char c='w';
    آیا می توان چنین نوشت؟
    کد:
    i=s;
    این دستور را چه طور؟
    کد:
    i=c;
    به عنوان پاسخ می توان گفت، دستور اول غیرمجاز است و دستور دوم مجاز! اما چه طور می توان تفاوت را تشخیص داد؟
    اصولا اجازه ذخیره اطلاعات متغیر از یک type در متغیری با type دیگر را نداریم؛ به جز درصورتی که رابطه ارث بری بین آن ها برقرار باشد.

    حالت های مجاز:

    حالت اول (cast فرزند به پدر): اگر متغیر b فرزند a باشد، با ریختن b در i (a=b) a مشکلی پیش نمی آید. یعنی این دستور مجاز است. البته این را بدانید که با این کار محتویات b که در a ذخیره شده است،type a را دارد. پس فقط به متغیرها و توابع a دسترسی دارد.

    به نمودار ارث بری Shape و فرزندانش مجددا توجه کنید.
    ارتباطات پدر-فرزندی آن ها مشخص است.

    اگر چنین داشته باشیم:
    کد:
    Shape s=new Shape();
    Circle c=new Circle();
    Circle c2;
    از آنجایی که Shape پدر Circle است، می توانید چنین بنویسید:
    کد:
    s=c;
    با این cast توقع نداشته باشید که s دقیقا همان توابع و متغیرهای c را داشته باشد. s دقیقا شامل همان توابع و متغیرهایی است که Shape دارد که آن ها مقادیر جدیدی به خود گرفته اند.

    حالت دوم( cast پدر به فرزند): اگر a پدر b باشد،می توانید a را در b ذخیره کنید. فقط باید type متغیر مقصد را در پرانتز صراحتا ذکر کنید و از طرف دیگر جنس واقعی a همان type b باشد.

    در ادامه کدهای بالا که s=c و متغیری از جنس Circle را در متغیر دیگری از جنس Shape ذخیره کرده ایم.
    حال می خواهیم s (از جنس Shape ولی با جنس واقعی Circle) را در c2 (از جنس Circle ) بریزیم.
    کد:
    C2= (Circle)s;
    توجه :
    متغیر سمت راست باید واقعا از جنس متغیر سمت چپ باشد تا بتوان آن را cast نمود؛ درغیر این صورت با خطای زمان اجرا روبه رو می شوید.
    برای مثال، کد زیر در زمان اجرا error خواهد داشت.چون جنس واقعی s،ا Circleنیست؛ بلکه Shape است.

    کد:
    Shape s= new Shape();
    Circle c= new Circle();
    c=(Circle)s;
    برای اطمینان از عدم وجود این مشکل، می توان از کد زیر استفاده کرد:

    کد:
    if (c instanceof type){
    type new_name = (type) c;
    }
    کد بالا درصورتی که c واقعا از جنس type نباشد، آن را به متغیر دوم cast نمی کند و از خطا جلوگیری میکند.


    نکته1: حالت اول(cast فرزند به پدر) (ذخیره b در a)را نیز می توان صراحتا این طور نوشت:
    کد:
    a= (aType)b;
    اما چون این casting خودکار انجام میشود، الزامی به نوشتن آن وجود ندارد.


    نکته2: Circle شامل تابع draw است؛ درحالی Shape آن تابع را دارا نیست:
    کد:
    Shape s=new Circle();
    Circle c=(Circle)s;
     s.draw();
    c.draw();
    خط سوم این کد اشتباه است .چون s تابعی به نام draw ندارد . پس با خطای زمان کامپایل روبه رو می شوید.
    درحالی که خط چهارم کاملا درست و بدون نقص است.


    ذخیره سازی با استفاده از casting در آرایه:

    باتوجه به رابطه ارث بری Shape و Circle و Triangle و Square،اگر بنویسیم:

    کد:
    Shape arrOfSh[]=new Shape[4];
    arrOfSh[0]=new Shape();
    arrOfSh[1]=new Triangle();
    arrOfSh[2]=new Square();
    arrOfSh[3]=new Circle();
    قطعه کد بالا آرایه ای به طول 4 می گیرد و در خانه صفرم آن شئی از Shape می ریزد. در خانه اول آن با استفاده از casting (فرزند به پدر) شئی ازجنس واقعی Triangle می ریزد. دوخط بعد نیز به همین شکل ادامه پیدا می کند.
    اکنون شما در آرایه arrOfShا، 4 شی از جنس Shapeولی با جنس واقعی متفاوت دارید.
    اگر بنویسید:
    کد:
    arrOfSh[3]
    به یک Shape اشاره میکنید. پس توقع نداشته باشید که بتوانید draw که در Circle است، از روی آن صدا بزنید.
    اگر بخواهید می توانید آن را از روی type اولیه اش صدا بزنید؛ به شکل زیر:
    کد:
    ((Circle)arrOfSh[3]).draw();


    abstract class:

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

    مثال زیر سه کلاس را نشان می دهد که Abs3 فرزند Abs2 و Abs2 فرزند Abs است؛ درحالی که AbsوAbs2 ،ا abstract هستند.

    همان طور که مشاهده می کنید، یک کلاس abstract هم می تواند تابع پیاده سازی شده و هم تابع بدون بدنه داشته باشد(مثل Abs)ا .Abs2 باوجود abstract بودن برخی توابع پدر، آنها را پیاده سازی نکرده؛ چون خود abstract است. اما Abs3 چون abstract نیست، باید همه توابع بدون بدنه پدر و جد خود را نیز پیاده سازی کند.

    کد:
    public abstract class Abs {
    	
    	public abstract void f();
    	 public int a=6;
    	 
    	 public String sFun(){
    		 return "Abstract!";
    	 }	
    }
    
    abstract class Abs2 extends Abs{
    	
    	public abstract int f2();
    		
    	
    }
    class Abs3 extends Abs2{
    	public static void main(String[]args){
    		
    }
    
    	@Override
    	public int f2() {
    		// TODO Auto-generated method stub
    		return 0;
    	}
    
    	@Override
    	public void f() {
    		// TODO Auto-generated method stub
    		
    	}
    }


    انتهای درس!

    ویرایش توسط Strange : 04-27-2012 در ساعت 07:34 AM
    "هست" را اگر قدر ندانی، می شود "بود"
    و چه تلخ است هستی که بود شود
    و دارمی که داشتم...

  2. 11 كاربر زير به خاطر اين پست سودمند از Strange عزيز تشكر كرده اند:


  3. # ADS
     

  4. #12


    Haiku آواتار ها


    رشته کارشناسی
    مهندسی کامپیوتر
    محل سکونت
    بوشهر، گنجینه ی خلیج فارس!
    پوینت
    6,214
    ارسال تشكر
    9,248
    تشكر شده 2,339 بار در 561 پست

    درسنامه ی دهم

    Interface (اینترفیس یا رابط):

    در ادامه ی بحث ارث بری در جاوا به مبحثی می رسیم به نام Interface. اینترفیس ها شباهت زیادی به کلاس های abstract دارند (با کلاس ها و متدهای abstract در درسنامه ی قبل آشنا شدید). از اینترفیس ها هم مانند کلاس های abstract نمی توانید شیء بسازید و new کردنِ یک اینترفیس خطا به دنبال دارد. یکی از تفاوت های اینترفیس ها با کلاس های abstract این است که اینترفیس ها در بدنه ی خود فقط می توانند متدهای abstract و متغیر های constant داشته باشند و اجازه ندارند که متدی را پیاده سازی کنند (یعنی در اینترفیس فقط باید الگو یا signature متدها را بنویسیم). هم چنین اینترفیس ها اجازه ی داشتنِ فیلد را هم ندارند. این درحالی است که کلاس های abstract هم می توانند فیلد داشته باشند و هم می توانند علاوه بر متدهای abstract متدهای پیاده سازی شده ی غیر abstract هم داشته باشند.
    در واقع اینترفیس ها مشخص می کنند که برنامه ی ما چه کاری را می خواهد اجرا کند، ولی نحوه ی اجرای آن کار را مشخص نمی کنند.
    از طرفی چون همه ی متدهای موجود در اینترفیس به صورت پیش فرض abstract هستند پس دیگر نیازی به استفاده از کلمه ی کلیدیِ abstract در signature متدهای اینترفیس نیست. هم چنین چون همه ی متدهای موجود در اینترفیس public هستند (چون به هرحال باید در کلاس فرزند به ارث برسند و کلاس فرزند هم باید آن ها را پیاده سازی یا override کند) می توانید از public هم در تعریف متدهای موجود در اینترفیس استفاده نکنید.
    برای تعریف اینترفیس مثلِ تعریف کلاس عمل می کنیم، با این تفاوت که به جای کلمه ی کلیدیِ class از کلمه ی کلیدیِ interface استفاده می کنیم. برای استفاده از یک اینترفیس هم یک کلاس concrete (به کلاسی که abstract نیست و می شود از آن شیء ساخت concrete می گویند) باید آن را implement کند و همه ی متدهای موجود در آن را هم override کند.

    نکته:
    کلاسی که می تواند یک interface را implement کند ولی متدهای آن را پیاده سازی نکند حتماً یک کلاس abstract است چون در غیر این صورت باید حتماً متدها در کلاس غیر abstract (یعنی همان concrete) پیاده سازی شوند.

    توجه:
    اینترفیس ها خودشان را extend می کنند، یعنی اگر یک اینترفیس بخواهد اینترفیس از اینترفیس دیگری استفاده کنید و آن را به ارث ببرد باید اینترفیس مذکور را extend کند. ولی یک کلاس برای استفاده از یک اینترفیس باید آن را implement کند.


    یک مزیت مهم اینترفیس نسبت به کلاس abstract :

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

    کد:
    public class Square extends Shape, Surface, …. !!!
    ولی بعضی مواقع واقعاً نیاز است که از محتویات چند کلاس استفاده کنیم و جاوا هم برای این مشکل راه حل دارد و همین جاست که اینترفیس وارد می شود. شما می توانید برخلاف کلاس ها، هر تعداد اینترفیس که لازم داشتید را implement کنید، فقط باید حواستان به متدهای اینترفیس ها باشد که همه را پیاده سازی کنید و چیزی را از قلم نیندازید.
    برای اینکه از چند اینترفیس استفاده کنید، پس از کلمه ی کلیدیِ implements اسامیِ اینترفیس ها را بنویسید و آن ها را با کاما از هم جدا کنید:

    کد:
    public class ClassName extends SuperClass implements FirstInterface, SecondInterface, …
    توجه:
    اینترفیس ها هم مانند کلاس ها public هستند و می توان از آن ها به عنوان type برای متغیرهایمان استفاده کنیم، پس هر اینترفیس هم باید در یک فایل جداگانه هم اسم خود اینترفیس و با پسوند .java قرار بگیرد.

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

    تفاوت اینترفیس ها با کلاس های abstract :

    1- هرکلاسی هر تعداد اینترفیس که لازم داشت را می تواند implement کند ولی فقط یک کلاس abstract را می تواند extend کند.
    2- در اینترفیس متدها نمی توانند بدنه داشته باشند ولی در کلاس های abstract متدهایِ غیرِ abstract بدنه هم می توانند داشته باشند.
    3- در اینترفیس نمی توانیم فیلد داشته باشیم ولی در کلاس abstract می توانیم.

    مثال:

    کد:
    public interface Drawable { public void draw(); }
    کد:
    public interface Colorable { public void setColor(int r, int g, int b); }
    کد:
    public abstract class Shape { private int x; private int y; public Shape() { this(0, 0); } public Shape(int x, int y) { this.x = x; this.y = y; } public void setX(int x) { this.x = x; } public int getX() { return x; } public void setY(int y) { this.y = y; } public int getY() { return y; } }
    کد:
    public class Square extends Shape implements Drawable, Colorable { public void draw() { System.out.println("The Shape we have is drawable"); } public void setColor(int r, int g, int b) { System.out.println("The RGB elements of the color of our shape is " + r + " " + g + " " + b); }
    کد:
    public class Test { public static void main(String[] args) { Square mySquare = new Square(); mySquare.draw(); mySquare.setColor(10, 20, 30); } }
    خب در این مثال ما ابتدا دو اینترفیس به نام های Drawable و Colorable تعریف کرده ایم. اینترفیس Drawable شامل یک متد به نام darw است که به دلیل abstract بودن اجازه ندارد که بدنه داشته باشد و فقط به صورت signature تعریف شده است. در اینترفیس Colorable هم یک متد به نام setColor داریم که به همان دلیل قبل فاقد بدنه است. پس اگر کلاسی بخواهد این دو اینترفیس را implement کند، باید حتماً متد موجود در آن ها را هم پیاده سازی کند. در ادامه یک کلاس abstract به نام Shape ساخته ایم که فیلدها و متدهای خود را دارد. حالا برای استفاده از این کلاس و اینترفیس های تعریف شده، کلاسی به نام Square داریم که concrete است و کلاس Shape را به ارث برده است. از طرفی این کلاس اینترفیس های Drawable و Colorable را هم implement کرده است. پس کلاس Square موظف است که متد موجود در اینترفیس ها را پیاده سازی کند، چون در غیر این صورت با خطای هنگام کامپایل روبرو می شود.
    بعد هم که این کلاس و متدها را پیاده سازی کردیم می توانیم یک شیء از کلاس Square بسازیم و از متدهای آن استفاده کنیم.

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

    کد:
    Output: The Shape we have is drawable The RGB elements of the color of our shape is 10 20 30
    روش ساختن اینترفیس در Eclipse :

    برای ساختن اینترفیس در eclipse دقیقاً باید به همان جایی بروید که از آن جا کلاس می ساختید ولی به جای انتخاب کلاس، گزینه ی Interface را انتخاب کنید. پس روی src پروژه ای که ساخته اید راست کلیک کنید و بعد هم از لیست گزینه ی new و بعد هم Interface را کلیک کنید.



    با این کار پنجره ای باز می شود که باید اسم اینترفیس را در مقابل Name بنویسید (درست مثلِ وقتی که می خواهید کلاس بسازید).



    بعد هم روی Finish کلیک کنید و یک ویرایشگر ایجاد می شود که در آن اینترفیس شما تعریف شده است.




    پایان درسنامه ی دهم



  5. 8 كاربر زير به خاطر اين پست سودمند از Haiku عزيز تشكر كرده اند:


  6. #13


    Haiku آواتار ها


    رشته کارشناسی
    مهندسی کامپیوتر
    محل سکونت
    بوشهر، گنجینه ی خلیج فارس!
    پوینت
    6,214
    ارسال تشكر
    9,248
    تشكر شده 2,339 بار در 561 پست

    درسنامه ی یازدهم

    استفاده از API جاوا

    در این درسنامه قصد داریم درباره ی روش استفاده از API جاوا توضیح دهیم که واقعاً هر برنامه نویس جاوایی باید از آن استفاده کند.
    کتابخانه ی پیش فرض جاوا شامل هزاران کلاس و اینترفیسِ از پیش نوشته است که برنامه نویسان می توانند از آن ها در برنامه های خود استفاده کنند. این کلاس ها در پکیج هایی بر اساس کارایی شان دسته بندی شده اند. برای مثال کلاس ها و اینترفیس هایی که برای کارکردن با فایل ها به آن ها نیاز دارید در پکیجی به نام java.io و کلاس ها و اینترفیس هایی که برای کارکردن با شبکه به آن ها نیاز دارید در پکیجی به نام java.net دسته بندی شده اند. API جاوا اعضای public و protected این کلاس ها و همچنین اعضای public اینترفیس ها را هم لیست کرده است. در مستندات جاوا درباره ی کارکردِ همه ی کلاس ها و اینترفیس ها توضیح داده شده است و جزئیاتی هم از کاربردِ اعضای این کلاس ها و اینترفیس ها بیان شده است. تعداد زیادی از برنامه نویسان جاوا از این مستندات به هنگام نوشتن برنامه های خود استفاده می کنند و API جاوا در واقع یکی از نقاط قوت این زبان برنامه نویسی است.

    به طور معمول برنامه نویسان مستندات جاوا را برای پیدا کردن موارد زیر جست و جو می کنند:
    1- پکیج هایی که شامل یک کلاس یا اینترفیس مشخص باشد.
    2- رابطه ای بین کلاس ها و اینترفیس های مشخص
    3- ثابت های موجود در کلاس ها و اینترفیس ها – یعنی فیلدهایی که به صورت public static final تعریف شده اند.
    4- Constructorهای یک کلاس، برای اینکه بدانند برای شیء ساختن از یک کلاس خاص به چه چیزهایی نیاز دارند.
    5- برای پی بردن به static یا غیرstatic بودنِ متدها ی یک کلاس، تعداد و نوع پارامترهایِ این متدها، return type آن ها و ...

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


    راهیابی در API جاوا:

    API جاوا را هم می توانید روی هارد کامپیوتر خود ذخیره کنید و هم می توانید آن را به صورت آنلاین ببینید. برای دانلود به [تنها کاربران قادر به مشاهده لینک ها هستند] رفته و از قسمت Java Resources می توانید مستندات جاوا را دانلود کنید. بعد از دانلود، یک فایل zip. خواهید داشت که باید آن را در مسیر نصب JDK خودتان از حالت فشرده خارج کنید و برای استفاده از آن در ویندوز به مسیر
    C:\Program Files\Java\YourJDKVersion\docs\api\index.html
    رفته و همین فایل index.html را با مرورگر خود باز کنید.

    برای مشاهده ی آنلاین مستندات هم به [تنها کاربران قادر به مشاهده لینک ها هستند] بروید.


    صفحه ی نخست:

    API جاوا به سه پنجره تقسیم شده است. پنجره ی بالایی و سمت چپ همه ی پکیج ها را به ترتیب حروف الفبا مرتب کرده است. پنجره ی سمت چپ و پایین، همه ی کلاس ها و اینترفیس ها را به ترتیب حروف الفبا لیست کرده است. برای تشخیص دادنِ اینترفیس ها از کلاس ها، اسم اینترفیس ها به صورت italic نوشته شده است. وقتی که از پنجره ی بالایی بر روی یک پکیج خاص کلیک کنید، پنجره ی پایینی همه ی کلاس ها و اینترفیس های پکیج انتخابی را نشان خواهد داد. پنجره ی سمت راست(همان پنجره ای که از همه بزرگ تر است) توضیحات مختصری درباره ی هر پکیج ارائه می دهد – این توضیحات را بخوانید تا با کاربرد کلیِ این پکیج ها آشنا شوید. اگر از پنجره ی پایینی یک کلاس یا اینترفیس را انتخاب کنید، در پنجره ی وسط اطلاعات کلاس یا اینترفیس انتخابی نمایش داده می شود.



    لینک های مهمِ موجود در صفحه ی index :

    در بالای صفحه ی نخست 4 لینک به نام های Tree ، Deprecated ، Index و Help می بینید. لینک Tree مراتب ارث بریِ همه ی پکیج ها، کلاس ها و اینترفیس ها را به صورتی درخت گونه نشان می دهد. لینک Deprecated اینترفیس ها، کلاس ها، فیلدها، constructorها و متدهایی را نمایش می دهد که دیگر نباید مورد استفاده قرار بگیرند. لینک Index کلاس ها، اینترفیس ها، فیلدها، constructorها و متدها را به ترتیب حروف الفبا نشان می دهد. لینک Help هم چگونگیِ سازمان دهیِ API را توضیح می دهد. شاید بهتر باشد که کارتان را با لینک Help شروع کنید.


    نمایش صفحه ی Index :

    اگر اسم کلاسی که به دنبال آن می گردید را نمی دانید، ولی اسم یک متد یا فیلد از آن کلاس را می دانید، می توانید از طریق لینک Index کلاس مورد نظرتان را پیدا کنید. صفحه ی Index فیلدها، constructorها ، متدها، اینترفیس ها و کلاس ها را به ترتیب الفبایی نمایش می دهد. برای مثال اگر به دنبال متد hasNextInt از کلاس Scanner هستید ولی اسم کلاسِ این متد را نمی دانید، می توانید بر روی H کلیک کنید و لیست الفباییِ همه ی آیتم هایی که در API جاوا با h شروع می شوند را در اختیار داشته باشید. متد hasNextInt را از لیست پیدا کنید. وقتی به متد مورد نظرتان رسیدید می بینید که متدهایی با نام hasNextInt به همراه اسم پکیج و کلاس آن ها لیست شده است. از اینجا با کلیک بر روی اسم کلاس می توانید تمام جزئیات کلاس مورد نظر را ببینید. همچنین با کلیک بر روی اسم متد، می توانید جزئیات متد مورد نظر را هم ببینید.








    مشاهده ی یک پکیج خاص:

    وقتی که از پنجره ی بالایی و سمت چپ صفحه اسم پکیجی را انتخاب کردید، همه ی کلاس ها و اینترفیس های موجود در آن پکیج در پنجره ی پایینی به نمایش در می آیند و به 5 بخش به نام های Interfaces ، Classes ، Enums ، Exceptions ، Errors تقسیم می شوند. به عنوان مثال در تصویر زیر محتویاتِ پکیجِ javax.swing در پنجره ی پایینی نمایش داده شده است. می توانید در پنجره ی پایینی هم روی اسم پکیج کلیک کنید تا به توضیحاتی درباره ی آن پکیج دست پیدا کنید. اگر فکر می کنید که این پکیج کلاس هایی دارد که به درد برنامه تان می خورد، پس توضیحات پکیج هم برایتان مفید خواهد بود.




    مشاهده ی جزئیات یک کلاس:

    وقتی که از پنجره ی پایین بر روی اسم یک کلاس یا اینترفیس کلیک کنید، پنجره ی وسطی جزئیاتی درباره ی آن کلاس یا اینترفیس را به شما نشان خواهد داد. ابتدا اسم پکیجی که آن کلاس در آن قرار دارد را می بینید و به دنبال آن هم سلسله مراتب ارث بریِ آن کلاس نمایش داده می شود. در ادامه، لیستِ اینترفیس هایی که این کلاس پیاده سازی کرده را می بینید و بعد هم لیستی از فرزندانِ آن کلاس آورده شده است. تصویر زیر مستندات مربوط به کلاس JButton را از پکیج javax.swing نشان می دهد. در این صفحه ابتدا اسم کلاس را می بینید و بعد سلسله مراتب ارث بریِ این کلاس و اینترفیس هایی که پیاده سازی کرده است و بعد هم فرزندانِ این کلاس.
    وقتی که مستندات یک اینترفیس را مشاهده می کنید، دیگر مراتب ارث بریِ آن اینترفیس نمایش داده نخواهد شد و به جای آن، اینترفیس های پدرِ این اینترفیس یعنی Superinterfaces و اینترفیس های فرزندِ این اینترفیس و کلاس هایی که آن را پیاده سازی کرده اند به نمایش درخواهند آمد.




    بخش خلاصه ی توضیحات (Summary) یک کلاس در صفحه ی مستندات:

    قسمت های دیگر موجود در هر صفحه ی API در زیر به صورت لیست آورده شده است. هر قسمت برای یک کلاس نمایان خواهد بود اگر کلاس مورد نظر شاملِ یک آیتم خاص باشد و یا آن آیتم خاص را به ارث برده باشد. اعضای کلاس که در قسمت خلاصه نمایش داده می شوند به صورت پیش فرض همیشه public هستند، مگر اینکه صراحتاً protected بودنِ آن ها ذکر شده باشد. درضمن اعضای private کلاس ها در مستندات نمایش داده نمی شوند چون نمی توانیم از آن ها به طور مستقیم در برنامه ی خودمان استفاده کنیم.

    1- Nested Classes :
    این قسمت خلاصه ای از کلاس های تو در تویِ public و protected را نمایش می دهد – کلاس های تو در تو کلاس هایی هستند که درون کلاس های دیگر تعریف می شوند(با این کلاس ها در درسنامه های آینده آشنا خواهید شد). تا زمانی که صراحتاً چیزی ذکر نشده باشد، این کلاس ها public و غیرstatic هستند.

    2- Filed Summary :
    این قسمت خلاصه ای از فیلدهای public و protected موجود در یک کلاس را ارئه می دهد. تا زمانی که صراحتاً چیزی ذکر نشده باشد، این فیلدها public و غیرstatic هستند. تصویر زیر هم Filed Summary را برای کلاس Color نمایش می دهد.



    3- Constructor Summary :
    این قسمت خلاصه ای برای constructorهای کلاس را ارائه می دهد. Constructorها به ارث برده نمی شوند، پس این قسمت فقط برای کلاس هایی فعال است که یک یا چند constructor داشته باشند. تصویر زیر Constructor Summary را برای کلاس JButton نمایش می دهد.



    4- Method Summary :
    این قسمت هم خلاصه ای از متدهایِ public و protected کلاس ها را نمایش می دهد. در اینجا هم تا قبل از این که صراحتاً چیزی ذکر شده باشد، متدها public و غیرstatic هستند. تصویر زیر Method Summary را برای کلاس Buffered Input Stream نمایش می دهد.




    بخش جزئیات کلاس ها (Detail) در صفحه ی مستندات:

    بعد از بخش خلاصه ها، بخش جزئیات را داریم که به طور معمول توضیحات بیش تری را درباره ی اعضای یک کلاس بیان می کند. درضمن برای قسمت کلاس های تو در تو (Nested Classes) بخش جزئیات نداریم.


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






    خسته نباشید
    ویرایش توسط Haiku : 05-05-2012 در ساعت 12:13 PM

  7. 6 كاربر زير به خاطر اين پست سودمند از Haiku عزيز تشكر كرده اند:


  8. #14


    Strange آواتار ها


    رشته کارشناسی
    مهندسی کامپیوتر
    پوینت
    1,175
    ارسال تشكر
    940
    تشكر شده 1,222 بار در 295 پست

    درسنامه دوازدهم

    ذکر و تشریح دو مثال از کاربرد interface :



    مرتب سازی :

    در دنیای واقعی وقتی می خواهید اشیا را مرتب کنید، چه می کنید؟

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

    حال فرض کنید اشیایی از تعدادی class در دسترس دارید و می خواهید آنها را نسبت به هم مرتب بچینید.

    باید به چند نکته برای این مرتب سازی توجه کرد:

    1. همه اشیا هم جنس باشند؛ یعنی یا همه از یک class درست شده باشند یا پدر مشترکی داشته باشند.
    2. به کمک هم type بودن، method یا attribute مشترکی داشته باشند تا بتوان بر اساس آن مقایسه برای مرتب سازی را انجام داد.
    3. هر شی باید بتواند خود را با شی دیگر مقایسه کند. این مقایسه در قالب پیاده سازی تابع compare صورت می گیرد.
    4. برای اطمینان از پیاده سازی compare توسط همه اشیا، همه class ها باید رابط Comparable را implement کنند.

    اگر شرایط بالا را برای همه اشیایی که قصد مرتب سازی آنها را داریم، درنظربگیریم؛ می توان یک تابع "مرتب ساز" نوشت و هر ورودی با شرایط بالا برای مرتب سازی دریافت کرد؛ بدون توجه دقیق به نوع class ها و method یا attribute مشترک بین آن ها جهت مقایسه و مرتب سازی بر اساس آن معیار.

    به عنوان قدم اول، کلاسی می نویسیم که مرتب سازی را انجام دهد:
    کد:
    public class Sorting {
    
    	public void sort(Comparable a[]){
    		
    		for(int i = 0; i < a.length; ++i){
    			for(int j=0; j < a.length -i; ++j){
    				if (a[j].compare(a[j+1]) >0 ){
    					Comparable t = a[j];
    					a[j] = a[j+1];
    					a[j+1] = t;
    				}
    			}
    		}
    	}
    }
    کلاس Sorting تابعی به نام sort دارد که با دریافت آرایه ای از جنس Comparable ، عناصر آن را نسبت به هم مرتب می کند.
    اما چگونه؟
    حلقه for بیرونی i را از صفر تا n-1 را تنظیم می کند. در هر مرحله با توجه به i، به کمک حلقه درونی، روی عناصر آرایه از عنصر صفرم تا n-i ام حرکت می کند و درصورتی که نتیجه ی مقایسه آن عنصر با عنصر بعدی، بزرگ تر بودن عنصر جاری بود، جای آن دو به کمک t عوض می شود.

    اگر بخواهید می توانید آرایه را پس از مرتب سازی، قبل از اتمام تابع برگردانید( return کنید)
    البته باید اشاره کرد که توابع مختلفی برای مرتب سازی وجود دارد و الزامی به استفاده از این روش (روش مرتب سازی حبابی) نیست. اگر مایل باشید می توانید الگوریتم های مرتب سازی دیگر مثل insertionSort یا selectionSort یا ... استفاده کنید.
    اما چون این درسنامه مربوط به انواع الگوریتم های مرتب سازی نمی شود، از توضیح بیشتر صرف نظر می کنم.

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

    برای مثال:


    مرتب سازی دانشجویان بر اساس شماره دانشجویی:

    از شما خواسته شده دانشجویان را مرتب کنید. برای این مرتب سازی چند مورد را باید چک کنید.
    1. همه دانشجو هستند.
    2. همه شماره دانشجویی دارند .

    پس اجازه داریم آنها را مقایسه کنیم.

    برای این مقایسه ،همه این کلاس ها باید Comparable را implement کنند --> مطمئنیم همگی compare را پیاده سازی می کنند.


    ابتدا Comparable را پیاده سازی می کنیم. البته می توان از Comparable موجود در java.lang هم استفاده کرد.

    کد:
    public interface Comparable {
    
    	public int compare(Comparable o);
    }

    پیاده سازی کلاس Student:

    کد:
    public class Student implements Comparable {
    public Student(int studentID){
    		 this.studentID=studentID;		 
    	 }
    	 private int studentID;
    	 public int compare(Comparable o){
    		 if (o instanceof Student) {
    			Student s = (Student) o;
    			
    			if(this.studentID==s.studentID)
    				return 0;
    			if(this.studentID>s.studentID)
    				return 1;
    			return -1;
    		}
    		 return -2;
    		 
    	 }
    
    }
    همان طور که گفتم، این کلاس شامل تابع compare می باشد. درصورتی که جنس واقعی ورودی برای مقایسه، از جنس Student باشد، مقایسه می کند شماره دانشجویی دانشجو از شماره دانشجویی دیگری بزرگ تر، مساوی یا کوچک تر است و طبق قرارداد برای هریک از حالات به ترتیب 1 و 0 و 1- برمی گرداند. البته درصورتی که ورودی از جنس Student نباشد، 2- را برمی گرداند.


    خب حالا main برنامه را ببینیم:


    کد:
     public static void main(String args[]){
    		 
    		 Student a[]=new Student[4];
    		 a[0]= new Student(6895457);
    		 a[1]= new Student(1089332);
    		 a[2]= new Student(3509853);
    		 a[3]= new Student(1000014);
    		 
    		 Sorting s= new Sorting();
    		 s.sort(a);
    	 }
    در main برنامه، چهار دانشجو با شماره دانشجویی های منحصربه فرد، درآرایه ای ذخیره شدند و با ساختن شی از Sorting این آرایه برای مرتب سازی ، به تابع sort فرستاده می شود.

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


    خب، مثالی که بررسی شد برای حالتی بود که همه اشیا از جنس یک class بودند. (از جنس Student)

    اکنون می خواهیم مثالی را بررسی کنیم که اشیا پدرمشترک دارند.
    باز هم همان مثال Shape و Circle وSquare و Triangle در درنظر بگیرید.

    اگر Shape را به شکل زیر پیاده سازی کنیم:

    کد:
    public  abstract class Shape implements Comparable{
    
    	private int x;
    	private int y;
    	public int getX() {
    		return x;
    	}
    
    	public void setX(int x) {
    		this.x = x;
    	}
    	public int getY() {
    		return y;
    	}
    	public void setY(int y) {
    		this.y = y;
    	}
    	
    	public void move(int x,int y){
    		this.x += x;
    		this.y += y;
    	}
    	
    	public abstract void draw();
    	
    	public int compare(Comparable o) {
    		
    		if (o instanceof Shape){
    			Shape s = (Shape)o;
    			if (this.getX() == s.getX()){
    				return 0;
    			} else if (this.getX() > s.getX()){
    				return 1;
    			} 
    			return -1;
    		}
    		
    		return -2;
    	}
    	
    }
    همه فرزندان Shape دارای تابع compare برای مقایسه هستند و همه آنها متغیر x برای مقایسه دارند. (اینجا، معیار مقایسه متغیر x قرار گرفته شده است)


    پیاده سازی Square را ببینید:
    کد:
    public class Square extends Shape {
    
    	private int l;
    	
    	public void draw() {
    		System.out.println("x = "+this.getX() + " y = "+this.getY() + " l = "+this.l);
    
    	}
    
    	public int getL() {
    		return l;
    	}
    
    	public void setL(int l) {
    		this.l = l;
    	}
    	
    	
    }
    فرزندان دیگر نیز به شکل مشابهی (نه به شکل یکسان) پیاده سازی می شوند. هرکدام ممکن است attribute یا method مخصوص به خود را داشته باشد یا draw را به شکل خاصی پیاده سازی کند. اما مطمئن هستیم که همه compare برای مقایسه دارند.

    توجه1: دراین مثال، attribute کلاس Triangle متغیر T می باشد و R متغیر کلاس Circle است.

    توجه2: تابع Sorting اینجا نیز قابل استفاده است . چون آرایه ای که می خواهیم به تابع sort آن بدهیم استاندارد است.

    main برنامه:
    کد:
    	public static void main(String args[]){
    		Shape ar[]=new Shape[3];
    		
    		ar[0]= new Circle();
    		ar[1]= new Square();
    		ar[2]= new Triangle();
    		
    		ar[0].setX(8);
    		ar[0].setY(32);
    		((Circle)ar[0]).setR(5);
    		
    		ar[1].setX(12);
    		ar[1].setY(14);
    		((Square)ar[1]).setL(11);
    		
    		ar[2].setX(7);
    		ar[2].setY(3);
    		((Triangle)ar[2]).setT(10);
    		
    		Sorting s=new Sorting();
    		s.sort(ar);
    		
    	}
    با توجه به اینکه مرتب سازی براساس x صورت می گیرد، عناصر موجود در آرایه a ، پس از مرتب سازی به ترتیب زیر خواهند بود:

    کد:
    Triangle (x=7)
    Circle (x=8)
    Square (x=12)

    پایان درسنامه!
    "هست" را اگر قدر ندانی، می شود "بود"
    و چه تلخ است هستی که بود شود
    و دارمی که داشتم...

  9. 6 كاربر زير به خاطر اين پست سودمند از Strange عزيز تشكر كرده اند:


  10. #15


    Strange آواتار ها


    رشته کارشناسی
    مهندسی کامپیوتر
    پوینت
    1,175
    ارسال تشكر
    940
    تشكر شده 1,222 بار در 295 پست

    درسنامه سیزدهم

    دو مثال و یک تعریف :




    مثال: می خواهیم بدانیم چند object از جنس Square در پروژه ساخته شده است.

    از ما خواسته شده تعداد اشیایی که از یک کلاس ساخته می شود را بشماریم. چگونه می توان متوجه شد که تا کنون چند شی از یک کلاس ساخته شده؟
    برای رسیدن به پاسخ، می توان از constructor کلاس استفاده کرد. وقتی از یک کلاس با استفاده از کلمه کلیدی new شی می سازیم، درواقع از برنامه میخواهیم که به constructor آن کلاس مراجعه کند و علاوه بر ساختن نمونه ای از آن کلاس، دستورات آن را اجرا کند. اگر در constructor کلاس شمارنده ای قرار دهیم، هر دفعه پس از ساخت شی، یکی به آن اضافه می شود . اما یک مسئله مهم مطرح می شود، اینکه وقتی شی جدید می سازید، شمارنده (attribute در سطح کلاس، که می توان به مقدار آن افزود) جدیدی ایجاد می کنید . این شمارنده جدید دقیقا متعلق به شی ساخته شده ی جدید است. یعنی اگر شما مقدار اولیه شمارنده را صفر بگیرید (که نماینده ی مفهوم نداشتن شی از کلاس باشد)، پس از یک بار شی ساختن، مقدارش یک می شود اما وقتی برای بار دوم از آن new میکنید، توقع نداشته باشید که دو شود. چون برای شی جدید فیلدهای جدیدی جهت set کردن متغیرهایش گرفته می شود.پس شی دوم نیز دارای شمارنده یک، بعد از خروج از constructor می شود.
    در جمله ای کوتاه می توان گفت، هر شی فیلدهای مخصوص به خود دارد و به اشیای دیگر وابسته نیست. پس باید این شمارنده طوری ذخیره شود که وابسته به شی نباشد، بلکه به کلاس وابسته شود.
    اگر شمارنده را static بگیریم مشکل حل می شود. چون یک متغیر static وابسته به کلاسش است و با هربار شی ساختن از کلاس دچار تغییر نمیشود. چون اصولا فیلدی برای آن مخصوص شی درنظر نمی گیرد. بلکه همان ابتدای کار و با ساخته شدن کلاس، فیلدی برای آن مشخص می شود.

    به کدهای زیر توجه کنید:
    کد:
    class Square extends Shape {
    
    	private static int counter=0;
    
    	public Square (){
    
    	++ counter;
    	}
    
    	public static int getCounter(){
    	return counter;
    	}
    
    	public static void setCount( int counter){
    	Square.counter=counter;
    
    	}
    	}
    همون طور که گفتم، متغیر را باید استاتیک تعریف کرد (که وابسته به شی نباشه)
    برای اینکه نتوان از خارج از کلاس به آن دسترسی داشت و آن را تغییر داد، private تعریف شده.
    در constructor هم یک واحد بهش اضافه می کنیم، چون هربار که constructor صدا زده بشه، یک شی ازش ساخته میشه.
    Setter و Getter را public تعریف کردم، اما اگر می خواهید از خارج از کلاس نتوان مقدارش را تغییر داد، باید Setter را private کرد.
    Setter و Getter را static تعریف کردیم که بتوانیم از روی اسم کلاس آنها را صدا بزنیم و وابستگی به شی را ازبین ببریم.
    همان طور که می دانید، یک متغیر استاتیک را هم می توان از روی اسم کلاس و هم از روی شی ساخته شده از آن صدا زد؛ اما اینجا، در Setter نمیتوان چنین کرد، چون در یک تابع static هستیم. (در درسنامه ششم درمورد متدها و متغیرهای static توضیح داده شده است)

    پس برنامه ای نوشته ایم که تعداد اشیا ساخته شده از کلاس Square را در متغیر static به نام counter ذخیره می کند.
    اگر main برنامه چنین باشد:

    کد:
    public static void main(String args[]){
    	Shape s= new Square ();
    	Shape s1= new Square ();
    	Square s2= new Square ();
    
    	System.out.println(Square.getCounter());
    }
    خروجی 3 خواهد بود؛ چون سه بار از Square شی ساخته ایم.



    مثال: می خواهیم اجازه دهیم فقط یک شی از کلاس Square ساخته شود و اگر کسی خواست شی جدیدی بسازد، همان شی قبلی فرستاده شود.

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

    کد مربوطه آن را ببینید:
    کد:
    class Square extends Shape {
    
    	private static Square n= null;
    	
    	private Square(){
    		
    	}
    	
    	public static Square getN(){
    		if(n==null)
    			n= new Square();
    		
    		return n;
    		
    	}
    	}
    فیلدی برای ذخیره شی از جنس Square درنظر کرفته شده و مقدار اولیه آن null قرار داده شده است.
    دلیل static تعریف کردن آن هم مشخص است.(عدم وابستگی به شی)
    constructor هم private تعریف شده تا از بیرون کلاس صدا زده نشود.
    تابعی که با آن می توان از کلاس شی ساخت نیز static تعریف شده تا اگر تاکنون شیئی از کلاس نداشته ایم مشکلی نباشد.
    شرط موجود در آن نیز تنها درصورتی شی میسازد که تاکنون شیئی ساخته نشده باشد، اگر چنین نباشد، همان شی قبلی را می فرستد.

    main برنامه:
    کد:
    public static void main(String args[]){
    
    
    	Square s= Square.getN();
    }



    دسترسی به آدرس شی ساخته شده از یک کلاس در کلاس دیگر:


    فرض کنید کلاس A و B را دارید و می خواهید از B در A شی بسازید و پس از آن تابعی در B را صدا بزنید. از طرف دیگر می خواهید در B به فیلدهای کلاس A دسترسی داشته باشید. برای حل این مشکل چه می کنید؟
    یکی از راه های حل این مشکل فرستادن آدرس کلاس A به عنوان پارامتر تابع است .
    به شکل زیر:

    کد:
    b= new B (this);
    این کد در کلاس A نوشته شده و آدرس A ، به عنوان پارامتر constructor داده شده است.
    این یک راه حل برای حل مسئله است. اما را دیگری هم وجود دارد.


    inner class :

    inner class ، کلاسی است که در کلاس دیگر نوشته شده باشد. همان طور که میتوان به یک کلاس، attribute ها و method هایی نسبت داد، می توان درون آن کلاس دیگری هم نوشت.

    کد:
    class A{
    
    class B{
    
    int n;
    }
    
    }
    کلاس B یک inner class است. چون درون کلاس A تعریف شده است.
    اگر B به صورت private تعریف شود، فقط از طریق A قابل دسترسی است. یعنی ازطریق new کردن میتوان از آن شی ساخت.
    کلاس B میتواند به همه attribute ها و method های A دسترسی داشته باشد (بدون نیاز به شی ساختن از آن کلاس) ولی عکس آن درست نیست.
    اگر از روی کلاس داخلی، تابعی را که هم در A و هم در B تعریف شده است ، صدا بزنیم، اولویت با تابع موجود در کلاس داخلی است. (درست مثل رابطه پدر-فرزندی که از پایین به بالا، توابع چک می شدند)
    اگر فیلد private در کلاس A داشته باشیم، در B قابل دسترسی است ، درحالی که اگر رابطه پدر-فرزندی داشتند (inheritance ) دسترسی به آن ممکن نبود، هرچند به ارث برده می شد.

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

    مثلا برای صدا زدن n موجود در کلاس B وقتی در A هستیم:

    کد:
    B b= new B();
    	b.n;
    صدا زدن n موجود در کلاس B وقتی در A نیستیم:

    کد:
    A.B b= new A.B();
    	b.n;

    ابتدا شیئی از کلاس B ساخته شده و سپس n از روی آن صدا زده شده است.
    بنابراین با استفاده از inner class توانستیم به فیلدها و متدهای یک کلاس درکلاس دیگر، بدون ارسال آدرس دسترسی داشته باشیم.(در واقع دسترسی به A، وقتی در B هستیم)


    خسته نباشید
    "هست" را اگر قدر ندانی، می شود "بود"
    و چه تلخ است هستی که بود شود
    و دارمی که داشتم...

  11. 9 كاربر زير به خاطر اين پست سودمند از Strange عزيز تشكر كرده اند:


  12. #16


    Haiku آواتار ها


    رشته کارشناسی
    مهندسی کامپیوتر
    محل سکونت
    بوشهر، گنجینه ی خلیج فارس!
    پوینت
    6,214
    ارسال تشكر
    9,248
    تشكر شده 2,339 بار در 561 پست

    درسنامه ی چهاردهم

    کنترل استثناها در جاوا (Exception Handling)

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

    کد:
    public static void main(String[] args) { divide(40, 20); } public static int divide(int x, int y) { if(y != 0) return x / y; else return Integer.MAX_VALUE; }
    در این جا یک متد به نام divide داریم که دوپارامتر int به عنوان ورودی می گیرد و خروجیِ متد هم int است. در بدنه ی متد با دستور کنترلیِ if کنترل کرده ایم که مقسومٌ علیه ما صفر نباشد ولی به قسمت else توجه کنید. از آن جایی که return type متد ما int است پس مجبوریم هرطور که شده یک مقدار int را برگردانیم ولی برای زمانی که مقسومٌ علیه ما صفر است، ما بزرگ ترین عدد int موجود را برگردانده ایم؛ از طرفی خود این بزرگترین عدد int هم یک عدد است و ممکن است خود جواب یک تقسیم باشد. پس راه خوبی برای کنترل استثنایِ تقسیم بر صفر به کار نبرده ایم. در جاوا کلاسی داریم به نام Throwable . هرکلاسی که می خواهد در مکانیزم Exception Handling مورد استفاده قرار بگیرد باید به صورت مستقیم یا غیر مستقیم کلاس Throwable که در پکیجِ java.lang قرار دارد را extend کند.

    کلاس Throwable دو زیرکلاس به نام های Exception و Error دارد.
    کلاس Exception و زیرکلاس های آن مانند RuntimeException یا IOException ، یک وضعیت استثنا که امکان دارد در یک برنامه ی جاوا به وقوع بپیوندد و از طریق برنامه قابل کنترل باشد را شامل می شود.
    کلاس Error و زیرکلاس های آن هم شامل حالت های غیرعادی است که امکان دارد برای JVM اتفاق بیفتد.

    ما فعلاً با کلاس Error کاری نداریم و توجه خود را به نحوه ی استفاده از کلاس Exception معطوف می کنیم. اجازه دهید همان مثال تقسیمِ ابتدای درسنامه را این بار با سیستم کنترل استثنای جاوا پیاده سازی کنیم و بعد درباره ی آن توضیح خواهیم داد.

    کد:
    public static void main(String[] args) { divide(20, 10); } public static int divide(int x, int y) { try{ if(y == 0) throw new Exception(); return x / y; }catch(Exception e) { e.toString(); return -1; } }
    برای استفاده از مکانیزم Exception Handling ، آن قسمت از کدمان که امکان دارد در آن exception رخ دهد را در بلاکی به نام try قرار می دهیم. به دنبال هر try می توانیم یک یا چند catch داشته باشیم که وظیفه ی آن ها کنترلِ استثنایِ رخ داده در بلاکِ try است. catch برای انجام عملیات خود به یک شیء از کلاس Exception و یا فرزندانِ آن نیاز دارد. در مثال بالا در try با استفاده از throw یک شیء از کلاس Exception ساخته و آن را برای catch فرستاده ایم. هرگاه که y برابر با صفر باشد throw فعال شده و وقتی خط throw اجرا شد، دیگر کدهای زیر throw که در try هستند اجرا نمی شوند و کنترل برنامه به catch می رسد که مسئولیت کنترل استثنایِ ایجاد شده را برعهده دارد. از این به بعد تمام بدنه ی catch اجرا می شود و بعد از آن اجرای برنامه از اولین خط بعد از بلاکِ catch ادامه پیدا می کند.

    بعد از هر try باید حداقل یک catch یا بلاکِ finally داشته باشیم (در ادامه با finally آشنا خواهید شد) و این یعنی بیشتر از یکی هم می توانیم داشته باشیم. در پرانتز جلوی هر catch نوع exception رخ داده را مشخص می کنیم و یک متغیر داریم که آدرس شیء را برای استفاده در catch به عنوان پارامتر در آن می ریزیم. در مثال قبل در catch از حالت کلیِ Exception استفاده کردیم. از آن جایی که در حال کنترلِ صفر شدنِ مقسومٌ عیله هستیم، می توانیم از یکی از زیرکلاس های Exception به نام ArithmeticException استفاده کنیم. ArithmeticException شامل استثناهای محاسباتی از جمله صفر بودنِ مقسومٌ عیله می شود که این کار کنترلِ استثنای ما را نسبت به حالت قبل دقیق تر می کند. برای این کار در قسمت throw با می نوشتیم:

    کد:
    throw new ArithmeticException();
    و برای catch هم داشتیم:

    کد:
    catch(ArithmeticException e)

    وقتی چند بلاکِ catch داشته باشیم، هنگامی که برنامه به خط throw رسید دقیقاً همان catchی اجرا می شود که پارامترِ آن با استثنایی که throw شده یکی است و یا آن catchی اجرا می شود که پارامترِ آن یکی از اجدادِ استثنایِ throw شده باشد. در این حالت سایر catchها اجرا نمی شوند و فقط همان catchی اجرا می شود که type آن با استثنای throw شده همخوانی دارد.

    دقت کنید که هر بلاکِ catch فقط می تواند یک پارامتر داشته باشد و نوشتن بیش از یک پارامتر خطای هنگام کامپایل در پی خواهد داشت. به طور معمول و بدون کنترل استثنا وقتی یک exception رخ می دهد برنامه بسته می شود و به کار خود پایان می دهد ولی با کنترل استثناها می توانیم از پایان کار برنامه جلوگیری کنیم تا برنامه سایر عملیات خود را هم انجام دهد. وقتی یک exception بدون کنترل رخ دهد چند خط اطلاعات در خروجی چاپ می کند که Stack Trace نام دارند. این اطلاعات شامل اسم exception رخ داده و جزییاتی از اینکه exception در کدام قسمت برنامه رخ داده است می شود.

    توجه: جاوا اجازه ی تقسیم بر صفر را در محاسبات اعداد int نمی دهد و وقتی این اتفاق رخ دهد یک ArithmeticException ارسال خواهد شد. ولی جاوا اجازه ی تقسیم بر صفر را در مقادیر float می دهد. این عمل یا حاصلش مثبت بی نهایت است یا منفی بی نهایت که در جاوا این حاصل به صورت float نگه داری می شود ولی به صورت یک رشته به شکل Infinity یا Infinity- نمایش داده می شود. همچنین اگر 0.0 را بر 0.0 تقسیم کنید حاصلش NAN یعنی Not a Number می شود که باز هم به در جاوا به صورت یک مقدار float نگه داری می شود ولی به صورت NaN نمایش داده می شود.


    فرآیند ارث بری Exception در جاوا:

    قسمتی از سلسله مراتب ارث بریِ زیر رده های کلاس Exception در تصویر زیر نشان داده شده است. هرکدام از این کلاس ها استثناهای خاصی را کنترل می کنند.




    سفارشی سازیِ Exceptionها :

    شما می توانید خودتان هم کلاس هایی تعریف کنید که به وسیله ی آن exceptionهای جدیدی تعریف کنید و از آن ها در کنترل استثناها استفاده کنید. فقط توجه داشته باشد که کلاس مورد نظر حتماً باید بنا به نیاز، کلاس Exception یا یکی از زیرکلاس های این کلاس را extend کند. برای کلاس exception جدید فقط به چهار constructor نیاز دارید. یکی که هیچ پارامتری نداشته باشد و یک پیام پیش فرض را به constructor کلاس پدر بفرستد. یکی که یک پیام دریافت کند و آن را به constructor کلاس پدر بفرستد. یکی که یک پیام به همراه یک شیء از کلاس Throwable دریافت کند و هر دو را به constructor کلاس پدر بفرستد و یکی هم که فقط یک شیء از کلاس Throwable بگیرد و آن را به constructor کلاس پدر بفرستد.
    مثلاً خودمان برای کنترل استثنای تقسیم بر صفر و همچنین کنترل اینکه دو عدد مورد نظر ما منفی نباشند می توانیم دو کلاس به صورت زیر تعریف کنیم.

    کد:
    public class DivideByZeroEx extends Exception { public DivideByZeroEx() { super("Divide by Zero Exception occurs"); } public DivideByZeroEx(String message) { super(message); } public DivideByZeroEx(String message, Throwable throwable) { super(message, throwable); } public DivideByZeroEx(Throwable throwable) { super(throwable); } }
    کد:
    public class NegativeEx extends Exception { public NegativeEx() { super("Negative Exception occurs"); } public NegativeEx(String message) { super(message); } public NegativeEx(String message, Throwable throwable) { super(message, throwable); } public NegativeEx(Throwable throwable) { super(throwable); } }
    حالا برای استفاده از این typeهای جدید که به وسیله ی خودمان ایجاد شده است می توانیم اینگونه بنویسیم:

    کد:
    public static void main(String[] args) { divide(10, 0); } public static int divide(int x, int y) { try { if(x < 0 || y < 0) throw new NegativeEx(); if(y == 0) throw new DivideByZeroEx(); return x / y; }catch(DivideByZeroEx e) { System.out.println(e); }catch(NegativeEx e) { System.out.println(e); } return -1; }
    اینجا در try شرط رخ دادنِ هر دو exception مورد نظر ما بررسی شده است و exceptionهای مورد نظر هم throw شده اند و برای هرکدام هم catch مخصوص به خودش را نوشته ایم که exception مورد نظر را کنترل کند.


    استفاده از کلمه ی کلیدیِ throws :

    روش دیگر کنترل استثنا استفاده از عبارت throws است. عبارت throws بعد از لیست پارامترهای یک متد و قبل از بدنه ی آن قرار می گیرد و شامل یک لیست از exceptionهایی است که با کاما از هم جدا شده اند و امکان دارد برای متد ما اتفاق بیفتد. در این حالت استثنا را کنترل نمی کنیم و فقط می گوییم که در متد ما ممکن است این لیست از استثناها رخ دهد و کنترل آن را برعهده ی متدی می گذاریم که متد ما را صدا زده است. اگر هیچ متدی exceptionهای متد ما را catch نکند، در نهایت exceptionها به JVM می رسند و JVM با گرفتنِ آن ها به برنامه پایان می دهد.

    کد:
    public static void main(String[] args) { try { method1(); }catch(Exception e) { System.err.println(e); } } public static void method1() throws Exception { }
    در این قسمت متد ما یک Exception در قسمت throws دارد و آن هم در main و در همان جایی که متد صدا زده شده است، کنترل شده.

    نکته1: از System.err که Standard Error Stream هست هم می توانید برای نمایش یک exception استفاده کنید. System.err متدهای printی دارد که شبیه متدهای System.out هستند.

    نکته2: اگر کلاسی متدی را از کلاس پدرش override کند، این خطاست اگر متد موجود در کلاس فرزند exceptionهای بیش تری نسبت به متد موجود در کلاس پدر را در لیست throws خود قرار دهد. البته استفاده از زیر مجموعه ای از استثناهای throws شده، مشکلی ندارد.

    اگر به ارث بریِ Exception دقت کنید یک کلاس به نام RuntimeException می بینید . نکته ای که اینجا وجود دارد این است که همه ی متد ها به صورت پیش فرض در لیست throws خود کلاس RuntimeException را throws می کنند و دیگر نیازی به نوشتن آن نیست. RuntimeException شامل همین exceptionهای معمول است که زیاد اتفاق می افتند.


    استثناهای Checked و Unchecked :

    جاوا بین استثناهای Checked و Unchecked تفاوت قائل است و این بسیار اهمیت دارد چون استثناهای Checked باید به طور جدا تعریف شوند. تمام کلاس هایی که کلاس Exception ولی نه RuntimeException را به ارث می برند، Checked هستند. این exceptionها exceptionهایی هستند که تحت کنترل برنامه نیستند و نیاز است که خودمان آن ها را تعریف کنیم و برای throws کردن، آوردنِ اسمشان ضروری است.

    اگر متد شما متدی دیگر را صدا زد که Checked exception داشت، این exception یا باید throws شود و یا باید catch شود ولی اگر می توان این استثنا را در خود متد به طوری منطقی کنترل کرد، بهتر است که متد آن را catch کند تا اینکه آن را throws کند و catch کردن را به عهده ی متدهای صدا زننده بیندازد.


    کنترل کردن استثنایی از جنس کلاس فرزند:

    اگر یک بلاکِ catch به گونه ای نوشته شده باشد که بتواند استثناهایی از typeهای کلاس های پدر را بگیرد، مطمئناً می تواند typeهای فرزندِ این استثناها را هم کنترل کند. از طرفی هم اگر چند catch داشته باشم که با exception ارسالی هماهنگ باشند، فقط اولین catchی که هماهنگ باشد عمل می کند و وقتی بدنه ی catch تمام شد سایر catchها رد می شوند و اجرا نمی شوند. ضمناً نوشتن catchهایی که دقیقاً typeهای یکسانی را کنترل می کنند، خطاست. دقت کنید که منظور از catchها در این جا catchهایی است که برای یک try نوشته شده باشد و موارد فوق برای tryهای جداگانه مشکلی ندارد ولی کلاً بهتر این است که try-catchها در برنامه زیاد نشوند چون موجب شلوغی و گُنگ شدن برنامه می شوند. بهتر است یک try داشته باشیم و به دنبال آن همه ی catchهای مورد نیاز را بیاوریم.

    گرفتنِ یک exception از type کلاس پدر می تواند ما را مطمئن کند که تمام فرزندانِ این exception هم catch خواهند شد، پس اگر بعد از همه ی catchهای خود یک catch با type کلاس پدرِ exceptionها داشته باشیم، مطمئن خواهید شد که هیچ گاه exception اتفاق افتاده بدونِ کنترل رها نمی شود.


    finally Block :

    finally یک بلاک اختیاری است. به صورت معمول بعد از آخرین catch می توانیم finally داشته باشیم و اگر هیچ catchی نداشتیم، finally بلافاصله بعد از try می آید. از مزیت ها و تفاوت های finally نسبت به catch این است که همیشه اجرا می شود حتی اگر exception رخ ندهد و یا exception رخ دهد و به وسیله ی یکی از Catchها کنترل شود. دستورهای break و continue و return هم مانع از اجرای finally نمی شوند. finally فقط در یک حالت اجرا نمی شود و آن هم استفاده از System.exit است که به وسیله ی آن کلاً اجرای برنامه پایان می یابد.

    توجه: اگر catch یک exception دیگر throw کند باز هم finally اجرا می شود و کنترل exception به عهده ی try بیرونی ترِ بعدی می افتد.

    از آن جایی که finally همیشه اجرا می شود، معمولاً حاوی کدهایی است که به منظور برگرداندن منابع (resource-release code) استفاده می شوند. finally یکی از بهترین جاهایی که وسیله ی آن می توان حافظه و منابع گرفته شده در try را رها سازی کرد. مثلاً در مبحث فایل ها وقتی یک فایل باز می کنیم، پس از اتمام کارمان باید حتماً فایل را ببندیم. اگر کدِ بستنِ فایل را در finally بنویسیم همیشه مطمئن خواهیم بود که اجرا می شود و فایل ما هم بسته می شود.

    نکته: اگر Exception گرفته نشود و تا finally پیشروی کند و خودِ finally هم یکی exception دیگر که در finally گرفته نمی شود را throw کند، exception قبلی از بین خواهد رفت و exceptionی که در finally فرستاده شده است برای catch شدن استفاده خواهد شد.


    گرفتن اطلاعات از شیئی که از Exception می سازیم:

    وقتی که بر روی یک شی از کلاس Throwable متد toString را صدا بزنیم، یک String خواهیم داشت که حاویِ پیامی است که در constructor آن نوشته ایم. مثلاً اگر شیء را این گونه new کنیم:
    کد:
    throw new Exception(“Message”);
    آن گاه همین عبارت Message را خواهیم داشت و اگر constructor را خالی بگذاریم اسم کلاس نمایش داده خواهد شد. همچنین یک متد هم به نام getMessage وجود دارد که همین پیام نوشته شده در constructor را از exception برمی گرداند.

    کلاس Throwable متد دیگر هم به نام printStackTrace دارد که Stack Trace را در خروجی چاپ می کند.(Stack Trace را از ابتدای درسنامه به یاد دارید؟ )



    دو ویژگی جدید در Java SE 7 :


    کنترلِ چند Exception در یک catch

    اگر بدنه ی چند catch یکسان باشد و یا برای کنترل چند استثنا می خواهید یک کار یکسان انجام دهید می توانید از این قابلیت جدید که در Java SE 7 اضافه شده است استفاده کنید و چند type مختلف را با یک catch بگیرید و یک کار یکسان رویِ آن ها انجام دهید. نحوه ی استفاده از این قابلیت به شکل زیر است:

    کد:
    catch(Type1 | Type2 | Type3 e)
    هر type به وسیله ی یک خط عمودی جدا می شود. هر تعداد type از کلاس Throwable و فرزندانِ آن را می توانید در این catch بنویسید.


    Try با قابلیت بازگردانیِ اتوماتیکِ منابع

    معمولاً کد بازگردانیِ منابع را در finally قرار میدهیم که مطمئن باشیم که همیشه اجرا می شود. حال در Java SE 7 مکانیزم جدیدی وجود دارد که این کار را ساده تر کرده است و آن نوع جدیدی از try است. برای این کار یک یا چند شیء که به آن ها نیاز دارید و بعداً هم باید بازگردانی شوند را در جلوی try و دورن پرانتز تعریف کنید و بعد به طور خودکار پس از پایانِ کارِ try ، منابع مورد استفاده بازگردانده خواهند شد. فقط باید دقت کنید که شیء های این قسمت باید از کلاس هایی باشند که اینترفیس AutoCloseable را پیاده سازی کرده اند و متد close دارند. حالت کلیِ استفاده از این try به شکل زیر است.

    کد:
    try(ClassName theObject = new ClassName()) { //use theObject here }catch(Exception e) { //catch exceptions that occur while using theObject }
    در این جا try به صورت خودکار متد close را روی شیء ما صدا می زند. می توانید چند منبع را در try تعریف کنید، فقط کافیست آن ها را با ( ; ) از هم جدا کنید.






    پایان درسنامه

    ویرایش توسط Haiku : 05-17-2012 در ساعت 09:54 AM

  13. 12 كاربر زير به خاطر اين پست سودمند از Haiku عزيز تشكر كرده اند:


صفحه 2 از 2 نخستنخست 12

اطلاعات موضوع

کاربرانی که در حال مشاهده این موضوع هستند

در حال حاضر 1 کاربر در حال مشاهده این موضوع است. (0 کاربران و 1 مهمان ها)

موضوعات مشابه

  1. پاسخ: 4
    آخرين نوشته: 08-02-2012, 11:36 AM
  2. جزوه آموزشی میکروکنترلر 8051 +پروژه های آموزشی
    توسط Zahra در انجمن جزوات و گزارش کار
    پاسخ: 0
    آخرين نوشته: 03-16-2012, 08:46 PM
  3. Rosetta Stone – آموزش زبان های زنده دنیا در سطوح آموزشی مختلف
    توسط Sales در انجمن فروشگاه لیان پرتال
    پاسخ: 0
    آخرين نوشته: 12-15-2011, 08:24 PM
  4. آموزش کامل سیم کشی ساختمان-آموزش ویدئویی به همراه Ebook
    توسط Sales در انجمن فروشگاه لیان پرتال
    پاسخ: 0
    آخرين نوشته: 10-19-2011, 07:53 PM
  5. پاسخ: 4
    آخرين نوشته: 08-10-2011, 04:46 PM

User Tag List

کلمات کلیدی این موضوع

Bookmarks

مجوز های ارسال و ویرایش

  • شما نمیتوانید موضوع جدیدی ارسال کنید
  • شما امکان ارسال پاسخ را ندارید
  • شما نمیتوانید فایل پیوست کنید.
  • شما نمیتوانید پست های خود را ویرایش کنید
  •  
stats online