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

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

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

Swift-ში არ არსებობს ტრადიციული გაგებით აბსტრაქტული კლასი. აბსტრაქტული კლასების ფუნქციონალობა მიღწეულია პროტოკოლებისა და კლასების კომბინაციით.

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

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

მაგალითი აბსტრაქტული კლასის იმიტირებისთვის პროტოკოლით და კლასით Swift-ში:

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

// პროტოკოლი, როგორც კონტრაქტი
protocol Drawable {
    func draw()
    var color: String { get set }
}

კლასი, რომელიც შესაბამისია პროტოკოლთან და უზრუნველყოფს რეალიზაციას:

// კლასი, რომელიც რეალიზებს პროტოკოლს
class Circle: Drawable {
    var color: String

    init(color: String) {
        self.color = color
    }

    func draw() {
        print("რეგიონი ხატავს ფერით \(color)")
    }
}

გაფართოება, რომელიც უზრუნველყოფს დეფოლტ ნაწილობრივ რეალიზაციას:

// გაფართოება, რომელიც უზრუნველყოფს დეფოლტ რეალიზაციას (არ აქცევს პროტოკოლს აბსტრაქტულ კლასად)
extension Drawable {
    func draw() {
        print("დაწყება რაღაცის ხატვის ფერით \(color)")
    }
}

ამ გზით, Swift-ში პროტოკოლები თამაშობენ ძირითადი როლს პოლიმორფიზმის და აბსტრაქციის მიღწევაში, ჩანაცვლելով სხვა ენების აბსტრაქტული კლასების კონცეფციას.