Капсулиране (програмиране)

В езиците за програмиране капсулиране се използва за обозначаване на едно от две свързани, но различни понятия, а понякога и в комбинация:

• Механизъм за ограничаване на директен достъп до някои от компонентите на обектите.
• Езикова конструкция, която улеснява комбинирането на данни с методи (или други функции), извърващи операции върху тези данни.

Някои изследователи и учени на езиците за програмиране използват първото значение на термина "капсулиране" самостоятелно или в комбинация с второто значение като отличителна характеристика на обектно ориентираното програмиране, а в някои езици за програмиране, които осигуряват лексическо затваряне, капсулирането е тяхна съществена характеристика.

Второто определение е продиктувано от факта, че в много обектно ориентирани езици скриването на компоненти не е автоматично или може да се презаписва. По този начин, укриването на информация се определя като отделно понятие от тези, които предпочитат второто определение.

Характеристиките на капсулирането се осъществяват чрез класове в повечето обектно ориентирани езици за програмиране, въпреки че има и други варианти.

Механизъм за скриване на информацията

Капсулирането може да се използва за да скрива полета и методи на даден клас. Според тази дефиниция капсулирането означава, че вътрешното представяне на обект не се вижда извън него. Като правило, само собствените методи на даден обект могат директно да виждат или променят поле. Някои езици, като smalltalk и Руби, позволяват достъп само чрез методите на обекта, но повечето от останалите езици (например С++, С#, Делфи и Java) предлагат на програмиста възможност да избере какво да остане скрито, обикновено чрез ключови думи като public и private. Стандартът ISO в C++ се отнася до protected, private и public като „модификатори за достъп“, които „не крият информация“. Скриването на информация се осъществява чрез предоставяне на крайната версия на изходния код, който се свързва чрез заглавен файл.

Почти винаги има начин да се заобиколи тази защита – обикновено чрез отражение в API (Ruby, Java, C# и т.н.), понякога чрез механизъм като изопачаване на името (name mangling) в Python или специални запазени думи като friend в C++.

По-долу е даден пример на C#, който показва как достъпът до полето с данни може да бъде ограничен чрез използване на запазената дума private:

class Program {
	public class Account {
		private decimal accountBalance = 500.00m;

		public decimal CheckBalance() {
			return accountBalance;
		}
	}

	static void Main() {
		Account myAccount = new Account();
		decimal myBalance = myAccount.CheckBalance();

		/* This Main method can check the balance via the public
		* "CheckBalance" method provided by the "Account" class
		* but it cannot manipulate the value of "accountBalance" */
	}
}

По-долу е даден пример на Java:

public class Employee {
    private BigDecimal salary = new BigDecimal(50000.00);

    public BigDecimal getSalary() {
        return salary;
    }

    public static void main() {
        Employee e = new Employee();
        BigDecimal sal = e.getSalary();
    }
}

class Account {
    /**
     * How much money is currently in the account
     * @var float
     */
    private $accountBalance;

    /**
     * @param float $currentAccountBalance Initialize account to this dollar amount
     */
    public function __construct($currentAccountBalance) {
        $this->accountBalance = $currentAccountBalance;
    }

    /**
     * Add money to account
     * @param float $money Dollars to add to balance
     * @return void
     */
    public function deposit($money) {
        $this->accountBalance += $money;
    }

    /**
     * Remove money from account
     * @param float $money Dollars to subtract from balance
     * @throws Exception
     * @return void
     */
    public function withdraw($money) {
        if ($this->accountBalance < $money) {
            throw new Exception('Cannot withdraw $' . $money . ' from account as it contains $' . $this->accountBalance);
        }
        $this->accountBalance -= $money;
    }

    /**
     * Get current account balance, that takes all additions and subtractions into consideration.
     * @return float
     */
    public function getAccountBalance() {
        return $this->accountBalance;
    }
}

// Create a new object from the Account class with a starting balance of $500.00
$myAccount = new Account(500.00);

// We have clearly defined methods for adding and subtracting money from the Account
// If we didn't have a method for withdraw(), nothing would prevent us from withdrawing more money than was available in the account
$myAccount->deposit(10.24);
$myAccount->withdraw(4.45);

// Get the current balance
$accountBalance = $myAccount->getAccountBalance();
echo 'My Account Balance: $' . $accountBalance; // 505.79

// Our code forbids us from withdrawing more than we have
$myAccount->withdraw(600.00); // Exception Message: Cannot withdraw $600 from account as it contains $505.79

Капсулирането също така може да се прилага в езици, които не са обектноориентирани. В C, например, структурата може да бъде обявена в публично API (т.е. заглавен(header) файл) за набор от функции, които оперират върху елемент от данни, съдържащ полета на обекта, които не са достъпни за ползвателите на API:

// Header file "api.h"

struct Entity; // Opaque structure with hidden members

// API functions that operate on 'Entity' objects
extern struct Entity * open_entity(int id);
extern int process_entity(struct Entity *info);
extern void close_entity(struct Entity *info);

Ползвателите извикват API функции за алокиране, опериране върху тях и освобождаване на обекти от непрозрачен тип данни (opaque data type). Съдържанието на този тип са известни и са на разположение само за имплементацията на функциите на API-то, а ползвателите не могат директно да се обърнат към неговото съдържание. Изходният код за тези функции определя действителното съдържание на структурата:

// Implementation file "api.c"

#include "api.h"

// Complete definition of the 'Entity' object
struct Entity {
    int     ent_id;         // ID number
    char    ent_name[20];   // Name
    ... and other members ...
};

// API function implementations
struct Entity * open_entity(int id)
{ ... }

int process_entity(struct Entity *info)
{ ... }

void close_entity(struct Entity *info)
{ ... }

Историческо значение

Целта на капсулирането е да се намалят конфликтите между променливи с еднакви имена и да се групират заедно свързаните методи (функции) и свойства (променливи), за да се състави обектен клас. Тази практика подобрява подредеността и четливостта на първичния код.

Обща дефиниция

Капсулирането е един от четирите основи на ООП (обектно ориентирано програмиране). Капсулиране означава обединяване на данни с методи, които работят върху данните. Капсулирането се използва за скриване на стойността или състоянието на структурирани данни на обекта вътре в класа чрез предотвратяване на неупълномощен директен достъп до него. Публично достъпните методи обикновено се предоставят от класа (така наречените гетъри(getter) и сетъри(setter)) за осъществяване на достъп до стойностите на полетата на обекта.

Този механизъм не е уникален за обектно ориентираното програмиране. Имплементацията на абстрактни типове данни, например, модули, предлагат подобна форма на капсулиране. Това сходство се дължи на факта, че двете понятия се основават на една и съща математическа основа – типизация на данните.

Капсулиране и наследяване

Авторите на „Design Patterns“ обсъждат напрежението между наследяването и капсулирането много подробно и заявяват, че според техния опит дизайнерите на класовете използват прекалено много наследяването. Опасността е формулирана по следния начин:

„

тъй като наследяването разкрива на наследника реализацията на родителя в подробности, то нарушава капсулирането.

“