DAM-M3-UF4. Caracterització i ús d'objectes

torna M3 - Programació

Programació Orientada a objectes (POO)

La POO és un paradigma de programació.

Es representa el sistema com una col·lecció d’objectes amb certes propietats.

Aquests reben estímuls externs o esdeveniments interns, i en resposta:

• Intercanvien informació
• Canvien el seu estat (Les seves propietats)
• Produeixen resultats observables (Informació per consola, creació d'un botó, etc...)

Les responsabilitats del Sistema queden així repartides entre els objectes que col·laboren entre ells

Per comunicar-se els objectes intercanvien missatges. (Crides a mètodes)

Les Classes i els objectes

Una classe descriu la estructura d'entitats del mateix tipus. Cadascuna d'aquestes entitats s'anomena objecte.

La classe recull totes les propietats i comportaments comuns d’aquestes entitats, però no les que difereixen.

Els objectes són instàncies d’una classe, representen un estat real d’un classe on les propietats que defineixen la classe tenen un valor concret.

Es poden descriure els objectes des d’un punt vista

• Estàtic: El valor de les seves propietats, atributs (Estat)
• Dinàmica: Com respon a esdeveniments externs, mètodes (Comportament)

Descripció estàtica. Atributs

Els atributs, poden ser de dos tipus segons l’àmbit:

• Atributs d’instància poden tenir un valor diferent per a cada objecte.
• Atributs de classe. Tenen el mateix valor per a tots els objectes de la classe. Només hi ha una còpia de l'atribut que comparteixen tots els objectes de la classe.

Es defineixen diferents nivells d’accés sobre els atributs, de manera general:

• Visibilitat pública: Atributs accessibles externament.
• Visibilitat privada: Només accessibles internament.
• Visibilitat protegida: Només accessibles internament i des dels descendents.

Descripció dinàmica. Mètodes

Pot haver-hi quatre tipus de operacions o mètodes:

• Constructors i destructors: Els primers es criden en el moment que s’instancia una classe, o sigui quan es crea un objecte. Tenen el mateix nom que la classe. Java no necessita destructors.
• Modificadors (Setter): Permeten modificar el valor d’un atribut
• Consultors (Getter): Permeten obtenir el valor d’un atribut
• Altres. Qualsevol altre mètode

Les operacions també poden tenir diferents àmbit:

• Operacions d’objecte. S’apliquen als objectes de la classe.
• Operacions de classe. S’apliquen a la classe (Per exemple les operacions constructores i destructores, i els Getter/Setter sobre atributs de classe).

Els nivells d’accés sobre els mètodes,de manera general:

• Visibilitat pública: Atributs accessibles externament.
• Visibilitat privada: Només accessibles internament.

Exemple

(+) Significa public (-) Significa privat Subratllat fa referència a àmbit de classe

Instanciació, ús dels objectes

        Alumne a = new Alumne();  // Instanciació 1
        Alumne b;
        b = new Alumne();         // Instanciació 2
       
        // Accés atributs
        a.dni = "52628669T";
        a.nom = "Alex M.";
        a.edat = 23; // Error, edat és privat
       
        // Ús de mètodes
        a.setEdat(37);
        int edat = a.getEdat();
        System.out.println(a.mostrarInfo());
       
        // Àmbit de classe
        Alumne.totalAlumnes = 2;

La crida als mètodes dels objectes s'anomena enviar un missatge a un altre objecte

Mentre un objecte no s'instància, té un valor a null. Aquest valor indica que l'objecte té una referència nul·la o sigui que encara no apunta a cap estructura de memòria.

La importància de tot això és que accedir a atributs o mètodes d'objectes sense instanciar (null), és un del errors més freqüents, sobretot en programadors novells

        Alumne a = null;
        Alumne b = a;
               
        b.getEdat();

Detecció de l'error (En execució)

Exception in thread "main" java.lang.'''NullPointerException'''
    at dam.m3.uf4.PasParametres.main(PasParametres.java:10)    // Programa : Línia         

Constructors

Els constructors son els mètodes estàtics que es defineixen a les classes per instanciar els objectes.

Per defecte, si no es defineix cap constructor, Java assumeix la existència d'un genèric sense paràmetres

     Alumne a = new Alumne();

Però també es poden definir múltiples constructors diferents que permetin instanciar els objectes de maneres diferents depenent de la necessitat.

Normalment s'utilitza els constructors per inicialitzar els atributs directament en el moment de crear-los.

     Alumne a = new Alumne("52628669T", "Alex M", 37);

Destructuros

El llenguatge Java no requereix de destructors, el pròpia MV s'encarrega de destruir els objectes innecessaris i reciclar els recursos que feia servir. (Garbage Collector)

Bàsicament es tracta d'identificar els objectes que perden totes les referències, o dit d'una altra manera, els objectes que queden inaccessibles.

        Alumne a = new Alumne();
        Alumne b = new Alumne();
       
        // "a" fa referència a un objecte oid: 1000
        // "b" fa referència a un objecte oid: 1001
       
        b = a;
       
        // L'objecte oid:1000 ara té 2 referències
        // L'objecte oid:1001 no té cap referència, ja no s'hi pot accedir

El procés "Garbage Collector", s'executa en background de manera transparent a l'usuari, i en principi abans d'alliberar un objecte crida al mètode finalize() disponible per defecte per a qualsevol objecte.

El desavantatge és que l'usuari no té control sobre el moment en que això succeeix, i per tant no és un mètode recomanable de fer servir.

Referències

Un objecte és una entitat complexa i pot arribar a contenir molta informació, cadascun dels objectes del sistema s'identifica per un oid únic.

Cal anar en compte quan es treballa amb objectes perquè vàries variables poden fer referència al mateix objecte i per tant aquest pot ser modificat des de diferents llocs del programa.

        Alumne a = new Alumne();
        Alumne b = new Alumne();
       
        a.nom = "Alex M.";
        b.nom = "Pep G.";
       
        b = a;  // L'objecte b deixa d'existir pq perd la única referència que tenia
       
        System.out.println(b.nom); // Mostra "Alex M."

En cas que es necessiti una còpia de l'objecte, o sigui un altre objecte amb els mateixos valors als atributs.

Es pot implementar un mètode clone() a la classe corresponent

        Alumne a = new Alumne();
   
        Alumne b = a.clone();  // b és un altre objecte amb el mateix estat (mateixos valors)

A més cal tenir en compte les comparacions d'objectes, sempre s'ha de fer servir el mètode equals()

        Alumne a = new Alumne();
        a.dni = "52628669T";
        a.nom = "Alex M.";
       
        Alumne b = new Alumne();
        b.dni = "52628669T";
        b.nom = "Alex M.";
       
        System.out.println(a == b); // Retorna false. Compara referències
               
        System.out.println(a.equals(b)); // Retorna true. Compara valors

Tipus primitius vs Objectes

Els tipus primitius : DAM-M3-UF4._Sintaxi#Declaraci.C3.B3_de_variables_i_assignaci.C3.B3

Identificar-los és immediat.

• Els tipus primitius comencen amb minúscules

• Els objectes comencen amb majúscules

Tots els tipus primitius tenen una classe associada anomenada wrapper (Envolcall).

Cada envolcall permet emmagatzemar el valor del tipus primitiu, i alhora ofereix mètodes d'utilitat (p.e. conversió entre tipus) i constants (valor màxim, mínim, etc...)

Exemples són

Primitiu	Envolcall
int	Interger
double	Double
boolean	Boolean

Conversions de tipus

Tipus de conversió	Com fer-ho	Exemple
Integer a partir de int	Integer ii = new Integer(i); on i és un int	Integer ii = new Integer(2);
Integer a partir de String	Integer ii= new Integer(s); on s és un String	Integer ii = new Integer("2");
	Integer ii = Integer.valueOf(s); on s és un String	ii = Integer.valueOf("2");
int a partir de String	int i = Integer.parseInt(s); on s és un String	int i = Integer.parseInt("2");
int a partir de Integer	int i = ii.intValue(); on ii és un Integer	int i = ii.intValue();
String a partir de Integer	String s = ii.toString(); on ii és un Integer	String s = ii.toString();
String a partir de int	String s = String.valueOf(i); on i és un int	String s = String.valueOf(2);
String a partir de boolean	String s = String.valueOf(b); on b és un boolean	String s = String.valueOf(false);
String a partir de char	String s = String.valueOf(c); on c és un char
String a partir de float	String s = String.valueOf(f); on f és un float