Enkapsulacja, dziedziczenie i polimorfizm są obok abstrakcji podstawowymi założeniami, czyli paradygmatami
programowania obiektowego.

Enkapsulacja, inaczej hermetyzacja jest to ukrywanie implementacji. Zapewnia, że obiekt nie może zmieniać stanu
wewnętrznego innych obiektów w nieoczekiwany sposób. Tylko wewnętrzne metody obiektu są uprawnione do
zmiany jego stanu. Każdy typ obiektu prezentuje innym obiektom swój interfejs, który określa dopuszczalne
metody współpracy. Pewne języki osłabiają to założenie, dopuszczając pewien poziom bezpośredniego
(kontrolowanego) dostępu do wnętrza obiektu. Ograniczają w ten sposób poziom abstrakcji. Przykładowo, w
niektórych kompilatorach języka C++ istnieje możliwość tymczasowego wyłączenia mechanizmu enkapsulacji;
otwiera to dostęp do wszystkich pól i metod prywatnych, ułatwiając programistom pracę nad pośrednimi etapami
tworzenia kodu i znajdowaniem błędów.

Hermetyzacja uodparnia tworzony model na błędy polegające np. na błędnym przypisywaniu wartości oraz
umożliwia wykonanie czynności pomocniczych (jak np. pobranie z konta 10% wypłacanej kwoty jako prowizji)
lub obsługę sytuacji wyjątkowej (np. brak wymaganych środków).

Dzięki stosowaniu hermetyzacji można budować modele rzeczywistości jako struktury składające z
mniejszych modułów, z których każdy ma pewne określone dane i określone metody wpływania na ich stan i
sprawdzania go. Na przykład w tworzeniu modelu samochodu można użyć modułu silnika, który ma określony
szereg danych wewnętrznych (np. opisujących jego stan w trakcie pracy) i metod wewnętrznych (np. pobranie
paliwa, wywołanie reakcji, ruch wirnika). Wszystko to jednak jest nieistotne dla użytkownika (a nawet nie powinno
być dostępne), który ma możliwość użycia tylko zapłonu i wyłączenia silnika.

Z pełną hermetyzacją mamy do czynienia wtedy, gdy dostęp do wszystkich pól w klasie jest możliwy tylko i
wyłącznie poprzez metody, lub inaczej mówiąc gdy wszystkie pola w klasie znajdują się w sekcji prywatnej (lub
chronionej).
----------------------------------------------------------------------------------------------------------------------
Polimorfizm (z gr. wielopostaciowość) - mechanizmy pozwalające programiście używać
wartości, zmiennych i podprogramów na kilka różnych sposobów[1]. Inaczej mówiąc jest to możliwość
wyabstrahowania wyrażeń od konkretnych typów.

Referencje i kolekcje obiektów mogą dotyczyć obiektów różnego typu, a wywołanie metody dla referencji
spowoduje zachowanie odpowiednie dla pełnego typu obiektu wywoływanego. Jeśli dzieje się to w czasie działania
programu, to nazywa się to późnym wiązaniem lub wiązaniem dynamicznym. Niektóre języki udostępniają bardziej
statyczne(w trakcie kompilacji)rozwiązania polimorfizmu - na przykład szablony i przeciążanie operatorów w C++.

Przykładowo podczas implementacji stosu nie jest bardzo istotne jakiego typu wartości będą na nim
przechowywane. Można napisać ogólne algorytmy obsługujące stos i ewentualne ukonkretnienie pozostawić
systemowi. Mechanizmy umożliwiające takie udogodnienia nazywane są właśnie polimorfizmem.

Przeciążanie (lub przeładowywanie, ang. overload) pozwala nazwać tak samo kilka podprogramów operujących na
różnych danych i następnie obsługiwać te dane w jednolity sposób. Np. inaczej dodawane są liczby całkowite, a
inaczej zmiennopozycyjne ale wygodnie obie te operacje nazywać po prostu dodawaniem i oznaczać symbolem
"+". W językach bez przeciążania operatory te muszą się różnić. Przeciążane mogą być np. operatory, funkcje,
metody, procedury. W niektórych językach niektóre operatory lub funkcje są przeciążone, ale programista nie może
ich dodatkowo dociążać lub przeciążać własnych.
Wybór konkretnego podprogramu następuje w miejscu wywołania na podstawie jego nazwy oraz statycznych
typów argumentów, a czasami również na podstawie typu oczekiwanej wartości zwracanej (np. w Adzie). Jest to
więc polimorfizm statyczny.
----------------------------------------------------------------------------------------------------------------------
Dziedziczenie to w programowaniu obiektowym operacja polegająca na stworzeniu nowej klasy na bazie klasy już
istniejącej.

Dziedziczenie porządkuje i wspomaga polimorfizm i enkapsulację dzięki umożliwieniu definiowania i tworzenia
specjalizowanych obiektów na podstawie bardziej ogólnych. Dla obiektów specjalizowanych nie trzeba
redefiniować całej funkcjonalności, lecz tylko tę, której nie ma obiekt ogólniejszy. W typowym przypadku powstają
grupy obiektów zwane klasami, oraz grupy klas zwane drzewami. Odzwierciedlają one wspólne cechy obiektów.