• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Curs2-POO
 

Curs2-POO

on

  • 1,841 views

 

Statistics

Views

Total Views
1,841
Views on SlideShare
1,830
Embed Views
11

Actions

Likes
1
Downloads
0
Comments
0

1 Embed 11

http://www.slideshare.net 11

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Curs2-POO Curs2-POO Presentation Transcript

    • Programarea orientată pe obiecte Curs 2
    • Clase şi obiecte
        Aceasta prezentare (si cele ce vor urma) are la baza cartea Ioan Jurca – Programarea Orientata pe Obiecte cat si diferite materiale “culese” din Internet. Peste tot unde am folosit diferite surse am incercat sa mentionez autorii acestora. Eventualele scapari sunt mea culpa .
    • Clase şi obiecte
      • Elementele componente ale unei clase
      • Modificatori
      • Crearea obiectelor
      • Supraîncărcarea metodelor
      • Metoda main
      • Tablouri
      • Enumerări
      • Clase înfăşurătoare
      • Clase şi metode generice
    • Clase şi obiecte (2)
      • Clasa – unitatea fundamentală de structurare a programelor orientate pe obiecte;
      • Clasa este tiparul care defineşte variabilele de stare ale unui obiect şi
      • operaţiile permise asupra obiectului
      • În C#: variabile de stare = câmpuri , operaţii = metode
      • Câmpurile, metodele şi sema n tica lor = contractul clasei
      • Reprezentarea câmpurilor şi implementarea (codul) metodelor se pot modifica ,
      • dacă nu afectează contractul ( open/close principle )
      • Este recomandabil ca numai unele dintre metode (de regulă nu şi câmpurile )
      • să fie vizibile utilizatorilor  Trebuie şi un mecanism de control al vizibilităţii
      • elementelor
      • Alt mecanism: crearea de obiecte (în C#: operatorul new aplicat pe un
      • constructor al clasei)
    • Elementele componente ale unei clase Cazul general: 1) câmpuri; 2) metode; 3) clase şi interfeţe încuibate Oricare dintre elemente pot lipsi class Persoana { public String CNP; // cod numeric personal public String nume; // numele persoanei public Persoana pereche; // sotul/sotiei public static long populatie = 0; public Persoana( String nume, String CNP, Persoana peer) { this .nume = nume; this .CNP = CNP; pereche = peer; //!!! populatie++; } public String getNume() { return nume; } public bool checkCNP() { return true ; // nu e obligatoriu sa fie true :) } }
    • Campuri Variabile de exemplar şi variabile de clasă Iniţializatori : constante sau expresii de tip corespunzător cu al câmpului, stabilesc valoarea iniţială Exemple: double sapte = 3.5 * 2; // expresie constanta double altSapte = sapte; // expresie cu alt camp al obiectului double sin45 = Math.sin(Math.PI/4); // apel de metoda double expr = sapte + Math.sqrt(sin45); //expresie combinata Tipuri predefinite Tipuri predefinite non-obiecte : numerice, char, boolean Tipuri numerice: Byte, short, int, long, float, double Char :reprezentare Unicode câmpuri constante : declarate cu final câmpurile cu tip clasă conţin referinţe !!
    • Metode (1)
      • Declararea metodelor: antet şi corp
      • Antet: modificatori , tipul val. returnate , semnătura ;
      • Semnătura : nume + lista de parametri
      • Corpul : instrucţiuni între acolade
      class Persoana { //declaratii de campuri, variabile si initializari public String ToString() { String reprez = "Persoana " + nume + " are codul numeric personal " + CNP + " si " ; if (pereche == null ) reprez += "nu " ; return reprez + " este casatorita." ; } public static void main( String [] args) { Persoana pers = new Persoana (); pers.CNP = "1760223364760" ; pers.nume = "Ion Ionescu" ; Console .WriteLine(pers.ToString()); } }
    • Metode (2)
      • Execuţia unui program începe în metoda main
      • S-a folosit un constructor no-arg , Persoana()
      • Metodele pot fi: de exemplar (ex. ToString ) sau de clasă / statice (ex. main )
      • Metodele statice au acces numai la câmpurile statice !
      class Persoana { //declaratii de campuri, variabile si initializari public String ToString() { String reprez = "Persoana " + nume + " are codul numeric personal " + CNP + " si " ; if (pereche == null ) reprez += "nu " ; return reprez + " este casatorita." ; } public static void Main( String [] args) { Persoana pers = new Persoana (); pers.CNP = "1760223364760" ; pers.nume = "Ion Ionescu" ; Console .WriteLine(pers.ToString()); } }
    • Metode (3) Execuţia metodelor :
      • Fluxul de control trece la metoda apelată;
      • Se execută metoda până când:
        • Ajunge la return
        • Ajunge la sfârşitul corpului metodei }
        • Generează o excepţie
      • Dacă o metodă nu returnează rezultat : tipul valorii ret. e void
      • Pentru mai mult de un rezultat : câmpuri în obiect indicat de referinta returnată, tablou;
      • În C# toţi parametri se transmit prin valoare !!!
      • În metode se lucrează cu copii ale parametrilor .
      • Valorile din metoda apelantă ( param. actuali ) nu sunt afectate
      • Efecte diferite pt. valori elementare şi pentru referinţe :
        • prin referinţe se pot modifica atribute (câmpuri) ale obiectului referit;
        • modif. referinţei nu are efect în apelant
    • Metode (4) In cazul valorilor elementare: class ValElem { public static void main( String [] args) { double a = 2.3, b = 4.5; Console .WriteLine( " a initial = " + a); suma(a, b); Console .WriteLine( " a final = " + a); } public static void suma( double x, double y) { x = x + y; Console .WriteLine( "arg 1 in metoda = " +x); } } In cazul referintelor: class ValRef { public static void main( String [] args) { Persoana pers = new Persoana (); pers.CNP = "2780609364760" ; pers.nume = "Maria Ionescu" ; Console .WriteLine( "Nume initial: " + pers.nume); casatorie(pers); Console .WriteLine( "Nume final: " + pers.nume); } public static void casatorie( Persoana refp) { refp.nume = "Maria Popescu" ; refp = null ; } }
    • Metode (5) casatorie() main() Maria IONESCU casatorie() main() Maria IONESCU before after ? OBIECT cnp, nume, pereche pers refp OBIECT cnp, nume, pereche pers refp
    • Metode (6) Tra n smiterea prin referinta:
      • metoda apelat ă prim. o referinţă la val. originala
      • În C# param. obiecte nu se transm. prin ref., se transm. prin valoare referintei la obiecte .
      • Param. decl. final nu se pot modif. în codul metodei.
      • metode cu nr. variabil de param. : ultimul param. specif. dă tipul argum. nespecificate
      public void IntParams( string Message, params int [] p) { Console .WriteLine(Message); for ( int i = 0; i < p.Length; i++) { Console .WriteLine(p[i]); } }
    • Modificatori Modificatori de acces Stabilesc reguli de vizibilitate pt. clase (în program), câmpuri şi metode (în clase)
      • La clase:
        • public – clasa este vizibila in tot programul;
        • Nesepecificat - clasa este vizibila in tot namespace-ul curent;
      Obs: La clasele incuibate modificatorii sunt membrii ai clasei incuibate;
      • La campuri
        • private – accesibil numai in metodele clasei;
        • protected – accesibil in metodele clasei curente si acelor drivate din ea si in namespace-ul curent;
        • public – accesibil oriunde este acesibila clasa;
        • Fara modificator – la nivel de namespace;
      • La metode: similar cu campurile
      • Atentie: modificatorii de acces actioneaza la nivel de clasa si nu de obiect;
    • Modificatori Alti modificatori
      • Modific. pt. clase:
        • abstract : def. incompletă (cel puţin o met. abstractă). Nu se pot crea obiecte
        • final : nu poate avea subclase (important pt. securitate)
      • La campuri
        • transient : există numai în mem., nu pe sup. extern
        • volatile : se poate modifica oricând, nu se fol. val. din registre
      • La metode:
        • abstract : nu are definit corpul. Ex.: public abstract void oMetoda();
        • s ynchronized : nu poate fi executat ă simultan în două fire de execuţie
    • Crearea obiectelor Constructori Se aplică operatorul new pe un constructor al clasei
      • Tratarea lui new:
        • din def. clasei se det. spaţiul de mem. necesar şi se rezervă în zona gest. de maş. virtuală MSIL;
        • Dacă este spaţiu, se exec. constr., după iniţializarea implicită
        • Dacă nu este sp.: se gen. exc. OutOfMemoryError şi se termină exec. programului
      • Constructorii : iniţializează obiecte , după iniţializarea implicită
        • Pot fi oricâţi într-o clasă, au acelaşi nume ca şi clasa, nu ret. valoare, se deoseb. prin param.
        • Motivaţii:
          • Clase cu iniţializ. Incompleta
          • Restricţii la crearea obiectelor, prin. constr. Ne-publici
      • Blocuri de iniţ.: instr. între acolade, în afara constr. sau metode. Se exec. inaintea constr.
    • Crearea obiectelor Constructori (2) class Complex { private float pReal = 0; private float pImag = 0; public Complex( float pReal) { this. pReal = pReal ; } public Complex( float pReal , float pImag) { this. pReal = pReal; this. pImag = pImag; } //.....
    • Supraincarcarea metodelor
      • Metode cu acelaşi nume , dar semnături diferite – metode supraîncărcate (overloaded)
      • Trebuie să difere prin numărul şi/sau tipul parametrilor si ordinea parametrilor
      • La apelul unei metode (în codul sursă) compil. determină cea mai bună corespondenţă pt. a selecta metoda
      • Obs : tipul val. ret. nu e parte din semnătură => metodele nu se pot deosebi numai prin valoarea returnată
    • Metoda main Lansarea în exec. a unui program C#
      • Sup. de exec. localiz. fiş. cu numele numeProgram.exe şi metoda main în fişier; exec. începe cu main
      • main este obligatoriu public, static şi nu ret. valoare
      • main are un arg. tablou String, numit args
      • Nu orice clasă trebuie să aibă main
      • Suportul de exec. transm. spre main, în args, argumentele din linia de comandă
    • Tablouri (1) Tablourile sunt considerate (caz special de )obiecte în C# => decl . unui tablou nu creează tabloul int [] tab = new int[3]; Persoana[] grupa = new Persoana[30];
      • Parantezele se pot pune dup ă numele de tip sau de var. Se preferă prima formă
      • Numărul de elem. din tablou se cere la creare. Nu se poate modifica
      • Accesul la elem. tabl.: prin indici
      • Câmp implicit:
      • public final int L ength;
      • Sunt permise tablori de lungime zero (tabl. vide)
      • Sunt permise tablouri cu mai multe dimensiuni:
      int [][] intArray = new int [5][6];
    • Tablouri (2) Se acceptă şi: int [,] b = { { 0, 1 }, { 2, 3 }, { 4, 5 }, { 6, 7 }, { 8, 9 } }; for ( int i = 0; i < triPas.Length; i++) triPas [i,0] = i; Similar, cu iniţializare: int [][] triPas = { { 1 }, { 1, 1 }, { 1, 2, 1 }, { 1, 3, 3, 1 } }; Managed array
    • Enumerari
      • Caz special de clase
      • public enum Volume { Low, Medium, High }
      • Numele între acolade: constantele (exemplarele) enumerării. Numai unul din acestea poate apare în orice utilizare a enumerării -> siguranţa tipurilor
      • Toate enumerările derivă din Enum (clasă abstractă)
    • Tablouri (2) Volume myVolume = Volume .Low; switch (myVolume) { case Volume .Low: Console .WriteLine( &quot;The volume has been turned Down.&quot; ); break ; case Volume .Medium: Console .WriteLine( &quot;The volume is in the middle.&quot; ); break ; case Volume .High: Console .WriteLine( &quot;The volume has been turned up.&quot; ); break ; }
    • EnumTricks (1) // declares the enum public enum Volume : byte { Low = 1, Medium, High } Dorim sa implementam un mecanism care sa permita conversia bidirectionala intre un nr. intreg si un element al unei enumerari.
    • EnumTricks (2) class Enumtricks { static void Main( string [] args){ Enumtricks enumtricks = new Enumtricks (); // demonstrates explicit cast // of int to Volume enumtricks.GetEnumFromUser(); // iterate through Volume enum by name enumtricks.ListEnumMembersByName(); // iterate through Volume enum by value enumtricks.ListEnumMembersByValue(); Console .ReadLine(); } /*...*/
    • EnumTricks (3) // get value user provided string volString = Console .ReadLine(); int volInt = Int32 .Parse(volString); // perform explicit cast from // int to Volume enum type Volume myVolume = ( Volume )volInt; Console .WriteLine( &quot;Volume Enum Members by Name:&quot; ); // get a list of member names from Volume enum, // figure out the numeric value, and display foreach(string volume in Enum .GetNames(typeof ( Volume ))){ Console .WriteLine( &quot;Volume Member: {0} Value: {1}&quot; ,volume,(byte) Enum .Parse(typeof( Volume ), volume)); }
    • EnumTricks (4) // get all values (numeric values) from the Volume // enum type, figure out member name, and display foreach ( byte val in Enum .GetValues( typeof ( Volume ))) { Console .WriteLine( &quot;Volume Value: {0} Member: {1}&quot; , val, Enum .GetName( typeof ( Volume ), val)); } Acest exemplu a fost preluat de la: http://www.csharp-station.com/Tutorials/Lesson17.aspx
    • Clase si metode generice Clase generice (1) class Stiva <E> { // declaratii de campuri // declaratii de metode public static void Main() { Stiva < String > stivasir = new Stiva < String >(); Stiva < Persoana > stivaint = new Stiva < Persoana >(); } }
      • Tipul efectiv al elementelor stivei este dat at ât la declarare, cât şi la apelul constructorului;
      • Există un singur cod al clasei Stiva . Compilatorul poate verifica dacă operaţiile cu obiecte sunt corecte, pentru că are info de tip complete
      class Nod <S, D> { // declaratii de campuri // declaratii de metode } Nod < String , Persoana >nod1= new Nod < String , Persoana >();
    • Clase si metode generice Clase generice (2)
      • Generics are the most powerful feature of C# 2.0 [MSDN]
      • GENÉRIC, -Ă, generici, -ce, adj. Care aparţine unei categorii întregi, privitor la o categorie întreagă (de fiinţe, obiecte , fenomene); care cuprinde toate cazurile de acelaşi fel. ♦ (Substantivat, n.) Partea de la începutul sau de la sfârşitul unui film, în care sunt indicate numele principalilor realizatori ai filmului respectiv. – Din fr. générique. [DexOnline]
      • Pt. aprofundare: http://msdn.microsoft.com/en-us/library/ms379564(VS.80).aspx
      • O clasă generică declară una sau mai multe variabile de tip , între paranteze unghiulare după numele clasei.
    • Clase si metode generice Metode generice Variabilele de tip ale unei clase generice se fol. la decl. de câmpuri şi def. de metode ale clasei; public bool push(E elem) { if (top == 100) return false ; tab[top++] = elem; return true ; } public E pop() { if (top == 0) return default (E); ; return ((E)tab[--top]); } public void print() { for ( int i = top - 1; i >= 0; i--) { Console .Out.WriteLine((E)tab[i]); } }
    • “Tema”
    • Intrebari ???