A 3 fő programozási paradigma, amelyet ismernie kell

A programozási paradigmák azok az elméletek vagy ötletek, amelyek segítenek kialakítani a szoftverek létrehozásához használt különböző nyelveket. Ezek képviselik a programozási nyelv főbb jellemzőit, diktálják a viselkedését.

Ezért nyugodtan kijelenthetjük, hogy a paradigma ugyanolyan fontos, mint a programozási nyelv szintaxisa és szemantikája. A legtöbb népszerű programozási nyelv a programozási paradigma néhány típusának egyikét használja.

1. Imperatív programozás

Az imperatív paradigma a programozás egyik legkorábbi megközelítése, egészen az 1950-es évekig nyúlik vissza. Ez a paradigma nagymértékben támaszkodik a változók, parancsok és eljárások használatára.

A kötelező programozás parancsokat használ a változók ellenőrzésére és frissítésére, az állapot tárolására a programban. A parancsok kombinációja ezután létrehoz egy eljárást. Az adatok absztrakciója döntő szerepet játszik az adatábrázolásban, ami megkönnyíti a laza csatolást.

Az egyik legnépszerűbb nyelv, amely az imperatív paradigmát használja, a C. Ez a programozási nyelv csak a függvényeljárásokat támogatja.

Egy kötelező programpélda

#beleértve 
#beleértve 
struct Ügyfél
{
 int Ügyfélazonosító;
 char Rendelési szám[20];
 char Név[30];
 float OrderTotal;
};
érvénytelen fő ()
{
 struct Ügyfél János = {4000, "HK1001", "John Doe", 200,00};
 struct Ügyfél Jane = {4001, "HK1002", "Jane Doe", 600,00};
memcpy (Jane. Név: "Jane Jones", 10);
printf ("A %s %s rendelés teljes költsége: $%.2f",Jane. Név, Jane. Rendelési szám, Jane. Rendelés Összesen);
}

A fenti C program létrehozza a Vevő szerkezet. Az struct típus az adatabsztrakció kiváló példája C-ben.

A program bemutatja, hogy a parancsok hogyan hozhatnak létre, frissíthetnek és jeleníthetnek meg állapotot – a Jane szerkezeti változó. Mindezek a parancsok az a fő() funkció, amely összességében egy olyan eljárás, amely meghatározza, hogy a vásárlónak mennyi pénzt kell fizetnie egy megrendelésért.

A fenti program végrehajtása a következő kimenetet eredményezi a konzolon:

A HK1002 számú Jane Jones rendelés teljes költsége: 600,00 USD

2. Objektumorientált programozás

Az objektum-orientált programozási paradigma az 1990-es években vette kezdetét. Ez a paradigma az imperatív paradigma leszármazottja. Az objektumorientált paradigma azonban az állapotokat objektumokban tárolja, nem változókban.

Az objektumorientált paradigmát használó programozási nyelvek gyakran jobban kezelik az összetett alkalmazásokat. A paradigma alapvető jellemzői az objektumok, az osztályok, az adatok tokozása, az öröklődés és a polimorfizmus.

Az osztály az objektum-orientált program alapvető összetevője. Egyes osztályok más osztályoktól öröklik a tulajdonságokat és a műveleteket. A programozók ezt szülő-gyerek kapcsolatként írják le. A polimorfizmus altípus kategóriájába tartozik.

Az osztályok eszközöket tartalmaznak az érzékeny adatok tokozással való elrejtésére és védelmére. Miután definiált egy osztályt, használhatja azt objektumok létrehozására.

Az objektumorientált paradigmát használó legnépszerűbb programozási nyelvek közül három a Java, a C++ és a Python.

Példa objektum-orientált programra

Ez az alkalmazás bemutatja az objektum-orientált programozási nyelv, a Java legtöbb funkcióját. Az ügyfelek egy bizonyos típusa egy általánosabb típustól örökli a viselkedést. Minden ügyfél alkalmaz egy interfészt. Az adott ügyféltípus felülír egy metódust a felületről.

A Discountable.java fájl

nyilvánosfelület kedvezményes {
nyilvánosüres grandTotal (String orderNumber, kettős teljes);
}

A fenti kód interfészt hoz létre. A Java-ban egy interfész egy másik példa a polimorfizmusra. Lehetővé teszi, hogy a közvetlenül nem kapcsolódó entitások hozzáférjenek ugyanazokhoz a tulajdonságokhoz, mint például a teljes összeg módszer. Ez az alkalmazás az ügyfelekre összpontosít, de egy alkalmazotti osztály is használhatja a Kedvezményes felületet.

A Customer.java fájl

nyilvánososztály Vevő megvalósítja kedvezményes {
védettint Ügyfél-azonosító;
védett String customerName;
védett String customerCode;
nyilvános Ügyfél() {
ez.customerId = 0;
ez.customerName = "";
ez.customerCode = "";
 }
nyilvános Vevő(int customerId, String customerName, String customerCode) {
ez.customerId = ügyfélazonosító;
ez.customerName = ügyfélnév;
ez.customerCode = ügyfélkód;
 }
nyilvánosint getCustomerId() {
Visszatérés Ügyfél-azonosító;
 }
nyilvánosüres setCustomerId(int Ügyfél-azonosító) {
ez.customerId = ügyfélazonosító;
 }
nyilvános String getCustomerName() {
Visszatérés Ügyfél neve;
 }
nyilvánosüres setCustomerName (karakterlánc customerName) {
ez.customerName = ügyfélnév;
 }
nyilvános String getCustomerCode() {
Visszatérés ügyfélkód;
 }
nyilvánosüres setCustomerCode (karakterlánc customerCode) {
ez.customerCode = ügyfélkód;
 }
nyilvánoskettős customerType (karakterlánc ügyfélkód) {
kettős kedvezmény = 0;
ha (customerCode.toLowerCase().equals("pre")) {
 kedvezmény = 0,10;
 } másha (customerCode.toLowerCase().equals("gen")) {
 kedvezmény = 0,02;
 } másha (customerCode.toLowerCase().equals("new")) {
 kedvezmény = 0,05; 
 }
Visszatérés kedvezmény; 
 }
@Felülbírálás
nyilvánosüres grandTotal (String orderNumber, kettős teljes) {
kettős kedvezmény = ügyfélTípus (customerCode);
kettős kedvezményszázalék = összesen * kedvezmény;
kettős finalTotal = összesen - kedvezményszázalék;
Rendszer.ki.println("A "+ getCustomerName() + " order Number " + orderNumber + " esetén a végösszeg: $" + finalTotal);
 }
}

A fenti kód létrehozza a Vevő osztály. Megvalósítja a Kedvezményes felületet, majd a módszerét használja a végösszeg kiszámítására és megjelenítésére, az ügyfél kategóriája alapján. Az védett kulcsszó a fenti kódban egy példa az adatok tokozására; korlátozza a hozzáférést az ezen az osztályon keresztül létrehozott adatokhoz. Tehát csak az alosztályai (vagy gyermekosztályai) a Vevő osztály hozzáférhet az adataihoz.

A NewCustomer.java fájl

nyilvánososztály Új vevő kiterjed Ügyfél {
nyilvános Új vevő() {
szuper();
 }
nyilvános Új vevő(int customerId, String customerName, String customerCode) {
szuper(customerId, customerName, customerCode);
 }
}

A fenti kód létrehozza a Új vevő osztály, amely kiterjeszti a Vevő osztály. Ez A Java osztály öröklődést használ hogy képviselje a szülő-gyermek kapcsolatot az Vevő osztály. Az Új vevő a kapcsolat gyermeke, tehát hozzáfér az Ügyfél osztály összes tulajdonságához. A Customer class attribútumokat a következővel importálja szuper() módszer.

Az App.java fájl

nyilvánososztály App {
nyilvánosstatikusüres main (String[] args) { 
 Ügyfél Jane = új NewCustomer (4001, "Jane Jones", "új");
 Jane.grandTotal("HK1002", 600); 
 }
}

A fenti kód végrehajtható fájlt hoz létre App osztály. Ez az osztály létrehoz egy Ügyfél objektumot (Jane), és a polimorfizmus révén Jane a Új vevő. Végül létrehozza Jane megrendelésének végösszegét. A fenti program végrehajtása a következő kimenetet generálja a konzolon:

A HK1002 számú Jane Jones rendelés végösszege: 570,0 USD

3. Funkcionális programozás

Ennek a paradigmának a kulcsfogalmai a kifejezések, a függvények, a parametrikus polimorfizmus és az adatabsztrakció. A kifejezések a funkcionális programozási nyelvek által használt függvények alapvető összetevői. A paraméteres polimorfizmus a polimorfizmus három típusának egyike. Ez a típus megkönnyíti az általános programozást funkciókon és típusokon keresztül.

A JavaScript az egyik legnépszerűbb funkcionális programozási nyelv.

Példa a funkcionális programra

const Ügyfél = {
 Azonosítószám: 1002,
 Név: "Jane Jones",
 Ügyfélkód: 'új'
}
const main = (ügyfél, funkció, érték) => {
 var total = func.apply (null, [ ügyfél. Ügyfélkód, érték ]);
 console.log(`${customer. Name} összesen: ${total}`);
}
const grandTotal = (Ügyfélkód, összesen) => {
 if (CustomerCode == "new") {
 kedvezmény = összesen * 0,05;
 mainTotal = összesen - kedvezmény;
 return mainTotal;
 } else if (CustomerCode == "pre") {
 kedvezmény = összesen * 0,10;
 mainTotal = összesen - kedvezmény;
 return mainTotal;
 }
}
fő (Ügyfél, grandTotal, 600);

A fenti JavaScript programnak van egy tárgy szó szerinti és két funkciót. Mindegyik függvényt kifejezésként deklarálja a JavaScript nyíl függvény. Az fő() függvény egy magasabb rendű függvény. Elviszi a teljes összeg függvény egyik argumentumaként, majd meghívja azt a függvényt. Ez is egy példa a parametrikus polimorfizmusra.

Az teljes összeg() függvény több kifejezést tartalmaz, és a Vevőtárgy egy példa az adatabsztrakcióra. A fenti program a következő kimenetet generálja a konzolon:

Jane Jones összesen: 570 dollár

A programozási nyelvek összetettsége

Egy programozási nyelv megtestesítheti egy programozási paradigma koncepcióit, de ez nem jelenti azt, hogy egyetlen paradigmára korlátozódik. Sok népszerű programozási nyelv (például Python, Java, JavaScript és C++) több paradigmát használó nyelv.

Néhány programozási paradigma, mint például az imperatív és az objektum-orientált paradigma szintén összefügg. De e rokonság ellenére van néhány jelentős különbség.

Objektum-orientált programozás vs. Eljárási programozás: miben különböznek egymástól?

Olvassa el a következőt

A szerzőről