JavaScript OOP klases – objekt-orientālā programmēšana

 

Objektorientētā programmēšanas principi:

Šajā rakstā jūs uzzināsit par objektorientētās programmēšanas (OOP) priekšrocībām un OOP principiem.

OOP priekšrocības

Objektorientētās programmēšanas (OOP) paradigmas izmantošanai ir daudz priekšrocību.

OOP palīdz izstrādātājiem atdarināt attiecības starp objektiem reālajā pasaulē. Savā ziņā tas palīdz jums spriest par attiecībām starp lietām jūsu programmatūrā, tāpat kā jūs to darītu reālajā pasaulē. Tādējādi OOP ir efektīva pieeja, lai rastu risinājumus jūsu rakstītajā kodā. OOP arī:

  • Ļauj rakstīt modulāru kodu,
  • Padara jūsu kodu elastīgāku un
  • Padara jūsu kodu atkārtoti lietojamu.

OOP principi

Četri OOP pamatprincipi ir mantošana, iekapsulēšana, abstrakcija un polimorfisms.

Jūs uzzināsit par katru no šiem principiem pēc kārtas. Lieta, kas jāatceras par objektiem, ir tāda, ka tie pastāv hierarhiskā struktūrā. Tas nozīmē, ka oriģinālā bāze jeb superklase visam ir objektu klase, un visi objekti izriet no šīs klases. Tas ļauj mums izmantot Object.create() metodi. lai izveidotu vai instansiētu mūsu klašu objektus.

class Dzīvnieks { /* ...klases kods atradīsies šeit... */ }


var myDog = Object.create(Dzīvnieks)


console.log (Dzīvnieks) // izvada [class Dzīvnieks]
Biežāka metode objektu izveidei no klasēm ir “new keyword” izmantošana. Izmantojot noklusējuma vai tukšu konstruktora metodi, JavaScript netieši izsauc objekta virsklasi, lai izveidotu instanci.
class Dzīvnieks { /* ...klases kods atradīsies šeit... */ }


var myDog = new Dzīvnieks()


console.log (Dzīvnieks) // izvada [class Dzīvnieks]

Šis jēdziens ir izpētīts nākamajā sadaļā par mantojumu

OOP principi: mantošana
Mantojums ir viens no objektorientētas programmēšanas pamatiem.

Būtībā tas ir ļoti vienkāršs jēdziens. Tas darbojas šādi:

  • Ir “lietas” bāzes klase.
  • Ir viena vai vairākas “lietu” apakšklases, kas pārmanto bāzes klases īpašības (dažreiz sauktas arī par “superklasi”).
  • Var būt dažas citas “lietu” apakšklases, kas mantotas no šīm 2. punktā minētajām klasēm.

Ņemiet vērā, ka katra apakšklase manto no savas virsklases. Savukārt apakšklase var būt arī virsklase, ja ir klases, kas manto no šīs apakšklases.

Tas viss varētu izklausīties mazliet “datorzinātniski”, tāpēc šeit ir praktiskāks piemērs:

  1. Ir “Dzīvnieku” bāzes klase.
  2. Ir vēl viena klase, apakšklase, kas mantota no “Dzīvnieks”, un šīs klases nosaukums ir “Putns”.
  3. Tālāk ir vēl viena klase, kas mantota no “Putna”, un šī klase ir “Ērglis”.

Tādējādi iepriekš minētajā piemērā es modelēju objektus no reālās pasaules, veidojot attiecības starp dzīvnieku, putnu un ērgli. Katra no tām ir atsevišķas klases, kas nozīmē, ka katra no tām ir atsevišķi rasējumi konkrētiem objektu gadījumiem, kurus var konstruēt pēc vajadzības.

Lai iestatītu mantojuma attiecību starp klasēm JavaScript, es varu izmantot paplašinājuma atslēgvārdu, tāpat kā B klasē paplašinājumu A.

Tālāk ir sniegts JavaScript mantojuma hierarhijas piemērs:

class Animal { /* ...klases kods atrodās šeit... */ }
class Bird extends Animal { /* ...klases kods atrodās šeit... */ }
class Eagle extends Bird { /* ...klases kods atrodās šeit... */ }

OOP principi: iekapsulēšana

Vienkāršāk sakot, iekapsulēšana ir saistīta ar koda ieviešanas “slēpšanu” no citiem lietotājiem tādā nozīmē, ka viņiem nav jāzina, kā darbojas mans kods, lai “izmantotu” kodu.

Piemēram, kad es palaižu šādu kodu:

"abc".toUpperCase();

Man nav īsti jāuztraucas vai pat nav jātērē laiks, domājot par toUpperCase() metodes darbību. Viss, ko es vēlos, ir to izmantot, jo es zinu, ka tas man ir pieejams. Pat ja mainās pamatā esošā sintakse, tas ir, metodes toUpperCase() ieviešana, ja vien tā nepārkāpj manu kodu, man nav jāuztraucas par to, ko tā dara fonā vai pat kā tā darbojas.

OOP principi: Abstrakcija

Abstrakcija ir saistīta ar koda rakstīšanu tādā veidā, kas padarīs to vispārīgāku.

Iekapsulēšanas un abstrakcijas jēdzieni bieži tiek pārprasti, jo to atšķirības var būt neskaidras.

Tas palīdz domāt par to šādos terminos:

Abstrakcija ir domāta priekšstata par to, ko jūs mēģināt darīt, iegūšanai, nevis konkrēta šīs koncepcijas izpausme.

Iekapsulēšana ir saistīta ar to, ka jums nav piekļuves vai nav jāuztraucās par to, kā dažas ieviešanas darbojas iekšēji.

Lai gan gan iekapsulēšana, gan abstrakcija ir svarīgi jēdzieni OOP, ir nepieciešama lielāka pieredze ar programmēšanu kopumā, lai patiešām iedziļināties šajā tēmā.

Pagaidām pietiek apzināties to esamību OOP.

 

OOP principi: polimorfisms

Polimorfisms ir vārds, kas atvasināts no grieķu valodas, kas nozīmē “vairākas formas”. Alternatīvs tulkojums varētu būt: “kaut kas var iegūt dažādas formas”.

Tātad, lai saprastu, kas ir polimorfisms, apskatīsim dažus reālās dzīves objektus.

Durvīm ir zvans. Varētu teikt, ka zvans ir durvju priekšmeta īpašums. Šo zvanu var zvanīt. Kad kāds piezvanītu pie durvīm? Acīmredzot, lai kāds parādītos pie durvīm.

Tagad apsveriet zvanu uz velosipēda. Velosipēdam ir zvans. Varētu teikt, ka zvans ir veloobjekta īpašums. Šo zvanu varētu arī zvanīt. Tomēr iemesls, nolūks un rezultāts tam, ka kāds zvana uz velosipēda, nav tas pats, kas zvanam pie durvīm.

Iepriekš minētos jēdzienus var kodēt JavaScript šādi:

const velosipēds = {
  zvans: function () {
    return "Lasies malā!";
  },
};
const durvis = {
  zvans: function () {
    return "Velcies šurp!";
  },
};
Tātad es varu piekļūt velosipēda objekta metodei bell(), izmantojot šādu sintaksi:
const velosipēds = {
  zvans: function () {
    return "Lasies malā!";
  },
};
const durvis = {
  zvans: function () {
    return "Velcies šurp!";
  },
};


velosipēds.zvans(); // "Lasies malā!"
durvis.zvans(); // "Velcies šurp!"

Šajā brīdī var secināt, ka tieši tādam pašam metodes nosaukumam var būt tieši pretējs nolūks, pamatojoties uz to, kādam objektam tā tiek izmantota.

Tagad, lai padarītu šo kodu patiesi polimorfisku, es pievienošu vēl vienu funkcijas deklarāciju:

function zvanītZvanu(thing) {
    console.log(thing.zvans())
}

Tagad esmu deklarējis funkciju zvanītZvanu(). Tas pieņem lietas parametru – ko es sagaidu kā objektu, proti, vai nu velosipēda objektu, vai durvju objektu.

Tātad tagad, ja es izsaucu funkciju zvanītZvanu() un nododu tai velosipēdu kā vienu argumentu, šī ir izvade:

zvanītZvanu(velosipēds); // Lasies malā!

Abu šo objektorientēto funkciju kods ar izvadēm izskatīsies šādi:

const velosipēds = {
  zvans: function () {
    return "Lasies malā!";
  },
};
const durvis = {
  zvans: function () {
    return "Velcies šurp!";
  },
};


velosipēds.zvans(); // "Lasies malā!"
durvis.zvans(); // "Velcies šurp!"


function zvanītZvanu(thing) {
  console.log(thing.zvans());
}
zvanītZvanu(velosipēds); // Lasies malā!
zvanītZvanu(durvis); // velcies šurp!

Tagad esat redzējis piemēru, kad tieši viena un tā pati funkcija rada atšķirīgus rezultātus, pamatojoties uz kontekstu, kurā tā tiek izmantota.

Šeit ir vēl viens piemērs, savienošanas operators, ko izmanto, izsaucot iebūvēto concat() metodi.

Ja es izmantoju concat() metodi divām virknēm, tā darbojas tieši tāpat kā tad, ja es izmantotu operatoru +.

"abc".concat("def"); // 'abcdef'
Varu izmantot arī concat() metodi divos masīvos. Lūk, rezultāts:
["abc"].concat(["def"]); // ['abc', 'def']

Apsveriet iespēju izmantot operatoru + divos masīvos ar vienu dalībnieku katrā:

["abc"] + ["def"]; // ["abcdef"]

Tas nozīmē, ka metode concat() uzrāda polimorfisku darbību, jo tā darbojas atšķirīgi atkarībā no konteksta — šajā gadījumā atkarībā no tā, kādus datu tipus es tai dodu.

Atkārtoti atgādinu, ka polimorfisms ir noderīgs, jo tas ļauj izstrādātājiem izveidot objektus, kuriem var būt tieši tāda pati funkcionalitāte, proti, funkcijas ar tādu pašu nosaukumu, kas darbojas tieši tāpat. Tomēr tajā pašā laikā jūs varat ignorēt dažas koplietotās funkcionalitātes daļas vai pat visu funkcionalitāti dažās citās OOP struktūras daļās.

Šis ir polimorfisma piemērs, izmantojot klases JavaScript:

class Putns {
  lietoSpārnus() {
    console.log("Lido!");
  }
}
class Ērglis extends Putns {
  lietoSpārnus() {
    super.lietoSpārnus();
    console.log("Knapi plivinās");
  }
}
class Pingvīns extends Putns {
  lietoSpārnus() {
    console.log("Ātri peld!");
  }
}
var plikgalvasĒrglis = new Ērglis();
var karaļPingvīns = new Pingvīns();
plikgalvasĒrglis.lietoSpārnus(); // "Lido! Knapi plivnās!"
karaļPingvīns.lietoSpārnus(); // "Ātri peld!"

Gan pingvīnu, gan ērgļu apakšklases ir mantotas no putnu superklases. Ērgļa apakšklase manto lietoSpārnus() metodi no putnu klases, bet paplašina to ar papildu konsoles izrakstu. Pingvīnu apakšklase nepārmanto lietoSpārnus() klasi – tā vietā tai ir sava implementācija, lai gan pati Penguin klase paplašina Putnu klasi.

Loading

Noderīgs raksts? Dalies ar citiem:
Dalīties: