Clase si Obiecte - Interface

Curs Flash

Interface (Interfata) este o clasa folosita ca tipar, sau template pentru clase cu functii similare, care trebuie sa respecte o anumita structura de baza.
Sintetizat, Interface este o clasa cu o lista de metode obligatorii ce trebuie sa fie create in clasele unde este implementata. Toate metodele specificate in "Interface" trebuie sa fie definite in clasele in care e aplicata, avand aceeasi denumire, tip si parametri cum sunt indicate in "Interface".

1. Creare interface

Clasa interface se creaza similar cu celelalte tipuri de clase, intr-un "package", salvata in document AS separat. Diferenta e aceea ca la definirea ei, in loc de cuvantul "class" se foloseste cuvantul "interface"; in plus, in corpul ei se scrie doar o lista cu metodele fara, alt cod.
Sintaxa generala este urmatoarea:

• package {
      public interface numeInterfata {
          function numeMetoda(prop1:Tip, prop2:Tip, ...):Tip;
          function altaMetoda(prop1:Tip, prop2:Tip, ...):Tip;
          ...........
      }
  }

- La declararea metodelor in Interface nu se adauga acoladele sau codul lor, si nici vreun atribut, deoarece in aceasta clasa se scriu doar metode care au atributul "public" in clasele unde e implementata.
- Nu se pot specifica proprietati, dar pot fi adaugate metode Accesor (prin care se dau valori proprietatilor).

Iata un exemplu cu o Interface, denumita "ITest", in care sunt definite 2 metode: "Links()" si "Tutoriale()".

package {
  // Se creaza interface
  public interface ITest {
    // Lista cu metode
    function Links():void;
    function Tutoriale(gen:String, nota:int):String
  }
}

- Acest cod se adauga intr-un document "ActionScript 3.0 Class" (sau "ActionScript 3.0 Interface"), la numele clasei se scrie "ITest" si fisierul cu acest cod trebuie salvat cu denumirea "ITest.as", in acelasi director in care sunt salvate si clasele in care va fi implementata.

2. Implementare interface

Dupa ce a fost salvat tiparul "interface", se pot crea clase care implementeaza metodele stabilite in acel tipar.
Implementarea se face adaugand cuvantul implements si numele Interfatei la definirea claselor, dupa numele lor.
                public class numeClasa implements numeInterfata {
                    // Instructiuni
                }
Acestea trebuie sa contina in corpul lor toate metodele definite in "interface", cu atribut "public", numarul de parametri si tipul lor stabilite in tipar. Pe langa acestea pot contine si alte metode.

In urmatorul exemplu se creaza o clasa (webDevelopment), intr-un nou document AS, cu numele "webDevelopment.as" si se salveaza in acelasi director unde e si interfata "ITest".

package {
  // Creare clasa care aplica Interfata ITest
  public class webDevelopment implements ITest
  {
    // Definire proprietate 'site' (cu atribut "protected")
    protected var site:String = 'marplo.net';

          /* Definire metodele obligatorii (Links si Tutoriale), din interface */

    // Returneaza in Output valoarea proprietatii 'site'
    public function Links():void
    {
      trace(this.site);
    }

    // Returneaza valoarea unei variabile din ea (re), ce preia argumentele transmise
    public function Tutoriale(gen:String, note:int):String
    {
      var re:String = gen+'-'+note;
      return re;
    }

    // Se creaza o alta metoda, suplimentara
    // Afiseaza in Output argumentul primit
    public function Diverse(val:*):void
    {
      trace(val);
    }
  }
}

- Metodele obligatorii (aici "Links" si "Tutoriale") respecta exact parametri (numarul, ordinea si tipul) stabilite in "interface" "ITest". Alte metode (aiici "Diverse") si proprietati sunt optionale, in functie de rolul fiecarei clase.
- Numele parametrilor nu conteaza (observati ca in loc de "nota" s-a folosit "note"), dar numarul, tipul si ordinea lor trebuie sa fie aceleasi ca in "interface".

Pentru a testa acest exemplu, se foloseste urmatoarul script ActionScript intr-un document FLA nou, salvat in acelasi director cu interfata si clasa de mai sus.

// Creare instanta obiect la clasa webDevelopment
var obj:webDevelopment = new webDevelopment();

// Se apeleaza metodele
obj.Links();                             // marplo.net
trace(obj.Tutoriale('Flash', 8));        // Flash-8
obj.Diverse(2010);                       // 2010

- Deoarece clasa "webDevelopment" indeplineste conditiile din interfata implementata (ITest), scriptul este functional.
- Daca vreuna din conditii nu ar fi respectata in clasa, cum ar fi: nedefinirea unei metode, adaugarea de parametru in plus sau declararea cu alt tip; scriptul genereaza eroare.
Astfel, implementarea de "interface" este utila mai ales cand sunt create mai multe clase cu roluri similare si dorim ca acestea sa aibe toate o anumita ordonare si structura minima de metode, mai usor de retinut.

3. Interface ca tip de date

Interfata poate fi aplicata si ca tip de data la variabile (sau parametri de functii), astfel, acea variabila (sau parametru) poate fi utilizata ca instanta de obiect la clasa precizata ca valoare, din cele ce folosesc acea "interface".
Se intelege mai bine din urmatorul exemplu, in care e creata si folosita inca o clasa (limbiStraine) ce aplica Tiparul din "ITest"; contine o proprietate si metodele obligatorii stabilite.

package {
  // Creare clasa care aplica Interfata ITest
  public class limbiStraine implements ITest
  {
    // Definire proprietate 'site' (cu atribut "protected")
    protected var adr:String = 'marplo.net/';

          /* Definire metodele obligatorii (Links si Tutoriale), din interface */

    // Returneaza in Output cuvantul 'Cale buna'
    public function Links():void
    {
      trace('Cale buna');
    }

    // Returneaza valoarea unei variabile din ea (re), ce preia argumentele "nr", "gen" si proprietatea "adr"
    public function Tutoriale(gen:String, nr:int):String
    {
      var re:String = nr+'-'+ this.adr+gen;
      return re;
    }
  }
}

In documentul FLA se scrie urmatorul cod la panoul ActionScript.

// Creare instante obiecte la clasele folosite
var web_development:webDevelopment = new webDevelopment();
var limbi_straine:limbiStraine = new limbiStraine();

// Creare functie a carui parametru are ca tip de data Interfata "ITest"
function cursuri(cls:ITest):void
{
  // Apeleaza metodele comune (stabilite in ITest) prin parametru "cls"
  cls.Links();
  trace(cls.Tutoriale('flash', 4));
}

// Apeleaza functia cu numele unei clase ce are aplicat ITest
cursuri(web_development);        // In Output afiseaza: marplo.net si flash-4
cursuri(limbi_straine);          // In Output afiseaza: Cale buna si 4-marplo.net/flash

- Observati ca apeland functia cu argumente diferite, reprezentand numele instantelor la clase, functia foloseste parametru "cls" (are ca tip de date interfata, ITest) ca instanta la clasa respectiva, si poate apela aceleasi metodele ("Links" si "Tutoriale") pt. fiecare deoarece aceste fiind specificate in "interface" ele trebuie sa existe in fiecare clasa ce apartine acelei Interfate, cu acelasi tip de parametri.
- Prin aceasta tehnica nu mai e nevoie de a crea aceeasi functie pt. fiecare instanta.

• Precum clasele, si "interface" poate fi creata prin extindere din alta Interfata, mostenind astfel lista de metode a aceleia, plus ce se mai adauga in ea. Sintaxa de definire fiind:
                public interface InterfataCopil extends InterfaceParinte {
                    // Lista metode suplimentare:
                }
- InterfataCopil va contine lista de metode mostenite din InterfataParinte, plus ce se mai adauga in ea. Nu va afecta in nici un fel InterfataParinte.

• O "interface" poate fi aplicate si la clasele extinse (copil), cu formula:
                public clasaCopil extends clasaParinte implements Interfata
- clasaCopil poate fi o extindere a oricarei clase, indiferent daca clasaParinte are implementata sau nu Interfata.

• O clasa poate implementa mai multe interface, separate prin virgula, dupa formula:
            public class numeClasa implements Interface1, Interface2

Atentie, daca modificati o "interface" (adaugand metode sau schimbandu-le definirea) care e deja aplicata in clase, acestea nu vor mai functiona deoarece nu mai respecta intru totul Interfata.

Fisierele FLA si AS cu exemplele din aceasta lectie pot fi descarcate de la: Clase si obiecte - Interface

<ul>
 <li>http://coursesweb.net/html/</li>
 <li>http://www.marplo.net/html/</li>
</ul>

.some_class {
  display: list-item;
}

var obj = {
 "courses": ["php", "javascript", "ajax"]
};
var jsonstr = JSON.stringify(obj);
alert(jsonstr);    // {"courses":["php","javascript","ajax"]}

$strhtml = '<body><div id="dv1">CoursesWeb.net</div></body>';
$dochtml = new DOMDocument();
$dochtml->loadHTML($strhtml);
$elm = $dochtml->getElementById("dv1");
echo $elm->nodeValue;    // CoursesWeb.net

I`m living here.
- Traiesc /Locuiesc aici.

Estoy viviendo aquí.
- Traiesc /Locuiesc aici.