Clasa (computer)

O clasă , în programare orientată obiect , este o construcție a unui limbaj de programare folosit ca model pentru crearea obiectelor . Modelul include atribute și metode care vor fi partajate de toate obiectele create ( instanțe ) din clasă. Un obiect este, de fapt, o instanță a unei clase.

O clasă este identificabilă ca un tip de date abstract care poate reprezenta o persoană, un loc sau un lucru și, prin urmare, este abstractizarea unui concept, implementat într-un software . Practic, definește intern starea, ale cărei date sunt stocate în așa-numitele variabile membre sau atribute și comportamentul entității pe care o reprezintă, descrisă prin blocuri de cod reutilizabile numite metode .

Descriere

În analiza orientată obiect

Termenul clasă poate însemna, în funcție de context, o categorie de obiecte, un tip de date sau implementarea unui tip de date. Aceste trei semnificații se regăsesc (în principal) în analiza orientată obiect , designul orientat obiect și limbajele de programare orientate obiect .

Analiza cerințelor , sau pur și simplu analiza , este una dintre primele faze ale ciclului de viață al software-ului și cel puțin precede fazele de proiectare și implementare . Scopul acestei faze este de a înțelege, clarifica și documenta ce trebuie să facă sistemul software sau care sunt funcțiile pe care trebuie să le dețină; nu ne preocupă definirea modului în care sunt implementate aceste funcționalități (cu excepția, la un nivel foarte dur, pentru o estimare aproximativă a costurilor ).

Vorbim de analiză orientată obiect dacă această fază se desfășoară folosind tehnici care se bazează pe un metamodel orientat obiect sau, mai simplu, dacă analiza folosește instrumentele conceptuale ale tehnologiilor orientate obiect, în primul rând conceptul de „ clasă".

În analiza orientată obiect, se pot distinge două subactivități: analiza domeniului și analiza cerințelor propriu-zise. Analiza domeniului constă în a clarifica mai întâi care sunt conceptele importante cu care sistemul care urmează să fie dezvoltat va trebui să se ocupe și să precizeze cât mai multe detalii posibil semnificația acestor concepte și relațiile care le leagă între ele.

De exemplu, în faza de analiză a unui sistem software din domeniul bancar, va fi necesar să se investigheze cu atenție modul în care funcționează un cont curent, care relații pot lega conturi diferite, conturi la sucursale, sucursale la clienți etc. După caracterizarea precisă a entităților care aparțin domeniului, vor fi elaborate cerințele reale ale sistemului, adică să descrie modul în care sistemul se potrivește domeniului și interacționează cu acesta.

În analiza orientată pe obiecte, „clasa” este conceptul fundamental utilizat pentru a descrie entitățile domeniului. O clasă reprezintă o categorie de entități (de exemplu, conturi de verificare) în termeni de două aspecte:

statutul entităților din acea categorie, descris în termenii unui set de atribute care pot varia în timp; de exemplu, fiecare cont curent are un sold care variază în timp;
comportamentul acelor entități, în ceea ce privește operațiunile pe care aceste entități le pot efectua sau le pot efectua; de exemplu, puteți retrage bani dintr-un cont curent. Operațiunile sunt analizate prin stabilirea (de asemenea) a modului în care aplicația lor modifică starea (retragerea banilor scade dimensiunea soldului).

Entitățile individuale sunt numite instanțe (adică exemple, cazuri speciale) ale clasei lor de apartenență. Astfel, contul meu de verificare este o instanță din clasa contului de verificare .

Modelul domeniului pe care îl definește analiza poate fi îmbogățit cu o serie de informații suplimentare referitoare la relațiile dintre diferitele clase identificate. Printre cele mai importante exemple de relații, de obicei, pot fi citate următoarele:

asociațiile specifică relațiile dintre instanțele claselor; de exemplu, faptul că conturile curente sunt în numele clienților băncii definește o asociere între clasa de cont curent și clasa de clienți ;
agregările sunt un tip particular de asociere care apare atunci când instanțele unei clase trebuie considerate părți ale instanțelor altor clase; de exemplu, o instanță a clasei auto include instanțe ale claselor roată , piston , parbriz și așa mai departe ca piese ale acesteia. Limita dintre asocierile generice și agregări nu este întotdeauna clară.
Relațiile ISA ( relația „este o”) specifică faptul că o clasă trebuie considerată o subcategorie sau o subclasă a alteia (numită superclasă ); de exemplu, clasa contului de verificare ar putea fi descrisă ca o subcategorie a clasei de servicii bancare . Numele relației rezultă din faptul că se poate spune cu sensibilitate, de exemplu, că un cont de verificare este un serviciu bancar („este un”, ISA). Rețineți că aceasta reprezintă o relație exclusiv între clase și nu între instanțe. Raportul ISA joacă un rol important în raționalizarea unui model. Un aspect fundamental este că se poate presupune că o subclasă este înzestrată cu siguranță cu toate atributele, operațiile și asocierile superclasei; este posibil să aibă altele, legate de caracteristicile specifice subcategoriei de obiecte pe care le descrie. De exemplu, dacă un serviciu bancar are un cost anual și este în numele unui client, toate acestea rămân valabile pentru un cont curent ; acesta din urmă are, de asemenea, un sold , un atribut care nu are neapărat sens pentru toate serviciile bancare (și, prin urmare, nu va apărea în clasa de servicii bancare mai generice).

În proiectarea orientată pe obiecte

Proiectarea este o fază a ciclului de viață al software-ului conceptual, ulterior analizei domeniului și analizei cerințelor, în care apare problema modului de creare a unui sistem software care îndeplinește cerințele explicate anterior. Rezultatul acestei faze ar trebui să fie un set de specificații ale proiectului suficient de detaliate și precise pentru a fi utilizate ca referință unică pentru faza de implementare ulterioară, adică pentru construcția produsului software propriu-zis.

Proiectarea orientată pe obiecte este în general utilizată în cazurile în care se așteaptă și o implementare orientată pe obiecte , într-un limbaj adecvat precum C ++ sau Java . De fapt, aceste limbi au un concept de clasă (a se vedea secțiunea următoare) care este similar din punct de vedere structural cu cel utilizat în faza de analiză. În acest caz, designul constă într-o rafinare și extindere a modelului produs de analiză. Această transformare a modelului are loc pe baza a două linii directoare generale:

sunt identificate toate noile concepte legate de arhitectura sistemului, adică care au legătură cu modul în care sistemul va trebui realizat, dar care nu corespund conceptelor domeniului. Conceptele de acest tip ar putea fi terminal , utilizator autorizat , adresă IP , bază de date și așa mai departe. Toate aceste concepte nu sunt legate de domeniu, ci exclusiv de sistem și totuși se pretează să fie descrise din nou prin conceptul de clasă.
clasele modelului rezultat (atât cele derivate din analiză, cât și cele legate de arhitectura sistemului) sunt de obicei detaliate prin introducerea de informații suplimentare care vor ajuta la ghidarea implementării; de exemplu, sunt stabilite tipurile de atribute și parametrii operațiilor. Se poate stabili, de exemplu, că soldul unui cont curent este un număr cu virgulă și, în mod similar, operațiunea „retragere” necesită specificarea unui număr cu virgulă care reprezintă suma care trebuie retrasă.

Se poate spune că în această etapă sistemul este descris în termeni de tipuri de date abstracte .

În limbaje orientate obiect

Una dintre caracteristicile fundamentale ale abordării orientate pe obiecte este „fluiditatea” mai mare (în comparație cu abordările anterioare, cum ar fi procedurale ) cu care fazele de analiză, proiectare și implementare duc fiecare la următoarea. Această fluiditate se datorează faptului că limbajele orientate pe obiecte oferă o serie de instrumente sintactice și semantice care sunt transpunerea directă a instrumentelor conceptuale care au fost discutate în ceea ce privește fazele de analiză și proiectare.

Un limbaj orientat obiect oferă un construct de clasă corespunzător structural conceptului abstract de clasă menționat mai sus: o clasă descrie un tip de obiecte (~ o categorie de entități ) în termenii unui set de variabile interne sau variabile de instanță din care au obiectele respective (~ atribute ) și un set de proceduri numite metode care pot fi efectuate asupra acestora (~ operații ). O variabilă internă a unei clase care conține o referință la o instanță a altei clase poate corespunde unei asociații; o variabilă internă care conține direct o instanță reală poate fi considerată o transpunere în implementare a conceptului de agregare; și în cele din urmă moștenirea corespunde direct relației ISA.

Dacă din punct de vedere istoric și tehnic, clasa limbajelor orientate obiect poate fi considerată ca o evoluție a înregistrării limbajelor procedurale precum C sau Pascal , aceasta implică o abordare complet diferită a programării, în care datele tipurile , însoțite de operațiile (metodele) lor devin centrale. Multe dintre noutățile semnificative ale acestei abordări sunt legate de conceptele de moștenire , încapsulare sau ascundere a informațiilor și polimorfism .

În UML

UML este o notație grafică semi-formală care vă permite să descrieți un sistem (nu neapărat software) prin crearea unui model bazat pe conceptele de orientare a obiectului. Deoarece toate fazele ciclului de viață al software - ului orientat pe obiecte utilizează instrumente conceptuale similare (clase, asociații, relații ISA), UML poate fi utilizat în mod constant în toate fazele. Uniformitatea rezultată a descrierii are o serie de avantaje:

o ușurință mai mare de verificare a conformității fiecărei faze cu constrângerile impuse de cea anterioară (de exemplu, verificarea conformității implementării cu cerințele);
o mai mare modificabilitate a setului de modele produse; de exemplu, de la o modificare la modelul de analiză (datorită unei modificări a cerințelor) este adesea simplu (sau chiar banal) să se deducă care modificări trebuie în consecință să fie aduse modelului de proiectare și, prin urmare, implementării.

Tocmai pentru că clasele se numără printre instrumentele centrale care vă permit să raportați modele de analiză, modele de proiect și implementări de software, conceptul de clasă în UML are o semantică mai abstractă și conceptuală sau generală decât în limbajele de programare.

Exemple

Un exemplu generic de cod sursă de clasă Java este:

 // definiția, corpul sau șablonul clasei
     '' ' public class ' '' < class_name > {
     
      // atribute sau membri ai clasei
     tipo_attributo1 <attribute1>;
                ...
     tipo_attributoN <attributoN>;

     // constructor implicit (fără parametri)
     '' ' public ' '' < uppercase_class_name > () {
     }

     // constructor cu parametri
     '' ' public ' '' < class_name_upercase > ( parametru_tip1 param1 , ... , parametru_tipN paramN ) {
     
          < atribut1 > = param1 ;
               ...
         <AttributeN> = paramN; 
       
     }

      // metoda membru
      '' ' public ' '' return_type < nume_metodă > ( parametru_tip1 param1 , ... , parametru_tipN paramN ) {
            ... 
          '' instruction_block '' ;
            ...
      '' ' return ' '' < object_type_method > ;
     }

      // metoda non-membru (static)
      '' ' public static ' '' return_type < nume_metodă > ( parametru_tip1 param1 , ... , parametru_tipN paramN ) {
            ... 
          '' instruction_block '' ;
            ...
      '' ' return ' '' < object_type_method > ;
     }

     // punctul de intrare al programului sau metoda de execuție
     '' ' public static ' '' void main ( String [] args ) {
          ...
        \\ instanțierea obiect al clasei
        < nume_clasă > foo = nou < nume_clasă > ();
      
        \\ chemat constructor la valorile atributelor obiect o atribuiți dell“
        foo . < constructor > ( parametri_passat );
   
        \\ apeluri sau metode apeluri pe obiectul Member 
        foo . <Obj> (parametri_passati);
               ...
        \\ apelează sau invocă metoda statică
        <Nome_metodo_statico> (parametri_passati); 
               ...
     }
 }

Un exemplu generic de cod sursă al unei clase în C # este:

 public class < class_name >
{
    // Atribute sau membri ai clasei
    tipo_attributo1 <attribute1>;
    ...
    tipo_attributoN <attributoN>;

    // Constructor implicit fără parametri
    public < nume_clasă > ()
    {
    }

    // Constructor cu parametri
    public < nume_clasă > ( parametru_tip param1 , ... , parametru_tipN paramN )
    {
        < atribut1 > = param1 ;
        ...
        <AttributeN> = paramN; 
    }

    // Metoda membrului
    returned_type publice <METHOD_NAME> (parameter_type param1, ..., parameter_typeN paramN)
    {
        // Logica metodei
        ...
        
        // Întoarcere
	    returnează < obiect_tip_metodă >;
    }

    // Metoda statică
    public static returned_type <METHOD_NAME> (parameter_type param1, ..., parameter_typeN paramN)
    {
        // Logica metodei
        ...
        
        // Întoarcere
	    returnează < obiect_tip_metodă >;
    }

    // Punctul de intrare al programului sau metoda de execuție
    public static void main (String [] args)
    {
        // Instantați obiectul clasei
        <Class_name> object_name = new <class_name> (eventuali_param);
      
        // Apelați o metodă membru a obiectului
        nume_obiect. <obj> (eventuali_param);

        // Apelați o metodă statică a obiectului
        nume_obiect. <nome_metodo_statico> (eventuali_param);
    }
}

Elemente conexe

Alte proiecte

Wikționarul conține dicționarul lema « clasă »

Portal IT : accesați intrările Wikipedia care se ocupă cu IT