Code.ge Blog » Java http://www.code.ge ბლოგი ვებ პროგრამირებისა და ტექნოლოგიების შესახებ Mon, 03 May 2010 14:38:57 +0000 en hourly 1 http://wordpress.org/?v=3.0 Java: variables, stack and heap http://www.code.ge/posts/java-variables-stack-and-heap http://www.code.ge/posts/java-variables-stack-and-heap#comments Tue, 22 Sep 2009 07:03:59 +0000 იოსები http://www.code.ge/?p=337 პრეზენტაცია Java – ს ცვლადების და მათთან დაკავშირებული საკითხების შესახებ.

]]> http://www.code.ge/posts/java-variables-stack-and-heap/feed 0 Java: აბსტრაქტული კლასები http://www.code.ge/posts/java-abstract-classes http://www.code.ge/posts/java-abstract-classes#comments Wed, 24 Oct 2007 11:57:18 +0000 იოსები http://www.code.ge/java/java-abstract-classes განსხვავებით ჩვეულებრივი Java – ს კლასისგან აბსტრაქტრული კლასის ინსტანციაცია(კლასის ობიექტის შექმნა) შეუძლებელია. თავად Sun Microsystems – ის დოკუმენტაციაში აბსტრაქტული კლასის განმარტება დაახლოვებით ჟღერს შემდეგნაირად:

აბსტრაქტრული კლასი ეს არის კლასი რომელიც აღწერილია როგორც abstract(მითითებული აქვს abstract მოდიფიკატორი). აბსტრაქტული კლასი შესაძლოა შეიცავდეს ან არ შეიცავდეს აბსტრაქტულ მეთოდებს. აბსტრაქტული კლასის ინსტანციაცია შეუძლებელია, თუმცა შესაძლებელია მისი მემკვიდრე კლასების შექმნა.

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

იგივე Sun Microsystems – ის დოკუმენტაციაში აბსტრაქტული მეთოდის განმარტება ასეთია:

აბსტრაქტული მეთოდი ეს არის მეთოდი რომელიც აღწერილია რეალიზაციის გარეშე(არ აქვს ბოლოში მითითებული {} ფრჩხილები, და მთავრდება წერტილმძიმით) და მითითებული აქვს abstract მოდიფიკატორი.

აბსტრაქტული კლასი, აბსტრაქტული მეთოდით აღიწერება შემედეგნაირად:

1
2
3
4
5
6
7
8
//აბსტრაქტულ კლასს აუცილებლად ეთითება abstract მოდიფიკატორი
abstract class MyAbstractClass {
       
        //აბსტრაქტულ მეთოდს აუცილებლად ეთითება abstract მოდიფიკატორი 
        //აბსტრაქტული მეთოდი მთავრდება წერტილმძიმით ; ნაცვლად {}
  public abstract void myMethod();
 
}

მოყვანილ მაგალითში ყურადღებას იმსახურებს ორი დეტალი, ესენია: 1)abstract მოდიფიკატორი, რომელიც აუცილებელია აბსტრაქტული კლასებისა და მეთოდების განსასაზღვრად; 2) მეთოდი ნაცვლად ფიგურული ფრჩხილებისა {}, მთავრდება პირდაპირ წერტილმძიმით;


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

  • თუ კლასი არის აღწერილი როგორც abstract, არ არის აუცილებელი რომ იგი შეიცავდეს აბსტრაქტულ მეთოდებს;
  • აბსტრაქტურლი კლასი შეიძლება შეიცავდეს რეალიზებულ(არა აბსტრაქტულ) მეთოდებსა და კლასის ცვლადებს;
  • თუ კლასი შეიცავს თუნდაც ერთ abstract მეთოდს მაშინ თავად კლასიც უნდა იყოს აღწერილი როგორც abstract;
  • abstract მეთოდი ყოველთვის მთავრდება წერტილმძიმით ნაცვლად ფიგურული ფრჩხილებისა;
  • abstract მეთოდს უნდა გააჩნდეს public, protected ან ნაგულისხმევი წვდომის მოდიფიკატორი, private მოდიფიკატორის გამოყენება დაუშვებელი და შეუძლებელია;
  • შეუძლებელია აბსტრაქტული კლასისა და/ან მეთოდის აღწერა როგორც final;
  • კონკრეტული კლასი რომელიც არის მემკვიდრე აბსტრაქტული კლასისა, უნდა იყოს აღწერილი როგორც abstract თუ იგი არ ახდენს რომელიმე აბსტრაქტული მეთოდის რეალიზაციას;
  • აბსტრაქტული კლასის ინსტანციაცია(ობიექტის შექმნა) შეუძლებელია;

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

მაგალითად კლასების ასეთი გამოყენება სავსებით დასაშვებია:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//SomeClass არის აბსტრაქტურლი
abstract class SomeClass {
  abstract void implementMe();
}


//RegularClass არის ჩვეულებრივი არა აბსტრაქტურლი კლასი
//იგი მემკვიდრეა SomeClass აბსტრაქტურლი კლასისა
class RegularClass extends SomeClass {
        //SomeClass აბსტრაქტურლი კლასის აბსტრაქტული implementMe() მეთოდის რეალიზაცია
  void implementMe() {
    //rest of code here
  }
}


//MyAbstractClass არის აბსტრაქტურლი კლასი, რომელიც მემკვიდრეა RegularClass არა აბსტრქტული კლასისა
abstract class MyAbstractClass extends RegularClass {
  //აბსტრაქტული მეთოდი
  abstract void myMethod();
 
}

ასევე სავსებით დასაშვებია შემდეგი სახის კოდის დაწერა:

1
2
3
4
5
6
7
8
9
//ინტერფეისი Movable
interface Movable {
  void move();
}

//MyAbstractClass აბსტრაქტული კლასი
abstract class MyAbstractClass implements Movable {
  //კლასი ცარიელია, მასში არაფერი არ არის რეალიზებული
}

თუ დააკვირდებით კოდს, დაინახავთ რომ MyAbstractClass რეალიზაციას უკეთებს Movable ინტერფეისს, თუმცა მასში არ არის ინტერფეისის move() მეთოდის არანაირი რეალიზაცია. ეს დასაშვებია რამდენადაც ინტერფეისის ყველა მეთოდი არაცხადად აბსტრაქტულია, ხოლო რადგან რეალიზაციის კლასი(MyAbstractClass) ამ შემთხვევაში არის აბსტრაქტული შესაძლებელია ინტერფეისის მეთოდების ხელუხლებლად დატოვება. თუმცა უნდა აღინიშნოს ის ფაქტი რომ ნებისმიერი არა აბსტრაქტული მემკვიდრე MyAbstractClass კლასისა ვალდებულია move() მეთოდის რეალიზაციაზე.

აბსტრაქტული კლასის გამოყენების კლასიკური მაგალითია გეომეტრიული ფიგურების ხატვა. ამისათვის საჭიროა ერთი ზოგადი(აბსტრაქტული) კლასის აღწერა რომელსაც გარდა საერთო მახასიათებლებისა ექნება აბსტრაქტული მეთოდიბი. ამ მეთოდების რეალიზაციის კოდი დამოკიდებული იქნება კონკრეტულ ფიგურაზე, მაგალითად:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//ზოგადი GraphicObject კლასი
abstract class GraphicObject {
    //ცვლადები კოორდინატთა ღერძისათვის
    int x, y;
   
    //რეალიზებული არა აბსტრაქტული მეთოდი რომელსაც შეუძლია ფიგურისათვის პოზიციის შეცვლა
    void moveTo(int newX, int newY) {
        //
    }

    //აბსტრაქტული მეთოდი ფიგურის დასახატად
    abstract void draw();
    //აბსტრაქტული მეთოდი ფიგურის ზომის შესაცვლელად
    abstract void resize();
}

//კლასი Circle (წრეწირი) რომელიც არის აბსტრაქტული GraphicObject კლასის მემკვიდრე
class Circle extends GraphicObject {
    //აბსტრაქტული მეთოდის რეალიზაცია
    void draw() {
        //დახატვის ალგორითმი განსხვავდება წრეწირისათვის
    }

    //აბსტრაქტული მეთოდის რეალიზაცია
    void resize() {
        //ზომის შეცვლის კოდი განსხვავდება წრეწირისათვის
    }
}

//კლასი Rectangle (მართკუთხედი) რომელიც არის აბსტრაქტული GraphicObject კლასის მემკვიდრე
class Rectangle extends GraphicObject {
   
    //აბსტრაქტული მეთოდის რეალიზაცია
    void draw() {
        //დახატვის ალგორითმი განსხვავდება მართკუთხედისათვის
    }

    //აბსტრაქტული მეთოდის რეალიზაცია
    void resize() {
        //ზომის შეცვლის კოდი განსხვავდება მართკუთხედისათვის
    }
}

მაგალითი ძალიან მარტივია, იგი შედგება ერთი აბსტრაქტული GraphicObject კლასისაგან, და ორი კონკრეტული რეალიზაციის კლასისაგან Circle და Rectangle. კოდიდან მარტივი მისახვედრია თუ რა უპირატესობას გვაძლევს ამ შემთხვევაში აბსტრაქტული კლასის გამოყენება. გამომდინარე იქედან რომ გეომეტრიულ ფიგურებს მეტნაკლებად მსგავსი ან საერთო მახასიათებლები გააჩნიათ, შესაძლებელია მათი ერთ მშობელ კლასში აღწერა/რეალიზაცია, თუმცა ისეთი მეთოდები როგორიცაა draw და resize შეუძლებელია რომ ყოველი ფიგურისათვის იყოს საერთო. სწორედ ეს მეთოდებია აღწერილი როგორც აბსტრქტული მშობელ GraphicObject კლასში, და მათი რეალიზაცია დამოკიდებულია კონკრეტულ გეომეტრიულ ფიგურაზე. თუმცა მთავარი უპირატესობა ასეთი მიდგომისა არის ის რომ სამუშაო ინტერფეისი ყოველი ფიგურისათვის არის აბსოლუტურად ერთგვაროვანი, და ნებისმიერი ვინც კი იცის ფიგურებთან მუშაობის კლასის მეთოდების შესახებ მარტივად შეძლებს კონკრეტული რეალიზაციის კლასის ობიექტის გამოყენებას ისე რომ მისთვის აბსოლუტურად უმნიშვნელო იქნება: 1) თვითონ კონკრეტული რეალიზაციის კლასის ობიექტის ტიპი; 2) გრაფიკული მეთოდების რეალიზაციის დეტალები;

]]> http://www.code.ge/posts/java-abstract-classes/feed 1 Java: ინტერფეისები http://www.code.ge/posts/java-interfaces http://www.code.ge/posts/java-interfaces#comments Wed, 24 Oct 2007 08:46:20 +0000 იოსები http://www.code.ge/java/java-interfaces interface(ინტერფეისი) ჯავას ერთერთი ყველაზე მნიშვნელოვანი დეტალია. თავად სიტყვა ინტერფეისი საუკეთესოდ აღწერს მის დანიშნულებას, თუმცა უფრო კონკრეტულ მაგალითად შეგვიძლია განვიხილოთ თავად კლასი და კალსის ობიექტი.

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

მაგალითად თუ გვაქვს კლასი:

1
2
3
4
5
6
public class MyClass {
   public void doSomething() {
        String myString = "doing";
        System.out.println(myString + " something");
   }
}

ხოლო შემდეგ ამ კლასს თუ გამოვიყენებთ სხვა ნებისმიერ კლასში:

1
2
3
4
5
6
public class SomeOtherClass {
   public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.doSomething();
   }
}

შედეგად მივიღებთ “doing something” სტრიქონს:

doing something

ამ შემთხვევაში უბრალოდ გამოყენებულ იქნა MyClass კლასის doSomething() მეთოდი, სწორედ ამ მეთოდზე შეგვიძლია ვთქვათ რომ ეს არის კლასის ინტერფეისი, რადგან მისი მეშვეობით ვმუშაობთ კლასთან. ასევე საგულისხმოა ის დეტალი რომ კლიენტისათვის(ამ შემთხვევაში SomeOtherClass – ის main მეთოდი) აბსოლუტურად უმნიშვნელოა doSomething() მეთოდის რეალიზაციის დეტალები, ასეთ შემთხვევაში საკმარისია მხოლოდ იმის ცოდნა რომ doSomething მეთოდი არსებობს და მასზე წვდომა გაგვაჩნია.

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

მაგალითად თუ ავღწერთ ინტერფეისს სახელად Movable (მოძრავი), და მასში განვსაზღვრავთ მეთოდებს move(), moveUp(), moveDown(), ნებისმიერი კლასი რომელიც მოახდენს ამ ინტეფეისის რეალიზაციას ვალდებული იქნება ჩამოთვლილი მეთოდების რეალიზაციაზე – ეს ნიშნავს რომ კლასი ეთანხმება კონტრაქტს.

იმ შემთხვევაში თუ გვინდა რომ რომელიმე კლასი გახდეს Movable, ამისათვის საკმარისია Movable ინტერფეისის რეალიზაცია(იმპლემენტაცია), რაც გამოიხატება იმაში რომ კლასში უნდა მოხდეს Movable ინტერფეისში აღწერილი move(), moveUp(), moveDown() მეთოდების რეალიზაცია.

თავად ინტერფეისი აღიწერება შემდეგნაირად:

1
2
3
4
5
interface Movable {
     public void move();
     public void moveUp();
     public void moveDown();
}

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

1
2
3
4
5
6
7
8
9
10
11
class MyMovableClass implements Movable {
     public void move() {
          System.out.println("just moving");
     }
     public void moveUp() {
          System.out.println("now moving UP");
     }
     public void moveDown() {
          System.out.println("and now moving DOWN");
     }
}

MyMovableClass კლასი ახორციელებს Movable ინტერფეისის რეალიზაციას. ამის მითითება ხდება implemenets გასაღები სიტყვის გამოყენებით. საგულისხმოა ის ფაქტი რომ განსხვავებით მემკვიდრეობისაგან სადაც extends ის შემდეგ შეგვიძლია მივუთითოთ მხოლოდ ერთი კლასი, implemenets – ის შემთხვევაში შეგვიძლია ჩამოვთვალოთ რამდენიმე ინტერფეისი. მაგალითად:

1
2
3
calss SomeClass implements Movable, OtherInterface, OneMoreInterface {
     //rest of code here
}

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

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

  • იგი არ უნდა იყოს abstract;
  • მასში უნდა იყოს რეალიზებული ინტერფეისში/ინტერფეისებში განსაზღვრული ყველა მეთოდი;

რა უნდა გვახსოვდეს ინტერფეისების შესახებ?

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

  • ინტერფეისი არაცხადად არის abstract აბსტრაქტული და მისი აღწერისას არ არის საჭირო abstract – ის მითითება;
  • ინტერფეისის ყველა მეთოდი არაცხადად არის public და abstract. რაც ნიშნავს იმას რომ არ არის საჭირო ამ მოდიფიკატორების მითითება მეთოდების აღწერისას, რადგან ისინი მაინც ყოველთვის არიან public და abstract;
  • მეთოდების აღწერისას დაუშვებელია private და protected წვდომის მოდიფიკატორების გამოყენება, რადგან ყველა მეთოდი აუცილებლად უნდა იყოს public;
  • ინტერფეისში აღწერილი ნებისმიერი ცვლადი უნდა იყოს public, static და final. რაც ნიშნავს იმას რომ ინტერფეისში შესაძლებელია მხოლოდ კონსტანტების აღწერა;
  • შეუძლებელია static(სტატიკური) მეთოდების აღწერა;
  • რადგან ინტერფეისის ყველა მეთოდი არის abstract(აბსტრაქტული), შეუძლებელია მათი აღწერა როგორც final;
  • შესაძლებელია რომ ინტერფეისი იყოს, სხვა ინტერფეისების მემკვიდრე(extends – ის შემდეგ შესაძლებელია ერთი ან მეტი ინტერფეისის მითითება);
  • შეუძლებელია რომ ინტერფეისი იყოს მემკვიდრე ჩვეულებრივი ან აბსტრაქტული კლასისა;
  • ინტერფეისის მეშვეობით შეუძლებელია სხვა ინტერფეისის(ინტერფეისების) რეალიზაცია. ანუ ჩაწერა interface MyInterface implements AnotherInterface {} დაუშვებელი და შეუძლებელია;
  • ინტერფეისი უნდა აღიწეროს interface გასაღები სიტყვის მეშვეობით;


ინტერფეისის აღწერის მაგალითები

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//ინტერფეისი ნაგულისხმევი წვდომის მოდიფიკატორით
interface Movable {
  //rest of code here
}

//ინტერფეისი public წვდომის მოდიფიკატორით
public interface Movable {
  //rest of code here
}

//ინტერფეისი abstract მოდიფიკატორით
//ინტერფეისი public წვდომის მოდიფიკატორით
public abstract interface Movable {
  //rest of code here
}

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


ინტერფეისის მეთოდების აღწერის მაგალითები

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//ინტერფეისი მეთოდების ნაგულისხმევი მოდიფიკატორებით (public abstract)
interface Movable {
  void move();
  void moveUp();
  void moveDown();
}

//ინტერფეისი public მეთოდების აღწერით
interface Movable {
  public void move();
  public void moveUp();
  public void moveDown();
}

//ინტერფეისი public abstract მეთოდების აღწერით
interface Movable {
  public abstract void move();
  public abstract void moveUp();
  public abstract void moveDown();
}

//ინტერფეისი abstract public მეთოდების აღწერით
interface Movable {
  abstract public void move();
  abstract public void moveUp();
  abstract public void moveDown();
}

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

ინტერფეისებთან მუშაობის დროს ასევე მნიშვნელოვანია გვახსოვდეს რომ ინტერფეისი შესაძლებელია იყოს სხვა ინტერფეისისა ან ინტერფეისების მემკვიდრე. მაგალითად შესაძლებელია Movable ინტერფეისის მსგავსი მოდიფიკაცია:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//UpMovable ინტერფეისი
interface UpMovable {
  void moveUp();
}

//DownMovable ინტერფეისი
interface DownMovable {
  void moveDown();
}

//Movable ინტერფეისი, რომელიც არის UpMovable და DownMovable ინტერფეისების მემკვიდრე
interface Movable extends UpMovable, DownMovable { 
  void move();
}

მაგალითში ნაჩვენებია აღნიშნული მემკვიდრეობის შესაძლებლობის რეალიზაცია, სადაც Movable ინტერფეისის აღწერისას extends გასაღები სისტყვის შემდეგ მითითებულია ორი ახალი UpMovable და DownMovable ინტერფეისების ჩამონათვალი. ასეთ შემთხვევაში ნებისმიერ კლასი რომელიც შეეცდება Movable ინტერფეისის რეალიზაციას უკვე ვალდებული იქნება მოახდინოს არა მხოლოდ move() მეთოდის რეალიზაცია(რომელიც აღწერილია Movable ინტერფეისში), არამედ იგი ვალდებული იქნება ასევე მოახდინოს moveUp() და moveDown() მეთოდების რეალიზაცია რომლებიც განსაზღვურლია შესაბამის ინტერფეისებში. რეალიზაციის მაგალითი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class InterfaceTest implements Movable {
 
  //implement moveUp() method
  public void moveUp() {
    //rest of code here
  }
 
  //implement moveDown() method
  public void moveDown() {
    //rest of code here
  }
 
  //implement move() method
  public void move() {
    //rest of code here
  }
 
}

ამ შემთხვევაში InterfaceTest კლასში რეალიზებული ყველა ინტერფეისის მეთოდი. რადგან კალსის აღწერისას მითითებულია რომ ეს კლასი რეალიზაციას უკეთებს Movable ინტერფეიის, ხოლო თავად ეს ინტერფეისი არის მემკვიდრე UpMovable და DownMovable ინტერფეისებისა, ეს კლასი ვალდებულია რომ მასში მოხდეს ყველა ინტერფეისის მეთოდის რეალიზაცია, წინააღმდეგ შემთხვევაში კლასი არ დაკომპილირდება.


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


კონსტანტური ცვლადების აღწერა ინტერფეისში

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
interface Movable {
       
        //კონსტანტის აღწერა ყველა მოდიფიკატორის მითითებით
  public static final int NUMBER_ONE = 1;

        //კონსტანტის აღწერა public მოდიფიკატორის გარეშე
  static final int NUMBER_TWO = 2;

        //კონსტანტის აღწერა public მოდიფიკატორის გარეშე
  public final int NUMBER_THREE = 3;

        //კონსტანტის აღწერა final მოდიფიკატორის გარეშე
  public static int NUMBER_FOUR = 4;

        //კონსტანტის აღწერა public და final მოდიფიკატორების გარეშე
  static int NUMBER_FIVE = 5;

        //კონსტანტის აღწერა public და static მოდიფიკატორების გარეშე
  final int NUMBER_SIX = 6;

        //კონსტანტის აღწერა public, static და final მოდიფიკატორების გარეშე
  int NUMBER_SEVEN = 7;
}

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

]]> http://www.code.ge/posts/java-interfaces/feed 0 ინიციალიზაციის მიმდევრობა Java – ში http://www.code.ge/posts/initialization-order-in-java http://www.code.ge/posts/initialization-order-in-java#comments Tue, 03 Apr 2007 07:47:12 +0000 იოსები http://www.code.ge/java/initialization-order-in-java ინიციალიზაცია ჯავაში საკმაოდ ნიუანსური და ერთი შეხედვით საკმაოდ რთული საკითხია, თუმცა სინამდვილეში ყველაფერი ზედმეტად მარტივი და ლოგიკურია. ინიციალიზაცია იყოფა რამდენიმე ნაწილად და ყოველთვის ერთი და იგივე მიმდევრობით სრულდება მიუხედავად კონკრეტული იერარქიის სიღრმისა და სირთულისა.

პირველ რიგში მნიშვნელოვანია ვიცოდეთ თუ როგორ ხდება კლასების ჩატვირთვა ამ ენაში. ჯავაში კლასები იტვირთება დინამიურად საჭიროების მიხედვით და ეს ხდება მხოლოდ ერთხელ.

რა დროს იტვირთება კლასი? კლასის ჩატვირთვა ხდება მხოლოდ მაშინ როდესაც მივმართავთ მის რომელიმე სტატიკურ წევრს(იგულისხმება რომ ასეთ წევრს უნდა გააჩნდეს შესაბამისი წვდომის მოდიფიკატორი რათა მასზე წვდომა იყოს შესაძლებელი). გარდა კლასის ჩვეულებრივი სტატიკური ცვლადებისა და მეთოდებისა უნდა აღინიშნოს რომ კლასის კონსტრუქტორიც ასევე არის სტატიკური(თუმცა არაცხადად, რადგან მას არ ესაჭიროება static გასაღები სიტყვის მითითება). გამომდინარე აქედან შეგვიძლია ვთქვათ რომ კლასის ობიექტის შექმნისას როდესაც new ოპერატორის შემდეგ მივმართავთ სასურველი კლასის კონსტრუქტორს(მაგ. TestClass t = new TestClass()), სინამდვილეში მივმართავთ კლასის სტატიკურ წევრს და იმ შემთხვევაში თუ კლასი ჯერ არ არის ჩატვირთული ხდება მისი ჩატვირთვა.

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

იმისათვის რათა უფრო დეტალურად გავიგოთ ინიციალიზაციის მიმდევრობა საჭიროა გამოვყოთ ამ პროცესში მონაწილე ყოველი ნაწილი.

1) კლასის სტატიკური ცვლადების ინიციალიზაცია

კლასის სტატიკურ ცვლადებს ენიჭებათ საწყისი მნიშვნელობები(თუ ცხადად არ არის მითითებული რაიმე კონკრეტული მნიშვნელობა)

2) კლასის სტატიკური ინიციალიზაციის ბლოკები

სტატიკური ინიციალიზაციის ბლოკები სრულდება მხოლოდ ერთხელ კლასის ჩატვირთვისას და იმ მიმდევრობით რა მიმდევრობითაც არიან ასეთი ბლოკები განსაზღვრული კლასში(იხ. სტატიკური ცვლადები და მეთოდები)

3) კლასის ცვლადების ინიციალიზაცია

კლასის ცვლადებს ენიჭებათ საწყისი მნიშვნელობები(თუ ცხადად არ არის მითითებული რაიმე კონკრეტული მნიშვნელობა) კლასის ყოველი ახალი ობიექტის შექმნისას

4) კლასის ინიციალიზციის ბლოკები

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

5) კონსტრუქტორები

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

ჩამოთვლილი ეტაპები გარდა იმისა რომ ვრცელდება კონკრეტულ ერთ კლასზე – ასევე ვრცელდება კლასების მთელ იერარქიაზე რა სიღრმისაც არ უნდა იყოს იერარქია ინიციალიზაციის პროცესი შესრულდება ზევიდან(იერარქიის სათავიდან) ქვევით და ზუსთად ზემოთ აღწერილი მიმდევრობით

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
class TestParent {
 
  private static String str;
 
  private int t;
 
  /**
   * Static initialization block
   */
  static {
    str = "TestParent Class Static Initialization";
    System.out.println(str);
  }
 
  /**
   * Initialization block
   */
  {
    t = 24;
    System.out.println("TestParent Class Initialization block: int t = " + t);
  }
 
  /**
   * Test Class Constructor
   */
  TestParent() {
    System.out.println("TestParent Class Constructor: int t = " + t);
  }
 
}

class TestChild extends TestParent {
 
  /**
   * Private static variable
   */
  private static String str;
 
  /**
   * Static initialization block
   */
  static {
    str = "TestChild Class Static Initialization";
    System.out.println(str);
  }
 
  /**
   * Initialization block
   */
  {
    System.out.println("TestChild Class Initialization block");
  }
 
  /**
   * TestOne Class Constructor
   */
  TestChild() {
    System.out.println("TestChild Class Constructor");
  }
 
  static void test() {
    System.out.println("TestChild's static test method");
  }
 
}

public class InitTest {
 
  public static void main(String[] args) {
   
    /**
     * Create TestChild class instance
     */
    new TestChild();

    /**
     * Invoce TestChild class' static test method
     */
    //TestChild.test();

  }

}

კოდის დაკომპილირებისა და გაშვების შემდეგ new TestChild(); გამოსახულების შესრულების შემდეგ მივიღებთ ქვემოთ ნაჩვენებ შედეგს:

TestParent Class Static Initialization
TestChild Class Static Initialization
TestParent Class Initialization block: int t = 24
TestParent Class Constructor: int t = 24
TestChild Class Initialization block
TestChild Class Constructor

თუ გავაანალიზებთ შედეგს დავინახავთ რომ ინიციალიზაცია იერარქიაში ხდება ზევიდან ქვევით, მიუხედავად იმისა რომ new TestChild(); გამოსახულება ქმნის TestChild კლასის ობიექტის, პირველად მისი მშობელი TestParent კლასის ყველა ინიციალიზაციის ბლოკი სრულდება, შემდეგ სრულდება მშობელი კლასის კონსტრუქტორი ხოლო უკვე შემდეგ სრულდება თვით TestChild კლასის ინიციალიზაციის ბლოკები და ბოლოს კი კონსტრუქტორი.

თუ გავაკომენტარებით new TestChild(); გამოსახულებას და შევასრულებთ მხოლოდ TestChild.test(); გამოსახულებას შედეგი იქნება შემდეგი სახის:

TestParent Class Static Initialization
TestChild Class Static Initialization
TestChild's static test method

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

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

]]> http://www.code.ge/posts/initialization-order-in-java/feed 3 Quercus – PHP in Java http://www.code.ge/posts/quercus-php-in-java http://www.code.ge/posts/quercus-php-in-java#comments Wed, 28 Mar 2007 13:08:45 +0000 იოსები http://www.code.ge/java/quercus-php5-java-implementation აჟიტირებული ვარ სრული ამ სიტყვის მნიშნველობით… ასეთ რამეს მართლა არ ველოდი და ხელი მქონდა დიდი ხანია ჩაქნეული… ამასწინათ იკას ბლოგზე ვნახე პოსტი სათაურით: Breakthrough: Java Implementation of PHP5 თავისთავად დამაინტერესა(რატომღაც), დღეს გამოვნახე დრო და გავტესტე… სიმართლე უნდა ითქვას შედეგმა ყოველგვარ მოლოდინს გადააჭარბა…

PHP და Java ერთად? რაოდენ ირონიულადაც არ უნდა ჟღერდეს თურმე ეს შესაძლებელია. რა საჭიროა? მიჭირს კონკრეტული მაგალითის მოყვანა, თუმცა გავიხსენებ ერთი წლის წინანდელ შემთხვევას როდესაც ერთერთი მეგა კომპანიის(არა ქართული) რეპორტინგის სისტემაზე მუშაობისას როცა სკრიპტინგი აღმოჩნდა საჭირო(ამას გააჩნდა საფუძვლიანი მიზეზი) როგორ ვნატრობდი რომ Groovy – ის ნაცვლად PHP – ზე შემძლებოდა წერა… თუმცა ამის შესაძლებლობა მაშინ არ მომეცა.

მიუხედავად იმისა რომ ეს ძრავი ჯერ არ მუშაობს ბევრისათვის კარგად ნაცნობ Tomcat – ზე მიმაჩნია რომ არც ეს არის შორეული პერსპექტივა… რაც შეეხება ტესტირების შედეგებს…

პირველ რიგში ამისათვის საჭიროა Resin Server – ი, რომელიც კარგად არის ნაცნობი Java დეველოპერებისათვის და იგი შეგიძლიათ გადმოწეროთ შემდეგი მისამართიდან: Resin Pro 3.1.0 Download.

ასევე საჭიროა JDK 5 ან უფრო მაღალი ვერსია, მისი ინსტალაციის ინსტრუქცია შეგიძლიათ ნახოთ ამ მისმართზე.

Resin – ის გადმოწერის შემდეგ საჭიროა მისი დეარქივაცია, ჩემს შემთხვევაში ეს გავაკეთე C:\web\resin მისამართზე. მეტი ინსტალაციისათვის არაფერი არ არის საჭირო. სერვერის გასაშვებად საკმარისია httpd.exe ფაილის გაშვება, ხოლო http://localhost:8080/ მისამართის გახსნის შემდეგ დავინახავთ შესაბამის გვერდს რომელიც გვატყობინებს რომ Resin დასტარტულია.

როგორ გავუშვათ PHP სკრიპტი? ამისათვის საკმარისია C:\web\resin\webapps\ROOT კატალოგში შევქმნათ კატალოგი სასურველი სახელით, ჩემს შემთხვევაში კატალოგს დავარქვი test. შემდეგ ახლად შექმნილ კატალოგში უნდა შევქმნათ WEB-INF კატალოგი და მასში მოვათავსოთ web.xml ფაილი და ჩავწეროთ მასში შემდეგი ინსტრუქციები:

<web-app xmlns="http://caucho.com/ns/resin">
  <servlet-mapping url-pattern="*.php" servlet-class="com.caucho.quercus.servlet.QuercusServlet">
    <init>
      <script-encoding>iso-8859-1</script-encoding>
    </init>
  </servlet-mapping>
</web-app>

ეს არის და ეს ახალი ვებ აპლიკაციის კონფიგურაცია დასრულებულია და შეგვიძლია შევუდგეთ PHP – ზე წერას. test კატალოგში გააკეთეთ ჩვეულებრივი index.php ფაილი, ტესტირებისათვის შეგიძლიათ გამოიყენოთ შემდეგი კოდი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class Test {
 
  private $test;
 
  function __construct() {
    $this->test = "this is test";
  }
 
  static function runTest() {
    return "This is static method";
  }
 
  public function getVar() {
    return $this->test;
  }
 
  public function testArrayList() {
   
                //create ArrayList object
    $list = java("java.util.ArrayList", array(1, 2, 3, 4));
   
                //add instance of class Test into arraylist
    $list->add(new Test());
   
                //create another ArrayList instance
    $l1 = java("java.util.ArrayList", array("Test Array List"));
   
                //add $l1 to $list arraylist object
    $list->add($l1);
   
                //output object
    echo '<pre>';
    print_r($list);
   
  }
 
}

$t = new Test();

$t->testArrayList();

echo $t->getVar();

echo '<br />';

echo Test::runTest();

კოდის მუშაობის შედეგი შეგიძლიათ შემოწმოთ http://localhost:8080/test/index.php მისამართზე. როგორც მაგალითიდან ჩანს ჩვეულებრივ PHP – ს კოდთან გვაქვს საქმე რომელიც ისევე ჩვეულებრივად მუშაობს Resin – ზე როგორც იმუშავებდა PHP5/Apache2 ტანდემის შემთხვევაში, თუმცა ყურადღება უნდა მივაქციოთ testArrayList მეთოდს რომელიც უშუალოდ მუშაობს Java – ს ArrayList კლასთან.

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

java() ფუნქციის მიერ დაბრუნებული ობიექტი შეგვიძლია გამოვიყენოთ ისევე როგორც ამას გავაკეთებდით Java – ში. მაგალითად: $list->add(new Test()); ამ შემთხვევაში add არის ArrayList კლასის მეთოდი. გამომდინარე იქიდან რომ ArrayList არის კონტეინერი მისი იტერაცია შეგვიძლია PHP – ს foreach ოპერატორის გამოყენებით.

დამატებითი დეტალებისთვის დოკუმენტაცია იხილეთ შესაბამის მისამართებზე:
Resin Documentaion
Quercus Documentaion

]]> http://www.code.ge/posts/quercus-php-in-java/feed 10 Singleton პატერნი – Java http://www.code.ge/posts/singleton-pattern-java http://www.code.ge/posts/singleton-pattern-java#comments Fri, 23 Feb 2007 02:16:49 +0000 იოსები http://localhost/wordpress/?p=9 ყველა სახელმძღვანელო რომელიც წამიკითხავს იწყება სწორედ ამ პატერნის აღწერით, რაც უდავოდ გამოწვეულია იმით რომ იგი წარმოადგენს ყველაზე მარტივს არსებულ პატერნებს შორის.

ამ პატერნის გამოყენებით შესაძლებელია კონკრეტული ტიპის(კლასის) ერთი და მხოლოდ ერთი ობიექტის (ეგზემპლარის) შექმნა რომელიც გამოყენებული იქნება გლობალურად გარკვეულ კონტექსტში. ზოგიერთ პროგრამირების ენაში (მაგ. C, PHP) არსებობს ე.წ. გლობალური ცვლადის ცნება, რომლის ინიციალიზაციაც ხდება ფუნქციებისა და კლასების კონტექსტ მიღმა და მისი გამოყენება შესაძლებელია ნებისმიერ ფუნქციასა თუ კლასში. მიუხედავად იმისა რომ Java არ არის აღჭურვილი მსგავსი შესაძლებლობით Singleton პატერნის მეშვეობით შესაძლებელია მივიღოთ იგივე(თუმცა უფრო დახვეწილი და მოქნილი) შედეგი რაც მიიღება გლობალური ცვლადებით სხვა ენებში.

თავისი უმარტივესი ფორმით ეს პატერნი შეიძლება ჩავწეროთ შემდეგნაირად:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Singleton {
   
    private static Singleton singleton = null; //private static variable to store reference to the singleton instance

    private Singleton() {} //private constructor

    public static Singleton getInstance() {

        if (singleton == null) {
            singleton = new Singleton();
        }

        return singleton; //return the reference

    }

}

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

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

ნაცვლად Singleton კლასის ობიექტის ცხადად შექმნის შესაძლებლობისა კლიენტს უნდა შევთავაზოთ მეთოდი(მეთოდები) რომლებიც იზრუნებენ ამ კლასის ობიექტის შექმნასა და მის დაბრუნებაზე. ზემოთ აღწერილ მაგალითში ასეთი მეთოდია getInstance() რომელიც არის public და ასევე static რაც გულისხმობს იმას რომ ამ მეთოდზე წვდომა შესაძლებელია მისი კლასის ობიექტის არსებობის გარეშე.

თავისთავად მეთოდი მარტივია და აკეთებს ორ ძირითად რამეს:

  1. ამოწმებს არსებობს თუ არა Singleton კლასის ობიექტი, თუ არ არსებობს ქმნის მას.
  2. აბრუნებს უკვე არსებულ ობიექტს.

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

]]> http://www.code.ge/posts/singleton-pattern-java/feed 2 კონსტრუქტორები და ინსტანციაცია (კლასის ობიექტის შექმნა) http://www.code.ge/posts/constructors-in-java http://www.code.ge/posts/constructors-in-java#comments Thu, 22 Feb 2007 03:07:42 +0000 იოსები http://localhost/wordpress/?p=7 ყოველი კლასის ახალი ობიექტი იქმნება კლასის კონსტრუქტორის გამოძახებით. გარდა ამისა ასევე შეუძლებელია ახალი ობიექტის შექმნა არა მხოლოდ ობიექტის ფაქტიური კლასის კონსტრუქტორის გამოძახების გარეშე, არამედ ეს შეუძლებელია ყოველი მისი სუპერკლასის კონსტრუქტორის გამოძახების გარეშე. კონსტრუქტორი არის კოდის ის ნაწილი რომელიც სრულდება ყოველთვის როდესაც ხდება new ოპერატორის გამოყენება.

კონსტრუქტორის საფუძვლები

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

1
2
3
4
5
class Foo {

    Foo() {} // Foo კლასის კონსტრუქტორი

}

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

1
2
3
4
5
6
7
8
9
10
11
12
class Foo {

    int size;

    String name;

    Foo(String name, int size) {
        this.name = name;
        this.size = size;
    }

}

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

Foo f = new Foo();//არ დაკომპილირდება რადგან არ არსებობს შესაბამისი (უპარამეტრო) კონსტრუქტორი

ხოლო შემდეგი კოდი დაკომპილირდება წარმატებით:

Foo f = new Foo(“Bar”, 43); //დაკომპილირდება, რადაგან გადაცემული პარამეტრები შეესაბამება Foo კონსტრუქტორს

ამ მაგალითიდან გამომდინარე, მიღებულია (და სასურველი) რომ კლასს გააჩნდეს უპარამეტრო კონსტრუქტორი, მიუხედავად იმისა თუ რამდენი გადატვირთული კონსტრუქტორი გააჩნია ამ კლასს (კონსტრუქტორების გადატვირთვა შესაძლებელია). თუმცა ასევე არსებობს შემთხვევები როდესაც უმჯობესია თუ კლასში არ იქნება უპარამეტრო კონსტრუქტორი.

კონსტრუქტორების გამოძახების მიმდევრობა

ცნობილია რომ კონსტრუქტორები გამოიძახება კოდის შესრულების დროს new ოპერატორის გამოყენების შემდეგ, მაგალითად:

1
Horse h = new Horse();

განვიხილოთ თუ რა ხდება როდესაც ვქმნით კლასის ობიექტს (new Horse())

დავუშვათ რომ Horse კლასის მშობელი არის Animal კლასი, ხოლო Animal კლასის მშობელი კლასი არის Object. ასეთ შემთხვევაში კლასის ობიექტის შექმნისას შესრულდება შემდეგი ბიჯები:

  1. თუკი სხვაგვარად არ არის მითითებული, Horse -ს კონსტრუქტორი ავტომატურად იძახებს მისი მშობელი კლასის უპარამეტრო კონსტრუქტორს (თუკი მშობელს კონსტრუქტორი განსაზღვრული არ აქვს, იძახება ნაგულისხმევი კონსტრუქტორი) ”სხვაგვარად მითითებული” გულისხმობს იმას, რომ Horse კონსტრუქტორს შეუძლია მშობლის კონსტრუქტორის ცხადად გამოძახებაც
  2. გამოიძახება Animal კონსტრუქტორი (Animal არის Horse კლასის მშობელი (super) კლასი).
  3. გამოიძახება Object კონსტრუქტორი (რადგან Object კლასი არის საწყისი სუპერკლასი ყველა სხვა კლასისთვის, გამომდინარე აქედან იგი არის Animal კლასის მშობელი კლასი (მიუხედავად იმისა ცხადად დავწერთ თუ არა “extends Object” Animal კლასის აღწერისას)).
  4. Object კლასის ობიექტის ცვლადებს ენიჭებათ განსაზღვრული მნიშვნელობები (ამ შემთხვევაში განსაზღვრულ მნიშვნელობაში იგულისხმება მნიშვნელობა რომლებიც ენიჭებათ ცვლადებს მათი აღწერის მომენტში მაგ. „int j = 20”, სადაც „20“ არის განსაზღვრული (განსხვავებით საწყისი (ნაგულისხმევი) მნიშვნელობისგან) მნიშნველობა კლასის ობიექტის ცვლადისა).
  5. Object კონსტრუქტორი ამთავრებს შესრულებას.
  6. Animal კლასის ობიექტის ცვლადებს ენიჭებათ განსაზღვული მნიშვნელობები (თუ მსგავსი არსებობს).
  7. Animal კონსტრუქტორი ამთავრებს შესრულებას.
  8. Horse კლასის ობიექტის ცვლადებს ენიჭებათ განსაზღვული მნიშვნელობები (თუ მსგავსი არსებობს).
  9. Horse კონსტრუქტორი ამთავრებს შესრულებას.

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

4. Object()
3. Animal() იძახებს super() – ს
2. Horse() იძახებს super() – ს
1. main() იძახებს new Horse() – ს

კონსტრუქტორების წესები

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

  • კონსტრუქტორებთან დასაშვებია ნებისმიერი მოდიფიკატორის გამოყენება (private კონსტრუქტორი ნიშნავს იმას რომ მხოლოდ მოცემული კლასის ფარგლებში არსებული კოდის გამოყენებით შეიძლება ამ კლასის ობიექტის შექმნა, თუ საჭიროა ამ კლასის ობიექტის გამოყენება მის გარეთ ასეთ შემთხვევაში კლასს უნდა გააჩნდეს სტატიკური (static) მეთოდი ან ცვლადი რომელიც ამ კლასის ობიექტთან წვდომის საშუალებას მისცემს მის გარეთ მყოფ სხვა კოდს). ასევე არსებობს კიდევ private კონსტრუქტორის კიდევ ერთი გამოყენება, ასეთი კონსტრუქტორის გამოძახება შესაძლებელია იმავე კლასში არსებული სხვა კონსტრუქტორებიდან.
  • კონსტრუქტორის სახელი უნდა იყოს იგივე რა სახელიც ქვია კლასს.
  • კონსტრუქტორს არ უნდა გააჩნდეს დასაბრუნებელი მნიშვნელობის ტიპი.
  • დასაშვებია (მაგრამ აზრს მოკლებული) მეთოდის არსებობა იგივე სახელით რა სახელიც ქვია კლასს. თუ ასეთ მეთოდს გააჩნია დასაბრუნებელი მნიშვნელობის ტიპი ეს ნიშნავს რომ იგი არის მეთოდი და არა კონსტრუქტორი.
  • თუ კლასის შიგნით არ არის აღწერილი არცერთი კონსტრუქტორი, ასეთ შემთხვევაში კომპილატორი ავტომატურად დააგენერირებს უპარამეტრო კონსტრუქტორს (ნაგულისხმევი კონსტრუქტორი).
  • ავტომატური კონსტრუქტორის გენერაცია ხდება მაშინ და მხოლოდ მაშინ, თუ კლასში სხვა კონსტრუქტორი ცხადად არ არის აღწერილი
  • ყველა კონსტრუქტორში პრიველი გამოსახულება ყოველთვის არის ან გადატვირთული კონსტრუქტორის გამოძახება (this()) ან მშობელი კლასის კონსტრუქტორის გამოძახება (super()), ასევე აღსანიშნავია რომ ასეთი გამოძახება შესაძლებელია დააგენერიროს კომპილატორმა.
  • იმ შემთხვევაში თუ კონსტრუქტორში არ დავწერთ მშობელი კლასის (super()) ან გადატვირთული (this()) კონსტრუქტორის გამოძახებას, მაშინ კომპილატორი ავტომატურად დააგენერირებს უპარამეტრო super() კონსტრუქტორის გამოძახების კოდს და ჩასვავს მათ კონსტრუქტორის პირველ გამოსახულებად.
  • super() მეთოდის გამოძახება შესაძლებელია იყოს როგორც უპარამეტრო ასევე პარამეტრიზებული.
  • უპარამეტრო კონსტრუქტორი არ არის აუცილებლად ნაგულისხმევი (default) (ე.ი. კომპილატორის მიერ დაგენერირებული) კონსტრუქტორი, მიუხედავად იმისა რომ ნაგულისხმევი კონსტრუქტორი ყოველთვის არის უპარამეტრო. ნაგულისხმევი კონსტრუქტორი ეწოდება ისეთ კონსტრუქტორს რომელსაც ქმნის კომპილატორი.
  • კონსტრუქტორიდან შეუძლებელია კლასის ობიექტის მეთოდის გამოძახება, ან მიმართვა კლასის ობიექტის ცვლადებზე, იქამდე სანამ არ დამთავრდება ყველა მშობელი კლასის კონსტრუქტორების შესრულება. (ეს არ ვრცელდება სტატიკურ მეთოდებსა და ცვლადებზე)
  • აბსტრაქტულ კლასებს აქვთ კონსტრუქტორები, ეს კონსტრუქტორები ყოველთვის გამოიძახება როდესაც ხდება კონკრეტული კლასის ობიექტის შექმნა.
  • ინტერფეისებს არ გააჩნიათ კონსტრუქტორები. ინტერფეისები არ არინ ობიექტების მემკვიდრული იერარქიის ნაწილი.
  • ერთადერთი საშუალება კონსტრუქტორის გამოძახებისა არის მისი გამოძახება სხვა კონსტრუქტორიდან, შეუძლებელია ისეთი კოდის დაწერა რომელიც განახორციელებს უშუალოდ კონსტრუქტორის გამოძახებას:
  • class Horse() {Horse() { } //კონსტრუქტორი
1
2
3
void doCall() {
    Horse(); //მსგავსი მიმართვა დაუშვებალია!
}

რა შემთხვევაში გენერირდება ნაგულისხმევი კონსტრუქტორი?

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

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

1
2
3
4
5
6
7
class Horse {

    Horse() { }

    Horse(String name) { }

}

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

განვიხილოთ აღწერილი კლასის სხვა ვარიანტი:

1
2
3
4
5
class Horse {

    Horse(String name) { }

}

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

განვიხილოთ იგივე კლასის შემდეგი ვარიანტი:

1
2
3
class Horse {

}

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

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

  • ნაგულისხმევ კონსტრუქტორს აქვს იგივე წვდომის მოდიფიკატორი რაც კლასს.
  • ნაგულისხმევ კონსტრუქტორს არ აქვს პარამეტრები.
  • ნაგულისხმევი კონსტრუქტორი შეიცავს სუპერ (super) კონსტრუქტორის უპარამეტრო გამოძახებას (super()).

ცხრილში მოყვანილია მაგალითები სხვადასხვა შემთხვევებისათვის, თუ რას აგენერირებს (ან არ აგენერირებს) კომპილატორი:

ხელით დაწერილი კლასის კოდი კომპილატორის მიერ გენერირებული კონსტრუქტორის კოდი
class Foo {} class Foo {
Foo (){
super();
}
}
class Foo() {
Foo(){ }
}		 class Foo {
Foo (){
super();
}
}
public class Foo { } public class Foo {
public Foo (){
super();
}
}
class Foo {
Foo (String s){}
}		 class Foo {
Foo (String s){
super();
}
}
class Foo {
Foo(String s){
super()
}
}		 კომპილატორი არ დააგენერირებს კოდს.
class Foo() {
void Foo(){ }
}		 class Foo {
void Foo(){ }Foo() {
super();
}
}

რა ხდება იმ შემთხვევაში თუ სუპერ კონსტრუქტორს აქვს პარამეტრები?

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

1
2
3
4
5
6
7
8
9
10
11
class Bar {

void testInt(int x) { }

}
class TestBar {
public static void main (String[] args) {
Bar bar = new Bar();
bar.testInt(); //მეთოდის უპარამეტროდ გამოძახება
}
}

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

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

1
2
3
4
5
6
7
8
9
class Animal {
    Animal (String name) { }
}

class Dog extends Animal {
    Dog() {
        super(); //შეცდომაა
    }
}

მოყვანილ მაგალითში შეცდომა მდგომარეობს იმაში, რომ მშობელ Animal კლასს არ გააჩნია უპარამეტრო კონსტრუქტორი რომლის გამოძახებაც მოხდა Dog კონსტრუქტორიდან – super(). ასეთივე შეცდომა წარმოიქმნება შემდეგი შემთხვევისთვისაც:

1
2
3
4
5
class Animal {
    Animal (String name) { }
}

class Dog extends Animal { }

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

კომპილატორის მიერ მოდიფიცირებულ კოდს აქვს შემდეგი სახე:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Animal {
    Animal (String name) { }
}

class Dog extends Animal {

    /*კომპილატორის მიერ დაგენერირებული კონსტრუქტორი და
       სუპერ კონსტრუქტორის გამოძახება.*/

    class Dog() {
        /*გამოძახება გამოიწვევს შეცდომას,
           რადგან მშობელ კლასში არ არის განსაზღვრული  
           უპარამეტრო კონსტრუქტორი.
         */
        super();
    }

}

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

კონსტრუქტორების გადატვირთვა

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

1
2
3
4
5
6
7
class Foo {
   
    Foo(){ }

    Foo(String s) { }

}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Animal {
    String name;
    Animal(String name) {
        this.name = name;
    }
    Animal() {
        this(makeRandomName());
    }
    static String makeRandomName() {
        int x = (int) (Math.random() * 5);
        String name = new String[]{"NameOne",
                                    "NameTwo",
                                    "NameThree",
                                    "NameFour",
                                    "NameFive"}[x];
        return name;
    }
    public static void main (String[] args) {
        Animal a = new Animal();
        System.out.println(a.name);
        Animal b = new Animal("Spot");
        System.out.pringln(b.name);
    }
}

ცხრილში ნაჩვენებია გამოძახებების მიმდევრობა მოყვანილი მაგალითისთვის:

4. Object()
3. Animal(String s) იძახებს super() – ს
2. Animal() იძახებს this(„შემთხვევით არჩეული სტრიქონი“)
1. main() იძახებს new Animal() – ს

განვიხილოთ Animal კლასის კოდი:

  • ხაზი 2 String ტიპის ეგზემპლარის name ცვლადის აღწერა.
  • ხაზები 3-5 კონსტრუქტორი რომელიც ღებულობს String ტიპის პარამეტრს და ანიჭებს მას ეგზემპლარის ცვლადს.
  • ხაზი 7 იმ შემთხვევაში თუ კლიენტი (გამომძახებელი კოდი) არ გადასცემს კონსტრუქტორს პარამეტრს, უპარამეტრო კონსტრუქტორი დააგენერირებს სახელს makeRandomName() მეთოდის მეშვეობით.
  • ხაზი 8 უპარამეტრო კონსტრუქტორი გამოიძახებს მის გადატვირთულ პარამეტრიან კონსტრუქტორს რომელიც პარამეტრად ღებულობს სტრიქონს. გადატვირთული კონსტრუქტორის გამოძახება ხორციელდება this – ის მეშვეობით, თუმცა ასეთ შემთხვევაში this – ის გამოყენება წააგავს მეთოდესი გამოძახებას this().
  • ხაზი 11 აღსანიშნავია რომ makeRandomName() მეთოდი აღწერილია როგორც static. მეთოდი სტატიკური უნდა იყოს გამომდინარე იქიდან რომ შეუძლებელია ეგზემპლარის (არასტატიკური) მეთოდზე ან ცვლადზე კონსტრუქტორიდან მიმართვა იქამდე სანამ სუპერ კონსტრუქტორი არ იქნება გამოძახებული და იგი არ დაამთავრებს შესრულებას, ხოლო რადგან მოცემულ შემთხვევაში სუპერ (super()) კონსტრუქტორის გამოძახება ხდება მე-3 ხაზზე აღწერილი პარამეტრიანი კონსტრუქტორიდან და არა იმ კონსტრუქტორიდან რომელშიც ვიძახებთ makeRandomName() მეთოდს, ამ მეთოდის გამოძახების ერთადერთი საშუალება არის ის თუ მას აღვწერთ როგორც სტატიკურს.
  • ხაზი 12 ხდება 0 – სა და 4 – ს შორის არსებული შემთხვევითი მთელი რიცხვის გენერაცია.
  • ხაზი 13 იქმნება ახალი String ტიპის ობიექტი. რადგან მეთოდის ამოცანა მდგომარეობს იმაში რომ დააბრუნოს შემთხვევითი მნიშვნელობა სიიდან, აუცილებელია ამ სიის შექმნა. აღნიშნულ სტრიქონში:
  1. აღიწერება String ტიპის name ცვლადი.
  2. იქმნება String ტიპის მასივი (ანონიმურად – რადგან ეს მასივი არ ენიჭება რომელიმე ცვლადს).
  3. ხდება მასივის ელემენტის ამოღება [x] ინდექსით (x ცვლადი აღწერილია მე-12 ხაზზე).
  4. მასივიდან ამოღებული მნიშვნელობა ენიჭება name ცვლადს.
  • ხაზი 18 გამოიძახება უპარამეტრო კონსტრუქტორი (რომელიც თავისთავად იძახებს პარამეტრიან კონსტრუქტორს რომელსაც გადასცემს შემთხვევით მნიშვნელობას)
  • ხაზი 20 გამოიძახება გადატვირთული კონსტრუქტორი რომელსაც პარამეტრად გადაეცემა სტრიქონი.

განხილულ მაგალითში საკვანძო ნაწილია მე-8 ხაზი, სადაც super() კონსტრუქტორის ნაცვლად გამოიძახება this(). this() ყოველთვის ნიშნავს სხვა კონსტრუქტორის გამოძახებას იგივე კლასში. რადგან super() კონსტრუქტორის გამოძახება არის გარდაუვალი და აუცილებელი, ხოლო this() იძახებს Animal კლასის პარამეტრიან კონსტრუქტორს, super() გამოძახება მოხდება სწორედ აღნიშნულ პარამეტრიან კონსტრუქტორში.

ყოველივე ზემოთქმულიდან გამომდინარე კონსტრუქტორის პირველი გამოსახულება აუცილებლად უნდა იყოს ან super() ან this() გამოძახება.

ისეთ შემთხვევაში თუ კონსტრუქტორში არ არის არც ერთი super() და this() გამოძახება, კომპილატორი ჩასვავს super() ის უპარამეტრო გამოძახების კოდს.

წინა წესის გათვალისწინებით შეუძლებელია კონსტრუქტორში იყოს ორივე super() და this() გამოძახება. რადგან ერთერთი მათგანის გამოძახება უნდა იყოს პირველი გამოსახულება კონსტრუქტორში, შეუძლებელია მათი ერთდროულად გამოყენება.

]]> http://www.code.ge/posts/constructors-in-java/feed 1 სტატიკური ცვლადები და მეთოდები http://www.code.ge/posts/static-variables-and-methods http://www.code.ge/posts/static-variables-and-methods#comments Fri, 16 Feb 2007 20:51:31 +0000 იოსები http://localhost/wordpress/?p=4 ზოგჯერ არსებობს აუცილებლობა იმისა რომ შევქმნათ კლასის ისეთი ელემენტი (წევრი) რომლის გამოყენებაც შესაძლებელი იქნება ამ კლასის რომელიმე ობიექტის (ეგზემპლარის) არსებობის გარეშე. ზოგადად კლასის ელემენტებზე მიმართვა ხორციელდება ამ კლასის ობიექტის მეშვეობით, თუმცა შესაძლებელია ისეთი ელემენტების შექმნა რომლების გამოყენებაც შესაძლებელია განსაზღვრული ობიექტის გარეშე. ამის განსახორციელებლად საჭიროა ელემენტი გამოვაცხადოთ როგორც static. როდესაც ელემენტი აღწერილია როგორც static მას შეიძლება მივმართოთ კლასის ჩატვირთვისთანავე იქამდე სანამ მოხდება ამ კლასის რომელიმე ობიექტის შექმნა. სტატიკურად შეიძლება გამოვაცხადოთ როგორც მეთოდები, ასევე ცვლადები. static-ის ყველაზე გავრცელებულ გამოყენებას წარმოადგენს main() მეთოდი. იგი აღწერილია როგორც static, რადგან მისი გამოძახება უნდა მოხდეს იქამდე სანამ მოხდება რაიმე ობიექტების შექმნა.
კლასის ცვლადები რომლებიც გამოცხადებულია როგორც static, დაახლოვებით მსგავსია გლობალური ცვლადებისა.

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

  • მათ შეუძლიათ გამოიძახონ მხოლოდ სხვა სტატიკური მეთოდები.
  • მათ შეუძლიათ გამოიყენონ მხოლოდ სტატიკური ცვლადები.
  • მათ არ შეუძლიათ გამოიძახონ this ან super.

რა საჭიროა მსგავსი ელემენტების არსებობა და რა დანიშნულება გააჩნიათ მათ? იმისათვის რათა ცხადი გახდეს static ელემენტების მუშაობის პრინციპები, საჭიროა განვიხილოთ მათი გამოყენების აუცილებლობის მიზეზები. მაგალითისათვის განვიხილოთ კლასის ისეთი მეთოდი რომელიც ყოველთვის მუშაობს ერთნაირად, და მისი ერთადერთი დანიშნულებაა რაიმე შემთხვევითი რიცხვის დაბრუნება, მიუხედავად იმისა თუ კლასის რომელი ეგზემპლარიდან მოხდება მისი გამოძახება მისი ქცევა ყოველთვის იქნება ერთნაირი ანუ მეთოდის ქცევა არ იქნება დამოკიდებული კლასის მდგომარეობაზე. გამომდინარე აქედან ავტომატურად იბადება შეკითხვა თუ რა საჭიროა ობიექტის არსებობა როდესაც კლასის მეთოდი არ არის დამოკიდებული ეგზემპლარზე? სწორედ ასეთ შემთხვევებში გამოიყენება static წევრები. static წევრები ყოველთვის მიეკუთვნებიან კლასს და არა მის რომელიმე ეგზემპლარს. static ცვლადების და მეთოდების გამოყენება/გამოძახება შესაძლებელია ყოველთვის კლასის ეგზემპლარის არსებობის გარეშე. იმისათვის რათა გამოვიძახოთ static მეთოდი, ან მივმართოთ static ცვლადს, საკმარისია კლასი იყოს ჩატვირთული (იმპორტირებული? დაიმპორტებული? :D ). იმ შემთხვევაში თუ კლასს გააჩნია static ცვლადები, და თუ არსებობს ამ კლასის ობიექტები, მაშინ static ცვლადების მნიშვნელობები საერთო იქნება ყველა ამ ობიექტისათვის.

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Car {

    static int carCount = 0; //სტატიკური ცვლადის აღწერა და ინიციალიზაცია

    public Car() {
        carCount += 1; //მთვლელის მნიშვნელობის მოდიფიკაცია
    }

    public static void main(String[] args) {
        new Car();
        new Car();
        new Car();
        new Car();
        System.out.printLn(“Car count is “ + carCount);
    }

}

მოყვანილ მაგალითში, სტატიკურ carCount ცვლადს საწყის მნიშვნელობად ენიჭება ნული როდესაც ხდება კლასის ჩატვირთვა (კლასის რომელიმე ეგზემპლარის შექმნამდე). როდესაც მოხდება Car კლასის ნებისმიერი ობიექტის შექმნა ყოველი Car კონსტრუქტორის გამოძახებისა და შესრულების შემდეგ სტატიკური carCount ცვლადის მნიშვნელობა გაიზრდება ერთით. კლასის main მეთოდში ხორციელდება Car კლასის ოთხი ობიექტის შექმნა, როდესაც მეთოდი დაასრულებს მუშაობას რეზულტატი იქნება შემდეგი:

Car count is 4

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class TestStatic {
   
    static int x = 1;
    static int y = 2;
    static int z;

    static {
        ystem.out.printLn(“Static Block”);
        z= x + y;
    }

    static void test() {
        System.out.printLn(“x = “ + x);
        System.out.printLn(“y = “ + y);
        System.out.printLn(“z = “ + z);
    }

    public static void main(String args[]) {
        test();
    }

}

მოცემულ კლასის ყველა static ინსტრუქცია სრულდება მაშინათვე როცა მოხდება ამ კლასის ჩატვიღტვა. პირველად, ცვლადს x ენიჭება მნიშვნელობა 1, ცვლადს y ენიჭება მნიშვნელობა 2, შემდეგ სრულდება static ინიციალიზაციის ბლოკი იბეჭდება შეტყობინება “Static Block” და ხდება z ცვლადი ინიციალიზაცია x + y გამოსახულებით. ბოლოს გამოიძახება main მეთოდი რომელიც თავისმხრივ იძახებს მეთოდს test(). ამ პროგრამის შესრულებას აქვს შემდეგი შედეგი:

1
2
3
x = 1
y = 2
z= 3

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

ClassName.methodName();
ClassName.variableName;

სადაც ClassName არის კლასის სახელი, რომელშიც აღწერილია სტატიკური მეთოდი/ცვლადი, ხოლო methodName და variableName შესაბამისად მეთოდისა და ცვლადის სახელი.

]]> http://www.code.ge/posts/static-variables-and-methods/feed 0 პირველი HelloWorld ვებ აპლიკაცია http://www.code.ge/posts/%e1%83%9e%e1%83%98%e1%83%a0%e1%83%95%e1%83%94%e1%83%9a%e1%83%98-helloworld-%e1%83%95%e1%83%94%e1%83%91-%e1%83%90%e1%83%9e%e1%83%9a%e1%83%98%e1%83%99%e1%83%90%e1%83%aa%e1%83%98%e1%83%90 http://www.code.ge/posts/%e1%83%9e%e1%83%98%e1%83%a0%e1%83%95%e1%83%94%e1%83%9a%e1%83%98-helloworld-%e1%83%95%e1%83%94%e1%83%91-%e1%83%90%e1%83%9e%e1%83%9a%e1%83%98%e1%83%99%e1%83%90%e1%83%aa%e1%83%98%e1%83%90#comments Mon, 23 Oct 2006 10:12:32 +0000 იოსები http://www.ioseb.com/?p=21 ეს ტურორიალიც განკუთვნილია სტუდენტებისათვის, და დამწყები Java პროგრამისტებისთვის. დიდი მადლობა მიშა კაპანაძეს ტექსტის რედაქტირებისათვის, და ინსტალაციის ინსტრუქციის ლინუქსის ვერსიის დამატებისათვის.

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

Tomcat – ის ინსტალაცია Windows-ში
1) გადმოიწერეთ Tomcat-ის ვერსია Windows-ისათვის მისი ერთ-ერთი სერვერიდან

2) გაუშვით გადმოწერილი ფაილი
3) Choose Install Location განყოფილებაში ინსტალაციის მისამართად მიუთითეთ C:\tomcat5
4) Java Virtual Machine განყოფილებაში მიუთითეთ თქვენი JRE – ს მისამართი (აქ გამოქვეყნებული ჯავას ინსტალაციის ინსტრუქცით დაინსტალირების შემთხვევაში მიუთითეთ C:\jdk1.5\jre)
5) ინსტალაციის ბოლო ეტაპზე მონიშნეთ ჩეკბოქსი (თოლია) Run Apache Tomcat და დააჭირეთ ღილაკს Finish

Tomcat-ის მულტი-პლატფორმული ვერსიის ინსტალაცია (მუშაობს Linux, Windows და სხვა პლატფორმებზე)
ინსტალაცია ლინუქსზე

1) გადმოიწერეთ Tomcat-ის მულტი-პლატფორმული ვერსია მისი ერთ-ერთი სერვერიდან
2) გახსენით გადმოწერილი ფაილი რომელიმე დირექტორიაში. მაგალითად, /home/mikheil/tomcat
3) დარწმუნდით, რომ ჯავა სწორადაა ინსტალირებული? და Environment Variable, სახელად JAVA_HOME სწორადაა კონფიგურირებული და რომ ბრძანება java იშვება ამ დირექტორიიდან (ბრძანებით type java). თუკი ეს ასე არ არის, მაშინ თქვენს .bashrc ფაილში PATH-ის დასაწყისში ჩაუმატეთ $JAVA_HOME/bin: (ორწერტილი აუცილებელია დანარჩენი მისამართებისაგან გამოსაყოფად)
4) /home/mikheil/tomcat/bin -ში მოთავსებულ ფაილებს გაფართოებით sh მიეცით შესრულების უფლებები (მაგალითად, chmod 755 *.sh)
5) გაუშვით სკრიპტი startup.sh

ინსტალაციის შემოწმება
გახსენით თქვენი ინტერნეტ ბროუზერი (ნებისმიერი) და გახსენით შემდეგი მისამართი: http://localhost:8080/
თუ ჩაიტვირთა გვერდი წარწერით Apache Tomcat/5.5.20 და კატის სურათით ე.ი. ინსტალაციამ ჩაიარა წარმატებით.

1) შედით მისამართზე: C:\tomcat5\webapps
2) შექმენით ფოლდერი hello
3) hello დირექტორიაში შექმენით ქვედირექტორია სახელად WEB-INF
4) WEB-INF ფოლდერში შექმენით web.xml ფაილი (ფაილი შექმენით ზუსტად იგივე მეთოდით როგორც ნაჩვენები იყო წინა მაგალითში)
და მასში ჩაწერეთ შემდეგი ტექსტი:

1
2
3
4
5
6
7
8
9
10
< ?xml version="1.0" encoding="ISO-8859-1" ?>
<web -app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">
 
  <display -name>Hello, World Application</display>
  <description>Hello, World Application</description>

</web>

5) გადადით hello დირექტორიაში და მასში შექმენით ფაილი სახელად index.jsp და მასში ჩაწერეთ შემდეგი ტექსტი:

1
2
3
4
5
6
7
8
9
10
11
<html>
<head>
   <title>Hello World</title>
</head>

<body>

< % out.print("Hello World!"); %>

</body>
</html>

6) ამ ყველაფრის განხორციელების შემდეგ უნდა მიიღოთ ფაილების მსგავსი სტრუქტურა:

|-hello
|—index.jsp
|—web-inf
|——web.xml

7) გახსენით ბროუზერი და გახსენით შემდეგი მისამართი: http://localhost:8080/hello/

თუ ყველაფერი შეასრულედ სწორად ბროუზერში უნდა დაინხოთ შემდეგი ტექსტი: Hello World!

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

1) გახსენით თქვენს მიერ შექმნილი index.jsp ფაილი და დაარედაქტირეთ მისი ტექსტი შემდეგნაირად:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<html>
<head>
   <title>Hello World</title>
</head>

<body>




< %
   
  String name = request.getParameter("name");
   
  if (name != null) {
     out.print("Hello World! " + name);
  } else {
     out.print("Hello World!");
  }
   
%>




<hr />
<form method="get">
   Enter Name: <input type="text" name="name" />
</form>

</body>
</html>

2) გახსენით მისამართი: http://localhost:8080/hello/ თქვენ უნდა დაინახოთ სახეცვლილი გვერდი, კერძოდ მას დაემატა ერთი ტექსტური ველი. შეიტანეთ ამ ველში თქვენთვის სასურველი სახელი (ან ნებისმიერი ტექსტი) და დააჭირეთ ღილაკს Enter

შედეგად მივიღეთ მცირე ინტერაქტიული ვებ აპლიკაცია.

ოდნავ გავართულოთ აპლიკაცია და გადავაკეთოთ იგი მარტივ კალკულატორად.

1) გახსენით და დაარედაქტირეთ index.jsp ფაილი შემდეგნაირად:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<html>
<head>
   <title>Hello World</title>
</head>



<body>
   
< %
   
  String calculate = request.getParameter("calculate");
   
  if (calculate != null) {
     
     int valueOne = Integer.parseInt(request.getParameter("valueOne"));
     int valueTwo = Integer.parseInt(request.getParameter("valueTwo"));
     int result = valueOne + valueTwo;
     
     out.print("<b>Calculation Result = " + result + "<br /><hr />");
       
   }
   
%>

<form method="get">
   Value One: <input type="text" name="valueOne" />
   <font color="red">+</font>
   Value Two: <input type="text" name="valueTwo" />
   <br />
   <input type="hidden" name="calculate" value="Calculate" />
   <input type="submit" name="calculate" value="Calculate" />
</form>

</body>
</html>

2) გახსენით მისამართი: http://localhost:8080/hello/ თქვენ უნდა დაინახოთ ორი ველი (Value One და Value Two) შეიტანეთ ამ ველებში ნებისმიერი ციფრები და დააჭირეთ ღილაკს Calculate

]]> http://www.code.ge/posts/%e1%83%9e%e1%83%98%e1%83%a0%e1%83%95%e1%83%94%e1%83%9a%e1%83%98-helloworld-%e1%83%95%e1%83%94%e1%83%91-%e1%83%90%e1%83%9e%e1%83%9a%e1%83%98%e1%83%99%e1%83%90%e1%83%aa%e1%83%98%e1%83%90/feed 2 პირველი Java პროგრამა http://www.code.ge/posts/%e1%83%9e%e1%83%98%e1%83%a0%e1%83%95%e1%83%94%e1%83%9a%e1%83%98-java-%e1%83%9e%e1%83%a0%e1%83%9d%e1%83%92%e1%83%a0%e1%83%90%e1%83%9b%e1%83%90 http://www.code.ge/posts/%e1%83%9e%e1%83%98%e1%83%a0%e1%83%95%e1%83%94%e1%83%9a%e1%83%98-java-%e1%83%9e%e1%83%a0%e1%83%9d%e1%83%92%e1%83%a0%e1%83%90%e1%83%9b%e1%83%90#comments Mon, 23 Oct 2006 10:05:22 +0000 იოსები http://www.ioseb.com/?p=20 Run და აკრიფეთ notepad ან აირჩიეთ Start->Programs->Accessories->Notepad 2) ახლად გახსნილ დოკუმენტში აკრიფეთ შემდეგი კოდი: 12345class HelloWorld {    public static void main(String args[]) {        System.out.println("Hello world!"); [...]]]> ეს პატარა ტუტორიალი დავწერე სტუდენტებისათვის. დარწმუნებული ვარ იგი გამოადგებათ დამწყებ Java პროგრამისტებისაც, ან უბრალოდ Java-თი დაინტერესებულ კოლეგებს.

1) გახსენით პროგრამა Notepad, იგი შეგიძლიათ გახსნათ ორი მეთოდით: Start->Run და აკრიფეთ notepad ან აირჩიეთ Start->Programs->Accessories->Notepad

2) ახლად გახსნილ დოკუმენტში აკრიფეთ შემდეგი კოდი:

1
2
3
4
5
class HelloWorld {
   public static void main(String args[]) {
       System.out.println("Hello world!");
   }
}

3) Notepad – ის მთავარი მენიუდან აირჩიეთ File->Save As, ფაილის შესანახად აირჩიეთ C:\ დისკი და ფაილს დაარქვით სახელი HelloWorld.java (მიაქციეთ ყურადღება ფაილს უნდა ერქვას იგივე სახელი რა სახელიც ქვია კლასს) Save as type გრაფაში აუცილებლად აირჩიეთ All Files და შეინახეთ დოკუმენტი (Save)

ფაილის შენახვის შემდეგ:

1) Start->Run და აკრიფეთ ბრძანება cmd
2) გახსნილ კონსოლში აკრიფეთ შემდეგი ბრძანება: cd c:\ და დააჭირეთ Enter ღილაკს
3) ახლად შექმნილი კლასის კომპილაციისთვის აკრიფეთ: javac HelloWorld.java და დააჭირეთ Enter ღილაკს
4) პროგრამის გასაშვებად აკრიფეთ: java HelloWorld და დააჭირეთ Enter ღილაკს

კონსოლზე უნდა დაიბეჭდოს: Hello world!

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

1) დაარედაქტირეთ თქვენს მიერ შექმნილი კლასი:

1
2
3
4
5
  class HelloWorld {
     public static void main(String args[]) {
         System.out.println("Hello world! " + args[0]);
     }
  }

2) შეინახეთ და დააკომპილირეთ ფაილი (გაიმეორეთ იგივე ეტაპები რაც პირველ მაგალითში)
3) პროგრამის გასაშვებად აკრიფეთ: java HelloWorld erekle და დააჭირეთ Enter ღილაკს

კონსოლზე უნდა დაიბეჭდოს: Hello world! erekle

რა თქმა უნდა “erekle” – ს ნაცვლად შეგიძლიათ დაწეროთ თქვენი სახელი

]]> http://www.code.ge/posts/%e1%83%9e%e1%83%98%e1%83%a0%e1%83%95%e1%83%94%e1%83%9a%e1%83%98-java-%e1%83%9e%e1%83%a0%e1%83%9d%e1%83%92%e1%83%a0%e1%83%90%e1%83%9b%e1%83%90/feed 2