Diferència entre revisions de la pàgina «DAM-M3-UF4. Introducció»

Revisió de 00:22, 17 gen 2025

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 o instàncies des d’un punt vista

• Estat de l'objecte: El valor de les seves propietats, atributs
• Comportament de l'objecte: Com respon a esdeveniments externs, mètodes

Classe. Sintaxis

La estructura d'una classe normal a Java és

public class NomClasse {
     {constants}

     {atributs}

     {constructors}

     {getters / setters}

     {altres mètodes}
}

Per conveni:

• El nom de la classe comença amb majúscules.
• El nom dels atributs i mètodes comencen en minúscules.
• Si consten de vàries paraules, van seguides (sense espais o altres caràcters) i cada nova paraula comença amb majúscules. CamelCase
• Primer van els atributs: constants i atributs normals.
• Les constants van tots en majúscules i les paraules es separen per "_"
• Després els mètodes: constructors, getters/setters i altres.

Les classes de Java poden ser:

• public: Accessibles
• Sense modificador: Accessibles només des del mateix paquet.

A més per establir utilitza els modificadors: abstract, final, synchronizable

• abstract: Té mínim un mètode abstract que cal implementar (Herència).
• final: no admet subclasses.
• syncronizable: Per al tractament de fils (Threads). Tots els mètodes estan sincronitzats, no s’hi pot accedir des de diferents fils al mateix temps.

Visibilitat

Cal anar en compte amb els paquets que poden donar visions errònies de la visibilitat.

Descripció de l'estat. Atributs i dades

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

• Atributs d’instància
  • Cada objecte o instància té el seu propi conjunt de valors per tots aquests atributs
  • Poden tenir un valor diferent per a cada objecte o instància.
  • S'accedeix a cada atribut a través de l'objecte o instància
• Atributs de classe o estàtics.
  • Independent de les instàncies (objectes) de la classe
  • Només hi ha una còpia de l'atribut que comparteixen tots els objectes de la classe
  • S'accedeix als atributs estàtics directament amb 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 descendents descendents.

Atributs. Sintaxis

Els atributs defineixen l'estat dels objectes de la classe. Tots els objectes de la classe tenen els mateixos atributs però amb valors diferents.

Aquests es poden precedir de modificadors que en determinen l’accés i el tipus. Els modificadors d’accés determinen la visibilitat dels atributs:

• Sense modificador, accessible des de les classes del mateix paquet
• private, accessible des de la pròpia classe
• protected, accessible des de la pròpia classe i subclasses
• public, totalment accessibles

En general els atributs sempre són private (o protected). Les constants poden ser públiques si són d'utilitat.

Els modificadors de tipus:

• static, atribut de classe o estàtic
• final, constant, el valor no pot canviar després de ser inicialitzat.

Aquests dos modificadors s'utilitza per declarar constants per exemple. La constant és independent de les instàncies o objectes (estàtic) i no s'ha de poder modificar el valor inicial (final).

public class Alumne {
    public static final int MAX_ALUMNES = 30;
    private static int totalAlumnes;
    private String dni;
    private String nom;
    private int edat;
}

Descripció del comportament. 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
  • Mètodes constructors i destructors
  • Getter/Setter sobre atributs de classe
  • Mètodes d'utilitat de classe (veure mètodes de wrappers tipus primitius: Integer, Double, etc...)

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

Mètodes. Sintaxis

Els mètodes determinen el comportament, permeten la comunicació entre objectes.

Aquests també poden anar precedits de modificadors que en determinen l’accés i el tipus.

Els Modificadors d’accés determinen la visibilitat dels mètodes i són els mateixos que per als atributs: Sense modificador, private, protected, public.

En general els mètodes seran públics excepte si són mètodes d'utilitat interns de la classe (privat / protected)

Els modificadors de tipus,

• static, mètode de classe o estàtic
• abstract, mètode no implementat, cal reescriure’l en els descendents (Herència).
• final, el mètode no pot ser sobreescrit en cap dels descendents
• syncronizable, tractament multifil.

Sobrecàrrega de mètodes (Overload)

Java permet la sobrecàrrega de mètodes, que consisteix en tenir mètodes amb el mateix nom però amb una llista diferent de paràmetres, així en temps de compilació es pot determinar quin dels mètodes cal fer servir.

(No confondre amb sobreescriptura que es resol en temps d'execució).

Això es fa servir per exemple si algun dels paràmetres és opcional.

    public void incrementaEdat() {
        edat++;
    }
    public void incrementaEdat(int inc) {
        edat += inc;
    }

Un exemple de sobrecàrrega el tenim al mètode println

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/PrintStream.html#println()

Constructors

Els constructors són mètodes de classe que permeten crear instàncies (objectes) de la classe.

Tenen el mateix nom que la classe i en general es poden sobrecarregar.

Si no existeix cap constructor per a una classe, Java sobreentén la existència d'un constructor sense paràmetres que només instància objectes.

Normalment es crea un constructor per a cada forma de crear objectes que sigui necessària, per exemple per inicialitzar tots els atributs, només alguns, etc...

public class Alumne {
    public static final int MAX_ALUMNES = 30;
    private static int totalAlumnes;
    private String dni;
    private String nom;
    private int edat;

    public Alumne(String dni, String nom, int edat) {
        super();
        this.dni = dni;
        this.nom = nom;
        this.edat = edat;
        totalAlumnes++;
    }

    public Alumne(String dni, String nom) {
        super();
        this.dni = dni;
        this.nom = nom;
        this.edat = 18;
        totalAlumnes++;
    }
    ....
}

La paraula this fa referència a la pròpia classe, serveix per exemple diferenciar entre l'atribut i el paràmetre del mètode.

Getters / Setters

Els getters/setters permeten accedir i modificar els atributs dels objectes. Cal recordar que per norma aquests són privats (sense accés des de fora).

En general la classe ofereix un getter i un setter per a cada atribut

public class Alumne {
    public static final int MAX_ALUMNES = 30;
    private static int totalAlumnes;
    private String dni;
    private String nom;
    private int edat;

    public static int getTotalAlumnes() {
        return totalAlumnes;
    }
    public static void setTotalAlumnes(int totalAlumnes) {
        Alumne.totalAlumnes = totalAlumnes;
    }
    public String getDni() {
        return dni;
    }
    public void setDni(String dni) {
        this.dni = dni;
    }
    ....
}

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());

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         

Àmbit de classe o estàtic

En aquest cas tant per atributs com per a mètodes, com només existeix una còpia per a totes les instàncies, s'accedeix utilitzant el nom de la classe.

    // Àmbit de classe
    Alumne.totalAlumnes = 2;

    // Àmbit de classe
    int total = Alumne.getTotalAlumnes();

Destructors

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() (Cal sobreescriure la implementació per defecte de la classe Object)

    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. Implementació comparant els valors de les instàncies

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

Conversions de tipus

Gestió de memòria. Estàtica vs Dinàmica

(Pendent)