Clase

Clasele sunt niste intrumente foarte folositoare si distractive care fac programarea mai simpla si mai frumoasa. Ele fac parte din limbajele orientate pe obiect.
O clasa trebuie sa contina Date Membre (instante - sunt variabile) si Metode Membre (sunt functii si proceduri). Acestea trebuie sa fie precedate de modificatori de acces.
Modificatorii de acces sunt:

• private - nu permite accesul la membrii clasei
• protected - permite accesul la membrii clasei numai din clasele derivate
• public - permite accesul la membrii clasei din afara ei  

In cadrul metodelor membre trebuie sa exista un constructor si un destructor pentru fiecare clasa. Dupa cum numele le spune, este usor de inteles ce fac fiecare.
In randurile urmatoare aveti trei exemple de clase scrise in 3 limbaje de programare: C++, PHP si Python.


C++
In exemplul urmator veti vedea ca nu am specificat un modificator de acces pentru datele membre. Am facut asta pentru ca in C++ faptul ca nu exista un modificator de acces inaintea unui grup de membrii se considera implicit modificatorul private. Astfel, datele membre au modificatorul protected, iar metodele au modificatorul public.

O alta particularitate este faptul ca nici constructorul si nici destructorul nu returneaza un tip.

#include "stdafx.h"
#include <iostream> 
using namespace std;

 //clasa Eroare folosita pentru exceptie
class Eroare
{
     char* mesaj;
public:
     //constructorul clasei: pune mesajul mesaj_e
     //in data membra mesaj
     Eroare(char* mesaj_e):mesaj(mesaj_e){}
     char* eroare()
    {
          return this->mesaj;
    }
};

//clasa Produse
class Produse
{
     //datele membre
     char* nume;
     int cantitate, pret;
     //metodele membre
public:
     //consructorul clasei
     Produse(char* nume_n, int cantitate_n, int pret_n)
     {
           this->nume = nume_n;
           this->cantitate = cantitate_n;
           this->pret = pret_n;
     }
     //metoda Vinde
     void Vinde(int cantitate_v)
    {
          //aruncarea exceptiei daca cantitatea din stoc e prea mica
          if(this->cantitate < cantitate_v)
          {
                 throw Eroare("Nu aveti produse suficiente.");
          }
          this->cantitate = this->cantitate - cantitate_v;
     }
     //destructorul clasei
    ~Produse();
};

//partea de test
  int main()
{
     //initializarea clasei si a numarului de produse pe care le vindem
     Produse *instrument;
     instrument = new Produse("chitara", 5, 320);
     int nrProduseDeVazare = 7;

    //incercam sa vindem, iar daca nu reusim, returnam mesajul
    //pe care l-am aruncat in metoda Vinde() prin intermediul exceptiei
    try {
         instrument->Vinde(nrProduseDeVazare);
    } catch(Eroare& e) {
          cout<<e.eroare()<<endl;
    } 

   return 0;
}



PHP
In PHP toti membrii trebuie sa aiba inaintea lor un modificator de acces. Dar, dupa cum se vede in exemplu, lucrurile sunt un pic mai simple si mai rapide decat la C++.

//clasa Produse
class Produse
{
    //datele membre ale clasei, nu pot fi accesate din afara clasei
    protected $nume, $cantitate, $pret;
    //metodele clase, pot (public) sau nu pot(protected) fi accesate din afara clasei
    //constructorul clasei
    public function __construct($nume_n, $cantitate_n, $pret_n)
    {
          $this->nume = $nume_n;
          $this->cantitate = $cantitate_n;
          $this->pret = $pret_n;
    }
    //metoda Vinde
    public function vinde($cantitate_v)
   {
          //aruncarea exceptiei daca cantitatea din stoc este prea mica
          if($this->cantitate < $cantitate_v)
          {
                  throw new Exception('Nu aveti produse suficiente.');
          }
          $this->cantitate = $this->cantitate - $cantitate_v;
    }
    //destructorul clasei
    public function __destruct() {}
}

//partea de test
//initializarea clasei si a numarului de produse pe care dorim sa le vindem
$instrument = new Produse("chitara", 5, 320);
$nr_produse_de_vanzare = 7;

//incercam sa vindem, iar, daca nu reusim, returnam mesajul pe care l-am aruncat in metoda vinde
try {
      $instrument->vinde($nr_produse_de_vanzare);
} catch (Exception $e) {
      echo 'Eroare: ', $e->getMessage(), "\n";
}



Python

Python prin natura lui e "altfel". Are si el un constructor, __init__, respectiv un destructor, __del__, dar ceea ce ii lipseste sunt modificatorii de acces. In Python toti membrii unei clase sunt public implicit si nu se poate schimba asta. Totusi, o regula intre programatorii Python spune ca in cazul in care un membru apare de forma _nume acesta sa fie considerat protected, chiar daca in realitate e tot public.

#clasa Eroare care va fi o exceptie
class Eroare(Exception):
      def __init__(self, mesaj_e):
           self.mesaj = mesaj_e

#clasa Produse
class Produse:
      #constructorul clasei in cadrul caruia se definesc datele membre
      def __init__(self, nume_n, cantitate_n, pret_n):
          self.nume = nume_n
          self.cantitate = cantitate_n
          self.pret = pret_n
      #metoda Vinde
      def vinde(self, cantitate_v):
          #aruncarea exceptiei daca cantitatea din stoc e prea mica
          if(self.cantitate < cantitate_v):
                raise Eroare('Nu sunt produse suficiente.')
          self.cantitate = self.cantitate - cantitate_v

#partea de test
#initializarea clasei si a numarului de produse pe care le vindem
instrument = Produse('chitara', 5, 320)
nrProduseDeVanzare = 7

#incercam sa vindem, iar, daca nu reusim, afisam mesajul pe care l-am
#trimis prin clasa Eroare.
try:
      instrument.vinde(nrProduseDeVanzare)
except Eroare as e:
       print 'Eroare: ', e.mesaj
       raise