Dart: კლასები

Dart წარმოადგენს ობიექტზე ორიენტირებულ პროგრამირების ენას (Object oriented programming language), შესაბამისად მისი განუყოფელი ნაწილია კლასები, რომლებიც წარმოადგენენ ობიექტის ე.წ. შაბლონს (blueprint)-ს

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

მოდი პირდაპირ მაგალითით ვეცადოთ შესწავლა

მაგალითი:

class Animal {
  // კლასის ცვლადები
  String name;
  int age;

  // კონსტრუქტორი
  Animal(this.name, this.age);

  // მეთოდი
  void makeSound() {
    print('$name makes a sound.');
  }
}

void main() {
  // ახალი ობიექტის ინიციალიზაცია
  var animal = Animal('Lion', 5);

  // animal ობიექტის თვისებების(properties) დაბეჭვდა
  print(animal.name); // დაიბეჭდება: Lion
  print(animal.age);  // დაიბეჭდება: 5

  // makeSound() მეთოდის გამოძხება
  animal.makeSound(); // დაიბეჭდება: Lion makes a sound.
}

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

ასევე გვაქვს მეთოდი makeSound(), რომელიც ბეჭდავს name ცვლადს და make a sound ტექსტს.

სახელიანი კონსტრუქტორები

Dart-ში ასევე საშუალება გვაქვს კლასში გვქონდეს ე.წ. სახელიანი კონსტრუქტორი (Named constructor) რომელიც გამოიყოფა კონსტრუქტორის სახელის შემდეგ . სიმბოლოთი.

მაგალითი:

class Animal {
  String name;
  int age;

  // Default constructor
  Animal(this.name, this.age);

  // Named constructor
  Animal.baby(this.name) {
    age = 0;
  }

  void makeSound() {
    print('$name makes a sound.');
  }
}

void main() {
  var adultAnimal = Animal('Elephant', 10);
  var babyAnimal = Animal.baby('Elephant');

  print(adultAnimal.age); // დაიბეჭდება: 10
  print(babyAnimal.age);  // დაიბეჭდება: 0
}

Getters და Setters

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

მაგალითი:

class Rectangle {
  double _width;
  double _height;

  Rectangle(this._width, this._height);

  // Getter
  double get area => _width * _height;

  // Setter
  set width(double width) {
    if (width <= 0) {
      throw 'Width must be positive';
    }
    _width = width;
  }

  set height(double height) {
    if (height <= 0) {
      throw 'Height must be positive';
    }
    _height = height;
  }
}

void main() {
  var rectangle = Rectangle(5, 10);
  print(rectangle.area); // დაიბეჭდება: 50

  rectangle.width = 7;
  print(rectangle.area); // დაიბეჭდება: 70
}

მემკვიდრეობა (inheritence)

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

მაგალითი:

class Animal {
  String name;
  Animal(this.name);

  void makeSound() {
    print('$name makes a sound.');
  }
}

class Dog extends Animal {
  Dog(String name) : super(name);

  @override
  void makeSound() {
    print('$name barks.');
  }
}

void main() {
  var dog = Dog('Buddy');
  dog.makeSound(); // დაიბეჭდება: Buddy barks.
}

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

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

აბსტრაქტული კლასები და ინტერფეისები

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

აბსტრაქტული კლასებისთვის გამოიყენება abstract საკვანძო სიტყვა.

მაგალითი:

abstract class Animal {
  void makeSound(); // აბსტრაქტული მეთოდი
}

class Dog extends Animal {
  @override
  void makeSound() {
    print('Dog barks.');
  }
}

void main() {
  var dog = Dog();
  dog.makeSound(); // დაიბეჭდება: Dog barks.
}