Java/შესავალი Java-ში/Java-ზე პროგრამირების ელემენტები

Java–ზე ყველა პროგრამა იწერება კლასის გამოცხადების შიგნით. ამ თავში არ ჩავეძიებით თუ რა არის კლასი ან მისი გამოცხადება. ჩვენ ვისწავლით მხოლოდ კლასის შედგენის ზოგად შაბლონს, რომელსაც გამოვიყენებთ მთელი თავის მანძილზე. კლასებთან მუშაობას შემდეგი თავიდან დავიწყებთ.

მარტივი პროგრამის შაბლონი

პროგრამა Java-ში იწერება კლასის ტანის შიგნით. კლასი ამ ეტაპზე ჩვენთვის წარმოადგენს რაღაც აბსტრაქტულ ცნებას, რომელსაც გააჩნია სახელი. ამაზე მეტის ცოდნა კლასების შესახებ ამ ეტაპზე არ დაგვჭირდება.

კლასის სახელი შეგიძლიათ ნებისმიერად შეარჩიოთ. თუმცა არის გარკვეული შეზღუდვებიც. ასე, მაგალითად, არ შეიძლება კლასის სახელში ცარიელი ადგილის სიმბოლოს გამოყენება ან სახელის ციფრით დაწყება. არის კიდევ რიგი სხვა შეზღუდვებისა, რომლებსაც შემდეგ თავში გამოვავლენთ. აგრეთვე მიღებულია რომ კლასის სახელები მთავრული ასოთი იწყებოდეს. თუ კლასის სახელი რამოდენიმე სიტყვისაგან შესდგება მაშინ თითოული სიტყვა ისევ მთავრული ასოთი უნდა დაიწყოს.

სწორი კლასის სახელებია MyClass, Country, Year2009 და ა.შ.

კლასის არასწორი სახელების მაგალითებია My Class, 404Page და ა.შ.

შემდეგი წესი ეხება ფაილის სახელს, რომელშიც კლასის გამოცხადება იწერება. ამ ფაილის სახელი უნდა ემთხვეოდეს კლასის სახელს და ქონდეს .java გაფართოება. ასე მაგალითად, MyClass-ის გამოცხადება უნდა მოხდეს ფაილში MyClass.java.

Java-ში მნიშვნელობა აქვს ასოების რეგისტრს. ეს ეხება როგორც კლასის ასევე შესაბამის ფაილის სახელებს.

თუ როგორ უნდა მოხდეს კლასის გამოცხადება და მისი ტანის ჩაწერა ნაჩვენებია შემდეგ ნარკვევში:

// ფაილი: MyClass.java
public class MyClass {

    // აქ იწერება პროგრამული კოდი

}

მოდით შევეცადოთ ამ უცნაურ სიმბოლოებში გარკვევას. მართალია, მათში გაცილებით მეტი დევს ვიდრე ჩვენ ახლა ვიტყვით, მაგრამ ამან არ უნდა დაგაბნიოთ. მიიღეთ ყველაფერი ისე როგორც არის. რაც უფრო წინ წაიწევთ მით უფრო გასაგები გახდება ყველა ეს უცნაური კონსტრუქცია.

პირველი ხაზი შეიცავს იმას, რასაც პროგრამისტები კომენტარს ეძახიან. წმინდა ტექნიკური თვალსაზრისით კომნეტარი არ წარმოადგენს არანაირ ღირებულებას პროგრამისთვის. კომპილირების დროს კომენტარი უბრალოდ იგნორირდება. მაშინ რა საჭიროა კომენტარი თუ ის უსარგებლოა?

საქმე ისაა, რომ როდესაც სერიოზული პროგრამების წერას დაიწყებთ, გექნებათ ათობით, ასობით და, შესაძლოა, ათასობით კლასიც. თითოული მათგანი გარკვეულ ფუნქციას შეასრულებს თქვენს პროგრამაში. კოდის მთელი ფუნქციონალობის დამახსოვრება ერთი ადამიანის მეხსიერებაში შეუძლებელია, ხოლო თვით ასეთი მიდგომა არაპროდუქტიულია. რომც წარმოვიდგინოთ ეს შესაძლებლად, ეს მიდგომა მაინცარ ამართლებს, რადგან ახალი პროგრამისტი, რომელიც თქვენს მიერ დაწერილ კოდს არჩევს, არ ფლობს ინფორმაციას რომელიც თქვენს თავში ინახება. ყველას, ვინც თქვენ კოდში ცდილობს ცვლილების გაკეთებას, მისჯილი აქვთ საათობით იწვალოს იმაზე, რასაც თქვენ ერთ წუთში გააკეთებდით. თუ გაითვალისწინებთ იმას, რომ პროგრამისტი საკუთარ დაწეილის დავიწყებას ასწრებს რამდენიმე საათის განმავლობაში, მაშინ შეგიძლიათ წარმოიდგინოთ საკუთარი თავი ამ უბედური პროგრამისტის როლში.

ნაწილობრივი გამოსავალი ამ მდგომარეობიდან არის კოდის დოკუმენტირება. დოკუმენტირება არა სქელკანიანი მანუალით, არამედ პროგრმის შუაგულში -- უშუალოდ საწყის კოდში. მაგალითად კლასის სათაურში რომ ჩასვათ ასეთი შენიშვნა: "ეს კლასი დღგ-ეს გამოსათვლელად არის საჭირო", რამდენად გაგიადვილებთ ეს შემდგომში ცხოვრებას თქვენ და თქვენ მიმდევარს, რომელიც ოკეანეს გაღმა ცხოვრობს და ისე ვერ ერკვევა დღგ-ეს დარიცხვის ჩვენებუთ თავისებურებებში, რომ საწყისი კოდის ხაზებში ამოიკითხოს ამის შესახებ.

კომენტარების წერის პრაქტიკა ძალიან მნიშვნელოვანია. ყოველთვის წერეთ კომენტარი სადაც განმარტებაა აუცილებელი.

კომენტარის დასაწერად გამოიყენეთ ორი დახრილი ხაზი. ჩვენს კოდში ორი კომენტარია,

// ფაილი: MyClass.java

და

// აქ იწერება პროგრამული კოდი

ასეთი ტიპის კომენტარები მოქმედია ხაზის ბოლომდე.

Java-ში არსებობს სხვა სახის კომენტარები, რომლებიც უფრო მოსახერხებელია რთული დოკუმენტირებისთვის. თუმცა ამაზე მოგვნიანებით. ახლა კი, მოდით, შევეცადოთ ჩვენს პროგრამას ისე შევხედოთ როგორც მას კომპილატორი ხედავს. ამისათვის წავშალოთ ყველანაირი კომენტარი.

public class MyClass {
}

დარჩენილი ნარკვევი გვიჩვენებს თუ რას ნიშნავს კლასის გამოცხადება. public და class არის Java-ს საკვანძო სიტყვები, რომელთა შინაარსი შემდგომში იქნება განმარტებული.

MyClass არის კლასის სახელი. ის სწორედ ამ ადგილას უნდა დაიწეროს, public class ფრაზის შემდეგ. თუ თქვენი კლასის სახელია Animal, მაშინ შესაბამისი კლასი გამოცხადებული იქნება public class Animal {}.

მიაქციეთ ყურადღება ფიგურულ ფრჩხილებს. ისინი მონიშნავენ ადგილს სადაც იწერება პროგრამის ძირითადი შინაარსი. არ შეიძლება პროგრამის ამ ფრჩხილების გარეთ წერა. ასეთი ტიპის ფრჩხილები კიდევ ბევრჯერ შეგვხდება. მათი შინაარსი ყოველთვის ერთნაირი იქნება: შესაბამისი ბლოკის საზღვრის მონიშვნა. კლასის შემთხვევაში ამ ბლოკს ეწოდება კლასის ტანი.

მოდით კიდევ ცოტათი წინ წავიწიოთ და ჩავწეროთ უმარტივესი კოდი კლასის ტანში.

// უმარტივესი პროგრამის შაბლონი.
public class MyClass {

    public static void main(String[] args) {
        // აქ იწერება უმარტივესი პროგრამის კოდი
    }

}

ის რაც ჩვენ დავამატეთ ცნობილია main ანუ მთავარი ფუნქციის სახელით. ჩვენ არ დავიწყებთ ახლა გამოძიებას, თუ რატომ უნდა ჩაიწეროს main ფუნქცია ასეთი სახით. ამ საკითხს უფრო მოგვიანებით წიგნის სხვა-და-სხვა ნაწილში მიუბრუნდებით.

დააკვირდით, რომ main ფუნქციის გამოცხადება საკმაოდ წააგავს კლასის გამოცხადებას, თუმცა განსხვავებებიც თვალში საცემია. ისევე როგორც კლასს main ფუნქციასაც გააჩნია ტანი, რომლიც აგრეთვე წარმოადგენს ფუგურული ფრჩხილებით შემოსაზღვრულ ბლოკს.

main ფუნქციას გამოარჩევს ერთი თავისებურება, რის გამოც ჩვენ მას ასე ადრეულად განვიხილავთ. საქმე ისაა, რომ main ფუნცია წარმოადგენს პროგრამაში შესვლის წერტილი. სხვა სიტყვებით main ფუნქცია წარმოადგენს ადგილს, რომლიდანაც იწყება პროგრამის შესრულება.

ამიტომ ყველა პროგრამას, თავის მხრივ, უნდა ჰქონდეს განსაზღვრული main ფუნქცია. ზემოთ მოყვანილი პროგრამა წრმოადგენს პროგრამის უმარტივეს შაბლონს, რომელსაც ჩვენ მთელი თავის მანძილზე გამოვიყენებთ.

ტექსტის გამოტანა

ტერმინალში მომხმარებლისთვის ტექსტის გამოტანა ძალიან მნიშვნელოვანი ოპერაცია იყო ძველ დროში, როდესაც კომპიუტერებს არ გააჩნდა ისეთი დახვეწილი გრაფიკული ინტერფეისი, როგორც, მაგალითად, თანამედროვე ოპერაციულ სისტემას Mac OS X-ს აქვს.

Java-ს ასპარეზზე გამოჩენის შემდეგ ტექსტის ტერმინალში გამოტანა არც ისეთი აქტუალურია, როგორც ძველად, თუმცა მაინც მნიშვნელოვანი უნარია და ხშირად დაგჭირდებათ პრაქტიკაში. თანაც, შეიძლება გაგიკვირდეთ კიდეც, დინამიური ვებ-გვერდის გასაკეთებლად ზუსტად იგივე ტექნიკის გამოყენება დაგჭირდებათ, რასაც ისწავლით ტერმინალზე ტექსტის გამოტანისას.

პარალელურად, მოდით, წინ წავიწიოთ და ვისწავლოთ Eclipse-თან მუშაობა. რადგან ეს არაა Eclipse-თან მუშაობის სახელმძღვანელო, ამიტომ ამ წიგნში მწირი ინფორმაცია იქნება მოცემული ამ ინტეგრირებული გარემოსთან მუშაობის შესახებ. მეტი ინფორმაციისათვის ეწვიეთ Eclipse-ის ვებ-გვერდს და მოიძიეთ ინტერნეტში მის შესახებ.

გაუშვით Eclipse, თუ ეს აქამდე არ გაგიკეთებიათ. აარჩიეთ მენიუდან File > New > Java Project (ფაილი > ახალი > Java პროექტი). გამოსული "ჯადოქარი" დაგვეხმარება ახალი Java პროექტი შევქმნათ. შეიყვანეთ hello_java, ველში Project name (პროექტის სახელი). hello_java იქნება ჩვენი ახალი პროექტის სახელი. სხვა დანარჩენი ველები დატოვეთ უცვლელი. დააჭირეთ ღილაკს Finish (დასრულება).

ფანჯარაში სათაურით Project Explorer (პროექტები) უნდა გამოჩნდეს პატარა პიქტოგრამა წარწერით hello_java. სწორედ ესაა ჩვენს მიერ შექმნილი ახალი პროექტი. დააჭირეთ Ctrl ღილაკს და ისე დააწკაპუნეთ ამ პიქტოგრამაზე (არა მაკინტოშის მომხმარებლებმა, თაგვის მარჯვენა ღილაკით), გამოსულ კონტექსტურ მენიუში აარჩიეთ New > Class. გამოსული ჯადოქარი, New Java Class (ახალი Java კლასი) დაგვეხმარება მარტივად შევქმნათ Java-ს კლასი. შეიყვანეთ ტექსტი hellojava ველში Package. ეს იქნება ჩვენი პაკეტი ჩვენი კლასისთვის. თუ რა არის პაკეტი, ამას ცოტათი მოგვიანებით განვმარტავთ. შეიყვანეთ ტექსტი HelloJava ველში Name და მონიშნეთ ჩიტი ველზე წარწერით public static void main(String[] args), ეს უზრუნველყოფს main ფუნქციის ავტომატურ გენერაციას. თუ როგორ უნდა გამოიყურებოდეს ამ დროისთვის ჩვენი ხელოსანი ნაჩვენებია ნახატზე მარჯვნივ. დააჭირეთ ღილაკზე Finish.

ავტომატურად გაიხსნება, ჩვენი ახალი კლასის რედაქტორის ფანჯარაც სადაც შემდეგი ტექსტი დაგენერირდება ავტომატურად.

package hellojava;

public class HelloJava {

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

	}

}

წაშალეთ კომენტარი main ფუნქციის ტანში და ჩაწერეთ მის მაგივრად System.out.println("Hello, Java!");>. შედეგად უნდა მიიღოთ:

package hellojava;

public class HelloJava {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println("Hello, Java!");
	}

}

ის რაც ჩვენ ახლა დავწერეთ არის უმარტივესი მაგალითი იმისა, თუ როგორ უნდა გამოიტანო ტექსტი სისტემურ კონსოლზე. მოდით გავერკვეთ დეტალებში.

System.out არის Java-ს ენაზე სისტემური კონსოლი. რა უცნაური სახელი შეურჩევიათ!, იტყვით თქვენ. არც თუ ისე უცნაური. თუ კარგად დააკვირდებით, ეს სახელი ორი ნაწილისგან შესდგება. პირველი ნაწილი System არის Java-ს საბაზისო კლასი, რომელიც აღწერს სისტემას. მას შეუძლია საკმაოდ ბევრი რამ გვითხრას იმ სისტემაზე, რომელზეც ის არის გაშვებული, მათ შორის მას შეუძლია ჩვენს განკარგულებაში გადმოგვცეს სისტემური კონსოლი. სინამდვილეში კონსოლს ორი სახე აქვს: ერთი ტექსტის შეყვანისთვის (in), მეორე მის გამოსაყვანად (out). იმისათვის რომ System კლასს მივმართოთ მასში შემავალი კონსოლის (out) გადმოსაცემად, არსებობს სპეციალური ოპერატორი, რომელიც შესაძლოა ვერც კი შენიშნეთ. ეს ოპერატორი ჩაიწერება წერტილით, და მას ასეც ქვია წერტილის ოპერატორი. წერტილის ოპერატორის დახმარებით ჩვენ საბოლოოდ ვიღებთ კონსოლს.

შეიძლება ძალიან გაგიკვირდეთ თუ რა მაგიური ძალის დახმარებით იცის System-მა რომ წერტილის ოპერატორის და out მიმართვაზე უნდა მოგვართვას სისტემური კონსოლი, მაგრამ ეს ფაქტია. ამ კონსტრუქციის დეტალები მალე უფრო გასაგები გახდება თქვენთვის, როდესაც შემდეგი თავიდან ისწავლით, თუ როგორ უნდა წეროთ ანალოგიური ჯადოქრობა საკუთარი ხელით.

მოდით ახლა ისევ პროგრამას დაუბრუნდეთ. System.out წარმოადგენს კონსოლს, რომელზეც, ისევე როგორც თავად System-ზე შეგვიძლია უამრავი ოპერაციის ჩატარება, და როგორც System-ის შემთხვევაში, აქაც დამატებითი ფუნქციონალობის მისაღწევად გამოვიყენოთ ოპერატორი წერტილი. ამ შემთხვევაში ოპერაციას ქვია println. ეს კონსოლზე ტექსტის გამოტანის ბრძანებაა. println შემოკლებაა, სრული ვერსიაა print line, ანუ ხაზის დაბეჭდვა.

println განსხვავდება System და out-სგან. ეს უკანასკნელები გამოხატავდნენ საგანს, ხოლო println გამოხატავს მოქმედებას. მას Java-ში სხვანაირად მეთოდიც ქვია. მეთოდი კონკრეტულ მოქმედებას გულისხმობს, განსხვავებით საგნებისგან, რომლებიც მხოლოდ არსებულ რეალობას ასახავდნენ. მეთოდის გამოძახებისთვის იყენებენ ჩვეულებრივ ფრჩხილება ( ). ფრჩხილებს შორის მეთოდს შეიძლება გადავცეთ შესრულებისთვის საჭირო პარამეტრები.

ხშირად მოქმედება პარამეტრის გარეშე უაზრობაა. ასე მაგალითად მოქმედება დაბეჭდე სისტემურ კონსოლზე გაურკვეველია, რადგან გაუგებარია თუ კონკრეტულად რა უნდა დაიბეჭდოს სისტემურ კონსოლზე. თუმცა რომ გადავცეთ, თუ რისი დაბეჭდვა გვინდა, მაშინ ეს მოქმედება იძენს აზრს.

println("Hello, Java!") ადამიანურ ენაზე აღნიშნავს დაბეჭდე წარწერა Hello, Java!. კონსტრუქცია "Hello, Java!" წარმოადგენს ტექსტურ პარამეტრს რომელიც println მეთოდს გადაეცემა.

დააკვირდით, System.out.println("Hello, Java!"); ხაზის ბოლოს დასმულია წერტილმძიმე (;). წერტილმძიმე Java-ში აღნიშნავს ერთი კონკრეტული მოქმედების დასრულებას. ჩვენ შემთხვავაში ეს იყო კონსოლზე გარკვეული ტექსტის გამოტანა. როდესაც ჩვენ უფრო რთულ პროგრამებზე გადავალთ, რომელიც ბევრ მოქმედებას შეიცავს, შესაბამისად გაიზრდება წერტილმძიმეების რიცხვიც.

პროგრამის გასაშვებად Eclipse-დან, მონიშნეთ ფანჯარაში Project Explorer პიქტოგრამი წარწერით HelloJava.java და დააჭკაპეთ მას Ctrl ღილაკის თანხლებით (ან მარჯვენა წკაპით, არა მაკინტოშის მფლობელებმა). გამოსული მენიუდან აარჩიეთ Run As > Java Application (გაუშვა როგორც > Java პროგრამა). ფანჯარაში Console (ტერმინალი) უნდა დაინახოთ ახლად გამოსული წარწერა

Hello, Java!

თუ Console ფანჯარა არ გიჩანთ შეასრულეთ მოქმედება Window > Show View > Console (ფანჯარა > მანახე ფანჯარა > ტერმინალი).

შეჯამენა

მოკლედ შევაჯამოთ თუ რა ვისწავლეთ ამ განყოფილებაში.

Eclipse-ში პროექტის გახსნა, კლასის შექმნა და პროგრამის გაშვება. რეკომენდირებულია გაეცნოთ დამატებოთ დოკუმნტაციას Eclipse-თან მუშაობის სხვა დეტალების თაობაზე.

System, Java-ს მზამზარეული ობიექტი გამშვებ სისტემასთან მუშაობისთვის,

out, System-ში ჩადგმული ობიექტი კონსოლზე ტექსტის გამოსატანად.

println, ბეჭდვის ბრძანება, რომელსაც შეგვიძლია პარამეტრის სახით გადავცეთ ამოსაბეჭდი ტექსტი.

პაკეტები

წინა განყოფილებაში ჩვენ შევქმენით კლასი HelloJava, რომელსაც შეუძლია სისტემურ ტერმინალში ტექსტის გამოტანა. თუმცა ჩვენ არ მოგვიცდენია თქვენი ყურადღება კიდევ ერთ ახალ ელემენტზე, რომელიც, მიუხედავად ამისა, ძალიან მნიშვნელოვან როლს ასრულებდა.

დააკვირდით წინა განყოფილებიდან პროგრამის პირველ ხაზს.

package hellojava;

ეს არის პაკეტის გამოხცადება, რომელიც თითქმის ყველა კლასის გამოცხადებაში გვხდება. პაკეტი წარმოადგენს კლასის სახელის განვრცობის საშუალებას, ისევე როგროც გვარი წარმოადგენს ჩვენი სახელის განვრცობის საშუალებას.

რა საჭიროა პაკეტი?

წარმოიდგინეთ, რომ თქვენ მუშაობთ ინტერნეტ პროექტზე და შექმენით კლასი სახელად Page, რათა აღწეროთ ვებ-გვერდი. თქვენთან ერთად, იგივე პროექტზე მუშაობს მეორე პროგრამისტიც, რომელიც PDF დოკუმნეტების გენერირებით არის დაკავებული. მანაც, თქვენგან დამოუკიდებლად, შექმნა იგივე სახელწოდების კლასი Page, ამ შემთხვევაში PDF დოკუმენტებთან მუშაობისთვის. როდესაც თქვენ და თქვენი კოლეგა გადაწყვიტავთ თქვენი ნამუშევრის გაერთიანებას, დაინახავთ, რომ ერთნაირი სახელის მქონე ორი სხვა და სხვა დანიშნულების კლასი დაგიწერიათ.

აქ დგენა სახელების კონფლიქტის პრობლემა. თქვენ და თქვენი კოლეგა შესაძლოა მორიგდეთ და სახელები შეუცვალოთ თქვენ კლასებს, რომ რაღაცით მაინც გაარჩიოთ ისინი ერთმანეთისგან. მაგრამ ეს პრობლემა გადაუჭრელი ხდება, როდესაც ჩვენ ვიყენებთ ორ სხვა და სხვა მწარმოებლისგან მოწოდებულ კლასებს, რომელთაც ჩვენ ვერ ვაიძულებთ კლასის სახელები შეცვალონ.

გამოსავალი არის იმაში, რომ თითოულ კლასს შეუსაბამოთ სახელთა სივრცე. სახელთა სივრცე Java-ში ცნობილია როგორც პაკეტი.

პაკეტები იგივე როლს ასრულებენ, რასაც საქაღალდეები დოკუმენტების დახარისხებისას. ფიზიკურად პაკეტი საქაღალდეს წარმოადგენს. თქვენ შეგიძლიათ დარწმუნდეთ ამაში, თუ მოძებნით თქვენი ოპერაციულ სისტემაზე HelloJava.java ფაილს წინა პროექტიდან. დარწმუნდით რომ ის დევს საქაღალდეში hellojava, რაც ემთხვევა გამოცხადებას package hellojava.

ჩვენი კლასის სახელი არა უბრალოდ HelloJava, არამედ hellojava.HelloJava.

ზემოთ მოყვანილი მაგალითი, ინტერნეტ პროექტის შესახებ, ანალოგურად გადაწყდება. ვებ-გვერდებთან მუშაობაზე განკუთვნილი კლასი Page უნდა მოვათავსოთ მისთვის განკუთვნილ პაკეტში html, ხოლო PDF-ის შესაბამისი კლასი პაკეტში pdf.

ფაილური სისტემა ამ შემთხვევაში ასე გამოიყურება:

+-- /პროექტის საწყისი დირექტორია

    +-- /pdf

        -- Page.java

    +-- /html

        -- Page.java

როგორც ხედავთ, ჩვენ ავიცილეთ სახელების კონფლიქტი ორი Page.java ფაილის სხვადასხვა საქაღალდეში განთავსებით. პაკეტის სახელი ცხადად უნდა იყოს მითითებული Java კოდში. ჩვენი მაგალითის შემთხვევაში Page.java ფაილების შიგთავსი ასე გამოიყურება:

// pdf.Page კლასის გამოცხადება
package pdf;

public class Page {

    // ... სიმოკლისთვის ეს შიგთავსი ამოვშალეთ ...

}

და

// hmtl.Page კლასის გამოცხადება
package html;

public class Page {

    // ... სიმოკლისთვის ეს შიგთავსი ამოვშალეთ ...

}

ჩადგმული პაკეტები
[რედაქტირება]

შეგვიძლია პაკეტები ერთმანეთში ჩავდგათ. თუ თქვენ მუშაობთ ვიკიწიგნების პროგრამისტებად და უფროსობა გვავალებს თქვენს ნამუშევარს wikibooks დირექტორიაში მოუყაროთ თავი, მაშინ თქვენი პროექტის ფაილური სისტემა შემდეგნაირად უნდა დაგეგმოთ:

+-- /პროექტის საწყისი დირექტორია

    +-- /wikibooks

        +-- /pdf

            -- Page.java

        +-- /html

            -- Page.java

ამ სტრუქტურაში ერთმანეთში ჩადგმულ რამოდენიმე პაკეტია.
პაკეტის სახელი ემთხვევა დირექტორიის სრული მისამართის სახელს, იმ განსხვავებით, რომ დირექტორიებს შორის გამყოფად უნდა გამოვიყენოთ წერტილი. ასე მაგალითად, wikibooks/pdf დირექტორია შეესაბამება პაკეტს wikibooks.pdf, ხოლო wikibooks/pdf/print -- პაკეტს wikibooks.pdf.print. სრული სახელი კლასისთვის Page, რომელიც განთავსებულია wikibooks.pdf.print პაკეტში არის wikibooks.pdf.print.Page. ამ კლასის გამოცხადება შემდეგნაირად გამოიყურება,

// wikibooks.pdf.print.Page კლასის გამოცხადება
package wikibooks.pdf.print;

public class Page {

    // ... სიმოკლისთვის ეს შიგთავსი ამოვშალეთ ...

}

შეჯამება
[რედაქტირება]

აქ ჩვენ ვისწავლეთ კლასის გამოცხადება პაკეტის შიგნით.

პაკეტი საჭიროა სახელთა კონფლიქტის თავდან ასაცილებლად.

როდესაც ქმნით კლასებს, შეეცადეთ პაკეტის სახელის უნიკალურობა დაიცვათ მსოფლიო მაშტაბით. ამის გასაკეთებლად შეგიძლიათ გამოიყენოთ თქვენი კომპანიის დომენური სახელი. ასე მაგალითან ქართული ვიკიწიგნების დომენური სახელი ka.wikibooks. მე რომ დამავალონ ამ კომპანიის პროგრამული უზრუნველყოფის წერა, მე ყველა ჩემს პაკეთს ka.wikibooks პაკეტში ჩავდგამდი. და მექნებოდა პაკეტები, როგორიცაა ka.wikibooks.user, ka.wikibooks.pages და ა.შ.

რიცხვებთან მუშაობა
[რედაქტირება]

კომპიუტერს აქვს ერთი მეტად მნიშვნელოვანი უნარი, რომლითაც ის გაცილებით წინ დგას ნებისმიერ ჩვენთაგანზე. ეს არის რიცხვითი გამოთვლები. ბუნებრივია, რომ თითქმის ყველა პროგრამირების ენა გვთავაზობს რიცხვებთან მუშაობის ამა თუ იმ შესაძლებოლობას.
გამოთვლები ხშირად გვჭირდება ბიზნეს პროგრამებშიც.
ასე მაგალითად საბუღალტრო პროგრამის დაწერა თუ გაქვთ გადაწყვეტილი, დიდი ალბოთობაა იმისა, რომ დამატებითი ღირებულების გადასახადის გამოთვლა ხშირად მოგიწევთ. დღგ-ის გადასახადი საქართველოს დღევანდელი კანონმდებლობით განისაზღვრება როგორც ძირითადი ფასის 18%. ანსე მაგალითად, თუ ყიდით დაწნულ კალათებს ყვავილებისთვის, და თითოს 10 ლარად აფასებთ, მაშინ უნდა დაამატოთ ამ თანხის 18% თითოულ გაყიდულ კალათაზე. ანუ კალათის რეალური ფასია 10 + 10 * 0.18 = 11.80 ლარი.
ქვემოთ მოყვანილია პროგრამა, რომელსაც გამოაქვს პროდუქტის ფასი დღგ-ის გარეშე, იგივე ფასის დღგ ნაწილი და სრული ფასი დღგ-ის ჩათვლით.

package ka.wikibooks;

public class VatCalculations {

    public static void main(String[] args) {
        System.out.print("კალათის ფასი დღგ-ის გარეშე: ");
        System.out.println(10);
        System.out.print("დღგ: ");
        System.out.println(10 * 0.18);
        System.out.print("ფასი დღგ-ის ჩათვლით: ");
        System.out.println(10 + 10 * 0.18);
    }

}

როდესაც ამ პროგრამას გაუშვებთ, მიიღებთ შემდეგ შედეგებს:

კალათის ფასი დღგ-ის გარეშე: 10
დღგ: 1.7999999999999998
ფასი დღგ-ის ჩათვლით: 11.8

შეიძლება გაგაკვირვოთ, რომ დღგ-ეს მნიშვნელობა ასე უცნაურად გამოიყურება. თუმცა, თუ კარგად დააკვირდებით, შეამჩნევთ, რომ ის მოსალოდნელ 1.8-სთან ძალიან ახლოსაა, ცდომილება მხოლოდ 10^-16-ის რიგისაა. ეს დამახასიათებელია რიცხვითი გამოთვლებისთვის და სინამდვილეში სერიოზულ პრობლემას წარმოადგენს როდესაც ფინანსურ გამოთვლებს ეხება საქმე. ჩვენ ამ საკითხებს კიდევ დაუბრუნდებით.
ახლა კი მოდით პროგრამას შევავლოთ თვალი. მასში ალბათ ბევრი ნაცნობი ელემენტი აღმოაჩინეთ. შესაძლოა ცოტათი გაგაკვირვათ ახალმა ოპერატორმა print, რომელიც საკმაოდ წააგავს println? დიახ, ეს ორი ოპერატორი საკმარისად ახლოსაა და თითქმის ერთნაირი ფუნქციონალობა აქვთ. განსხვავება მხოლოდ ისაა რომ println-ს ბეჭდავს გადაცემულ ტექსტს ეკრანზე და ბოლოში ამატებს ახალ ხაზს. ასე, რომ ეკრანზე შემდეგი დაბეჭდვის ოპერაცია ახალი ხაზიდან შეიყვანს ტექსტს. რაც შეეხება print ფუნქციას, მას მხოლოდ ტექსტი გამოაქვს, და შემდეგი დაბეჭდვი ოპერაცია ტექსტის გამოტანას გააგრძელებს იგივე ხაზიდან.
შეეცადეთ გაანალიზოთ პროგრამის კოდი და შეუსაბამოთ იქ მოყვანილი ოპერატორები ეკრანზე გამოტანილ შედეგს. თუ თქვენ ხედავთ ამ კავშირს, მაშინ გილოცავთ!, თქვენ უკვე პირველი სერიოზული ნაბიჯი გადადგით Java-ს და ზოგადად პროგრამირების შესასწავლად.
კიდევ ერთი ახალი ელემენტი ჩვენს პროგრამაში არის წიცხვები და მათთან მუშაობა.

რიცხვები და არითმეტიკული ოპერატორები
[რედაქტირება]

რიცხვები Java-ში ჩაიწერება როგორც წესი ათობით სისტემაში, ანუ ციფრებით 0-დან 9-მდე. სხვა სისტემებში ჩაწერას უფრო მოგვიანებით ვისწავლით, როდესაც მონაცემთა ტიპებს საფუძვლიანედ მიმოვიხილავთ.
არსებობს ორი ტიპის რიცხვი: მთელი და არამთელი.
მთელი რიცხვებია, მაგალითად, 100, 200, -2 და ა.შ.
არამთელი რიცხების ჩასაწერად გამოიყენება წერტილი (და არა მძიმე!), ასე მაგალითად 10.30, -3.0 და ა.შ.
არ შეიძლება რიცხვების ჩაწერა სხვა სასვენი ნიშნების გამოყენებით, მაგალითად ადგილის გამოტოებით ციფრებს შორის, ან ათასების მძიმით გამოყოდა ან წილადის სახით ჩაწერა.
თავისთავად რიცხვების გამოცხადება დიდი არაფრის მომტანია. ჩვენ გვჭირდება აგრეთვე ვიცოდეთ ოპერაციები ამ რიცხვებზე. არითმეტიკული ოპერაციების შესასრულებლად Java-ში არის განსაზღვრული არითმეტიკული ოპერატარების ჯგუფი.
ასე მაგალითად, + ოპერატორი გამოიყენება რიცხვების შესაკრებად. ანალოგიურად, ოპერატორი -, რიცხვების გამოსაკლებად. ქვევით მოყვანილია ძირითადი არითმეტიკული ოპერატორების სია.

+ არის შეკრების ოპერატორი.

1 + 1 // მიიღება 2

- არის გამოკლების ოპერატორი.

8 - 15 // მიიღება -7

* არის გამრავლების ოპერატორი.

4 * 4 // მიიღება 16

/ არის გაყოფის ოპერატორი.

4.0 / 8.0 // მიიღება 0.5

% არის ნაშთის გამოყოფის ოპერატორი.

3 % 2 // მიიღება 1
4 % 2 // მიიღება 0

ყველა ეს ოპერატორი ძირითადში ისე იქცევა, როგორც შეიძლება ელოდოთ ამას. ერთადერთი გამონაკლისს წარმოადგენს გაყოფის ოპერატორი /, რომელსაც ორმაგი ფუნქცია აქვს.
თუ თქვენ მოინდომებთ ორი არამთელი რიცხვის გაყოფას, მიიღებთ იმას, რასაც ელით გაყოფისგან. ასე მაგალითად 5.0/2.0 მოგვცემს შედეგს 2.5. თუმცა იგივე მოქმედებას თუ ჩავატარებთ მთელი რიცხვებით, შედეგად მივიღებთ ისევ მთელ რიცხვს. ასე მაგალითად 5/2 მოგვცემს მნიშვნელობას 2. ეს არის მთელი რიცხვების გაყოფით მიღებული შედეგი (ნაშთის გამოკლებით).
შემდეგ განყოფილებაში ვნახავთ, თუ როგორ უნდა გამოვიყენოთ არითმეტიკული ოპერატორები. პარალელურად გავეცნობით ერთ მეტად მნიშვნელოვან ცნებას, რომელსაც ცვლადის გამოცხადება ქვია.

არითმეტიკული ოპერატორები პრაქტიკაში
[რედაქტირება]

პროგრამირების რომელიმე საშუალების საუკეთესო შესწავლის ხერხი, ხშირად ამ საშუალების ინტენსიური გამოყენებაა. ამ განყოფილებაში დავდგამთ პატარა პროგრამულ ექსპერიმენტს, რომელიც არც ერთი კონკრეტული ამოცანის გადაჭრაზე არ იქნება მიმართული. მისი ერთადერთი დანიშნულება იქნება არითმეტიკული ოპერატორების ინტენსიური გამოყენება. ამის მსგავსი ექსპერიმენტების დდგმა ხშირად დაგჭირდებათ შემდგომშიც, რათა დარწმუნდეთ, ესა თუ ის ფუნქციონალობის ნაწილი რამდენად შეესაბამება მასზე თქვენ წარმოდგენას.
განსხვავებით ატომური ბომბის შემქმნელებისაგან ჩვენ უსაზღვროდ დიდი უპირატესობა გვაქვს. ჩვენ შეგვიძლია უსასრულობამდე ვატაროთ ექსპერიმენტები და ჩვენი რომელიმე უნებლიე შეცდომა არ გამოიწვევს ქვეყნიერების აღსასრულს. ასე რომ ჩაატარეთ ექსპერიმენტები! მათ არანაირი ზიანი არ მოაქვთ გარემოსთვის, მაგრამ მეტად წაგადგებათ თქვენ.
ქვემოთ მოყვანილია ჩვენი ექსპერიმენტის საწყისი კოდი.

package ka.wikibooks;

public class Arithmetics {

	public static void main(String[] args) {
		int a = 30;
		int b = 8;
		double x = 30;
		double y = 8;
		
		System.out.println("a = " + a);
		System.out.println("b = " + b);
		System.out.println("x = " + x);
		System.out.println("y = " + y);

		System.out.println("a + b = " + (a + b));
		System.out.println("a - b = " + (a - b));
		System.out.println("a * b = " + (a * b));
		System.out.println("a / b = " + (a / b));
		System.out.println("a % b = " + (a % b));
		
		System.out.println("x + y = " + (x + y));
		System.out.println("x - y = " + (x - y));
		System.out.println("x * y = " + (x * y));
		System.out.println("x / y = " + (x / y));
		System.out.println("x % y = " + (x % y));
	}
	
}

მისი კონსოლზე გამოტანილი შედეგი ასე გამოიყურება:

a = 30
b = 8
x = 30.0
y = 8.0
a + b = 38
a - b = 22
a * b = 240
a / b = 3
a % b = 6
x + y = 38.0
x - y = 22.0
x * y = 240.0
x / y = 3.75
x % y = 6.0

ამ პატარა ექსპერიმენტში ძალიან ბევრი სიახლეა. ყველაზე მნიშვნელოვანი მათ შორის არის ოთხი ცვლადის a, b, x და y გამოცხადება. გამოცხადების წესებს ჩვენ შემდეგ სექციაში განვიხილავთ. თუმცა მოკლედ მოგცემთ აქ განმარტებას.
პირველი ცვლადის გამოცხადება იწება main ფუქციის პირველივე ხაზიდან.

int a = 30;

int აღნიშნავს, რომ ცვლადი სახელად a არის მთელი რიცხვი. ცვლადი Java-ში აღნიშნავს სახელობით იდენტიფიკატორს, რომელსაც შეუძლია მიიღოს მნიშვნელობა. Java არის სტატიკურად ტიპიზირებული ენა. ეს იმას ნიშნავს, რომ ცვლადის გამოცხადებაში აუცილებლად უნდა იყოს მითითებული მისი ტიპი. ტიპები შეიძლება იყოს პრიმიტიული და მიმართებითი (reference). პრიმიტიულ ტიპებს ჩვენ მომდვნო განყოფილებებში განვიხილავთ. მიმართებითი ტიპები კი შემდეგი თავის განხილვის საგანია.
გარდა ტიპის გამოცხადებისა, a ცვლადს ენიჭება საწყისი მნიშვნელობა 30. ეს ხდება ოპერატორი =-ის მეშვეობით. ოპერატორი = არის მინიჭების ოპერატორი. მისი მეშვეობით მარცხენა მხარეს ჩაწერილ ცვლადს ენიჭება მარჯვენა ნაწილში ჩაწერილი გამოსახულების მნიშვნელობა. მინიჭების დროს ცვლადის ძველი მნიშვნელობა იშლება და მის ადგილას იწერება ახალი.
ცვლადის გამოცხადების შემდეგ მინიჭება შეიძლება ნებისმიერ რაოდენობა ჯერ. ცვლადის გამოცხადება შეიძლება მოხდეს საწყისი მნიშვნელობის მინიჭების გარეშეც. ასე მაგალითად, a ცვლადის გამოცხადება და მასზე მნიშვნელობის მინიჭება შეგვეძლო ორ ნაწილად გაგვეყო:

int a;
a = 30;

b ცვლადის გამოცხადება წააგავს a ცვლადის გამოცხადებას. მას უბრალოდ განსხვავებული საწყისი მნიშვნელობა ენიჭება.
x და y ცვლადების ტიპი არის double. ეს არის არამთელი რიცხვის ტიპი. მიუხედავად იმისა, რომ მათ ენიჭებათ მთელი რიცხვითი მნიშვნელობა (შესაბამისად 30 და 8),ეს მნიშვნელობები ავტომატურად კონვერტირდება არამთელში. შებრუნებული ოპერაცია, მთელზე არამთელი მნიშვნელობის მინიჭება, მოგცემთ შეცდომას კომპილირებისას.
გამოხცადებული ცვლადები შეგვიძლია პროგრამის ნებისმიერ ადგილას გამოვიყენოთ მათი სახელით. ასე მაგალითად, შეგვიძლია ჩავწეროთ:

System.out.println(a); // გამოიტანს ეკრანზე a-ს მნიშვნელობას

შედეგად ეკრანზე მივიღებთ a-ს მიმდინაერე მნიშვნელობას. თუ შემდგომში a ცვლადის მნიშვნელობა შეიცვალა, ანალოგიური გამოძახების შემდეგ ეკრანზე განსხვავებული მნიშვნელობა დაიბეჭდება.
ცვლადების გამოცხადება მეტად მოსახერხებელი ოპერაციაა. ნაცვლად მნიშვნელობის უშუალოდ მითითებისა, ჩვენ ყველგან ამ ცვლადის სახელს ვიყენებთ. თუ საჭიროა განსხვავებული მნიშვნელობის გამოყენება, ჩვენ ვანიჭებთ ცვლადს ამ მნიშვნელობას, კოდის სხვა ნაწილის შეცვლის გარეშე. ასე მაგალითად, ჩვენს პრორამაში a ცვლადის მნიშვნელობა გვაქვს გამოყენებული ექვს ჯერ. ჩვენ რომ ნაცვლად ცვლადის გამოცხადებისა გვეწერა ყველგან მისი მნიშვნელობა, მისი მნიშვნელობის შეცვლის შედეგად მოგვიწევდა ჩასწორების ექვს ადგილას გაკეთება. გარდა იმისა, რომ ეს მოუხერხებელია, ეს შეცდომების მუდმივი წყარო იქნებოდა. ცვლადის გამოცხადების შემთხვევაში კი ახალი მნიშვნელობის მინიჭება მხოლოდ ერთ ადგილას შეიძლებოდა.
გარდა აღნიშნულისა, ცვლადის გამოცხადებით დაწერილი პროგრამები უფრო კითხვადია, რომ არაფერი ვთქვათ იმ შემთხევებზე, როდესაც მათი გამოყენების გარეშე პროგრამის დაწერა შეუძლებელია.
გამოცხადებების შემდეგ მოდის ეკრანზე დაბეჭდვის ოპერატორების გამოძახებები. განვიხილოთ პირველი მათგანი.

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

აქ + ოპერატორი გამოყენებულია ტექსტის "a = " და a რიცხვის ტექსტერი წარმოდგენის ერთმანეთზე შესაერთებლად. + ოპერატორი მოქმედებს განსხვავებულად იმის მიხედვით თუ რა ტიპისაა მისი მარჯვენა და მარცხენა პარამეტრი. როდესაც + ოპერატორს უყენებთ ტექსტს ან რიცხვის ტექსტურ წარმოდგენას ის იძენს დამატებით ფუნქციონალობას: ის ტექსტის გადაკერვის ოპერატორია ამადროულად.
სხვა არითმეტიკულ ოპერატორებს, გარდა + ოპერატორისა, არ გააჩნიათ ასეთი ორმაგი ფუნქციონალობის შესაძლებლობა.
გამოსახულების შეფასების დროს ყოველთვის პრიორიტეტულია ( და ) (მარცხენა  და მარჯვენა ფრჩხილი) შორის მოთავსებული გამოსახელება.
ასე მაგალითად, საწყისი კოდის ფრაგმენტში,

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

ჯერ ხდება ფრჩხილებში მოთავსებული გამოსახულების (a + b) შეფასება. შემდეგ კი მიღებული შედეგის ტექსტის შეერთება მარცხენა ნაწილში მყოფი ტექსტთან, "a + b = ".

ცვლადების გამოცხადება
[რედაქტირება]

წინა განყოფილებაში ჩვენ უკვე გამოვიყენეთ ცვლადის გამოცხადება. თუ პროგრამირების რომელიმე ენასთან აქამდე გქონდათ შეხება, მაშინ ცვლადების გამოცხადება თქვენთვის ნაცნობი თემა უნდა იყოს. თუმცა ახალბედებისთვის ეს შესაძლოა პირველ ჯერზე ცოტა დამაბნევებლადაც გამოიყურებოდეს. თუმცა სანერვიულო არაფერია. მოდით ახლა დეტალურად განვიხილოთ თუ რა არის ცვლადის გამოცხადება.
დავიწყოთ იმის განხილვით თუ როგორ მუშაობს კომპიუტერული პროგრამა.
პროგრამამ რომ ეფექტურად იმუშაოს, საჭიროა ის კომპიუტერის ოპერატიულ მეხსიერებაში იყოს ატვირთული. ალბათ შეგიმჩნევიათ რომ პროგრამის გაშვებას, განსაკუთებით კი დიდი პროგრამის გაშვებას, ესაჭიროება გარკვეული დრო...............

პრიმიტიული ტიპები
[რედაქტირება]

... დასაწერია ...

შემდეგ რა უნდა იყოს?
[რედაქტირება]

.. ახალი ხაზის სიმბოლო, და სხვა escape სიმბოლოები ...
... მრავალხაზიანი კომენტარები ...
... if ოპერატორი ... else ოპერატორი ... else if კონსტრუქცია ...
... for ოპერატორი ... while ოპერატორი ...
... სტატიკური ფუნქციები ...
... import დირექტივა ...
... package დირექტივა ...
... გრაფიკული პაკეტის მარტივი კლასები, JOptionPane.showInput, JOptionPane.showMessage და ა.შ. ...
ყველა ეს ცნება უნდა იყოს აქ გაკვრით აღწერილი. იგივე ცნებების გამეორება მოხდება უფრო მოგვიანებით, უფრო მეტი დეტალურობით. ეს თავი არის სპირალის ყველაზე პატარა ხვეული: გაშლით შემდეგ თავებში გავშლი ...