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.