Magia programării

Cele mai multe dintre tehnologiile care includ programarea par a fi, la prima vedere, o magie incredibilă, dar de fapt ele sunt create la intersecția dintre matematică și electronică. Ambele componente separate sunt complet inutile.







Fără software, cel mai puternic computer este doar o grămadă de junk-uri care clipeau și fumeau. În mod similar, software-ul - puteți să-l imprimați și chiar să-l scrieți cu un pix. Poate că și înregistrările dvs. vor arăta bine, dar fără un calculator vor rămâne doar niște scârboși fără sens.

Dar atâta timp cât avem propriile PC-uri care lucrează în cod binar, vor exista doar mai multe programe și vor deveni mai complicate. Deci, să le studiem - crede-mă, vino la îndemână.

Programarea orientată pe obiecte este un instrument puternic de dezvoltare. Scrierea în limbi moderne este mult mai ușor decât, de exemplu, în C. De exemplu, în scopul de a aduce utilizatorului la un număr întreg și nu o fracțiune, care este „rece“ în ecuație, a trebuit să mă gândesc un pic. Și am scris:

Să presupunem că avem o variabilă y, la care am trecut o valoare fracționară:
float y = 2,0
Pentru a verifica dacă întregul este un număr sau nu, ar trebui să folosim mijloace simple. Pentru aceasta, creați o variabilă goală x, inițializați-o cu zero și scrieți următorul cod:
flotați a = y;
int x = 0;
x = (int) y;
y = x;

dacă (x == 0) printf ("Variabila noastră este.", x);
>
else printf ("Variabila noastră este% f", a);
>

Am făcut un lucru foarte simplu - au adus datele într-o perspectivă de ansamblu, iar apoi am luat-o departe de fracțiunea noastră. Apoi au scris o condiție că, în absența unui echilibru real, utilizatorul vede un număr întreg în loc de o fracțiune. Acest mic "hack" funcționează, dar nu fiecare caz are o soluție simplă și eficientă la îndemână.

Programarea orientată pe obiecte este liberă de aceste complicații. Acolo, majoritatea tehnologiilor sunt prezentate în formă gata. De exemplu, în limba Java, este ușor să verificați corectitudinea intrării prin metoda parseInt din clasa Integer a pachetului Java.lang. Când introduceți un non-întreg sau chiar nimic, programul va genera o eroare (excepție) că programatorul ar trebui să fie tratate în mod corespunzător - pentru a pune expresia „a face o greșeală,“ pentru a transfera utilizatorul înapoi la fereastra de intrare, sau chiar să-i dea câteva serii de judecată. Dar, de fapt, astăzi nu vorbim despre asta, ci despre "magie".

Cel mai real miracol la OOP este faptul că programul poate fi scris nu printr-o listă infinită, ca în C, ci prin ruperea acestuia în fișiere și blocuri - clase și metode. Este minunat. La urma urmei, într-o clasă putem stoca funcția principală de declanșare, în altele - metodele programului nostru, în al treilea - datele sau interfața de conectare la baza de date. Dar cum putem realiza magia noastră? Nu-ți face griji, o vom rezolva împreună.
Să creați, de exemplu, clasa OneClass:
clasa publica OneClass>
Și am plasat datele noastre acolo - câteva variabile.
clasa publica OneClass int x = 9;
int y = 10;
int z = 11;
>

În mod implicit, aceste variabile au acces la lot - adică toate clasele (fișierele) din pachetul nostru pot să le folosească - copiați, modificați, redefiniți. Dar cum se poate face acest lucru? Este foarte simplu să creați o instanță a clasei OneClass într-o altă clasă sau după metoda principală.
OneClass cl = noua clasă OneClass ();

Acum am reușit să folosim toate metodele și câmpurile clasei (așa-numitele variabilele noastre, care sunt scrise imediat după numele clasei și sunt, prin urmare, vizibile peste tot pe OneClass). Le copiem la noi înșine - vom crea propriile noastre variabile și vom arunca în valorile necesare:
clasa publica TwoClass OneClass cl = noua clasa OneClass ();






int x = cl.x;
int y = cl.y;
int z = cl.z;
>

Nu vă fie frică de aceleași nume - într-o altă clasă nu vor fi confundate cu cele originale. Și acum avem date din clasa OneClass.

Dar trebuie să fii foarte atent cu ei. La urma urmei, noi nu numai că le putem lua din prima clasă, dar și rescriem valorile lor. Și e bine dacă facem acest lucru în mod deliberat. Și dacă este simplu? E dezordonat. Ce ar trebui să fac? Magicul are nevoie de protecție împotriva erorilor.

Vorbirea, desigur, nu se va referi la ortografia Harry Potter și nu la "Domnul Inelelor". Vreau să vorbesc despre metode uimitoare - getters și setters.

În ultimul capitol, am aflat că, dacă datele noastre sunt deschise unei alte clase - nu este foarte bună. La urma urmei, noi (sau altcineva) le putem modifica din greșeală atunci când le folosim, pur și simplu prin crearea propriei noastre clase și scrierea instrucțiunilor corespunzătoare acolo. Și obiectul, clasa pentru care am creat atât de mult, putem obține astfel de parametri încât să se transforme în adevăratul orc de la "Domnul Inelelor".

Pentru a evita acest lucru, vom face acest lucru: atribuim fiecărei variabile un identificator care va interzice utilizarea sa peste tot, cu excepția clasei proprii.
private x = 9;
private y = 10;
privat z = 11;

Acum, nimeni din afară nu poate schimba datele noastre. Aceasta se numește încapsulare. Dar pentru noi acest lucru este magic. Să încercăm să ne dăm seama.
Pentru a crea un obiect nou, noi, noi, alți programatori sau alte părți ale programului, trebuie încă să obținem date din clasa noastră. Și apoi ce să facem? Sunt închise? În aceste cazuri, este nevoie de getters. Dar această magie trebuie să ne creăm, prezentând întreaga logică a acestor metode. Începe să citești. Pentru a citi datele noastre într-o altă clasă, trebuie să le copiem și să le transferăm.

În clasa OneClass scriem, de exemplu, pentru variabila x metoda getter a următorului conținut:
public int getX () întoarcere x;
>
În clasa TwoClass, numim această metodă:
clasa cl = clasa nouă ();
cl. getX ();
Putem imprima expresia noastră și ne asigurăm că variabila noastră este obținută.
System.out.println (cl. GetX ());
De asemenea, puteți scrie ceva de care aveți nevoie la variabila de clasă. Acest lucru necesită un setter.
public void setY (newY) y = newY;
>
Inscripția, int int = 10; rămâne în locul său. Dar pentru a ajunge din adâncurile clasei poate fi doar valoarea care este scrisă în newY. Magic - și numai!
Cu ajutorul setatorilor, putem, de exemplu, să "trunchiem" ușor utilizatorul, luând doar cifre mai mari decât zero și mai puțin de 10. Pentru a face acest lucru, setter-ul trebuie să scrie o logică simplă:
public void setY (newY) dacă (newY> 0 newY<10) y = newY;
>

Constructorul este o altă unitate magică a OOP. Se poate vedea atunci când se creează un nou obiect de clasă - de exemplu, OneClass cl = new OneClass (); Părțișoare ascunde doar designerul. Cu toate acestea, în cazul nostru nu are parametri, deoarece este creat automat. Aceasta înseamnă că obiectul nostru poate avea orice număr de toate tipurile. Dar dacă scriem constructorul nostru, atunci obiectul nu va fi atașat doar câtorva parametri care nu pot fi modificați, dar pot obține și valori inițiale.
Să presupunem că unitatea de joc "dragon" conform ideii noastre ar trebui să aibă viteză, altitudine de zbor, timp în aer și ar trebui să aibă mai multe unități de forță abstracte. Creați clasa și constructorul adecvat:

clasa publica Dragon Dragon () int viteza = 120;
int flight_altitude = 1000;
int timeAir = 7;
int putere = 10;
>
>

Deci, avem un dragon care se poate grăbi la o viteză de 120 de kilometri pe oră, la o altitudine de 1000 de metri, timp de șapte minute! În plus, are 10 unități de forță, ceea ce înseamnă că adversarul său va trebui să lupte cu el de foarte mult timp.
Atât de ușor am creat propriul nostru dragon și l-am inițializat cu proprietăți cu adevărat magice. Nu puteți adăuga nimic pentru aceasta, deoarece dacă constructorul cu parametrii este scris, atunci gol nu se creează. Dar acele proprietăți pe care le-am dat dragonului nu pot fi luate. Acum, cu designerul nostru puteți crea o mulțime de hoarde de dragoni, care va clarifica calea spre comoara. Miracole!

Dar asta nu este totul. Atât designerii cât și metodele susțin așa-numita supraîncărcare - asta eo altă magie. Să presupunem că trebuie să creăm din clasa Dragonului nu numai un dragon, ci și un "berserker". El nu va avea altitudine și timp de zbor - dar viteza și puterea vor rămâne. Al doilea constructor va fi:
Dragon (int v, int c)>

În clasa unde este localizată metoda principală pentru toate unitățile de joc, inițializați variabilele noi cu valori diferite și adăugați-le la noul obiect:
int viteza = 60;
int putere = 7;
Dragon berserker = Dragon nou (viteză, putere);

Up! Avem un berserker!
Un alt mic miracol "pentru o gustare". Dacă avem deja câmpuri x, y, z în clasă, atunci în constructorul sau metoda noastră, putem crea cu ușurință aceleași variabile cu aceleași nume și să le transmitem valorile câmpului. Și variabilele noastre nu vor fi confundate. Pentru a face acest lucru, trebuie doar să introduceți un cuvânt mic cu un punct înaintea lor, astfel: aceasta.
int x = 4;
int y = 6;
int z = 12;
Dragon (int, int c, int z) this.x = x;
this.y = y;
this.z = z;
>

În programare, există multe lucruri care pot fi numite, dacă nu chiar magice, apoi miraculoase - absolut exacte. Iar aceste minuni pot fi stăpânite de oricine dorește.

Versiune imprimabilă







Articole similare

Trimiteți-le prietenilor: