Estructures de dades

Apunts Laboratori 1:
Abstracció, herència, interfícies
Grau d’Enginyeria Informàtica · Curs 2023-2024
Escola Tècnica Superior d’Enginyeria
Universitat Rovira i Virgili
Abstracció
 Abstracció: un nou recurs per millorar el disseny de software

abstracte / -a
Dit de tota noció considerada d'una manera més o menys general i
separadament de les representacions en les quals és donada.
PRINCIPI BÀSIC
L’objectiu principal és poder modelar estructures complexes mentre
amaguem els detalls a l’usuari. L’usuari de la nostra classe abstracta
sabrà què fa la classe però no sabrà com està implementat. Exemple:

classe “Porta”
ESPECIFICACIÓ // Atributs
estat = {obert, tancat}
// Mètodes
porta obrir()
tancar()
Obertura que es fa en una paret per permet entrar i sortir i que pot estar
oberta o tancada

UTILITAT: QUÈ ENS APORTA?

DIVERSES IMPLEMENTACIONS
• Millorar el disseny descendent. Especificació separada de la
implementació. L’usuari de la classe abstracta no té perquè
conèixer la implementació. En té prou amb l’especificació. Similar
a l’ús de capçaleres.
• Simplificar les implementacions. Minimitza l’ús de sentències
condicionals per tractar diferents implementacions.
• Facilitar el reaprofitament de codi, en no tenir les classes
fortament dependents (lligades) de les implementacions mútues.
• Permetre millorar el codi de forma fàcil. Podem tenir diferents
implementacions serons les necessitats actuals i futures.
El concepte d’abstracció en Java

Herència Classes abstractes Interfícies

Menys abstracte Més abstracte

Herència
 Herència Classes Interfícies
abstractes
Herència
Menys abstracte Més abstracte
Definició i conceptes

L’herència és el procés pel qual una classe adquireix les propietats (atributs) i les
funcionalitats (mètodes) d’una altra classe.

Per què hauríem de voler que una classe hereti els mètodes i propietats d’una altra? Per què
classe “Porta”
estan relacionades d’alguna manera i no volem tornar a escriure el codi, cosa que generaria codi
// Atributs
duplicat i qualsevol canvi que haguéssim de fer al codi suposaria haver-ho de canviar a més d’un lloc.
estat = {obert, tancat}
Classe “Base” / “Parent class” / “Superclass”: // Mètodes
La classe que defineix les propietats i funcionalitats compartides per tots els objectes de la mateixa obrir()
classe. tancar()
Classe “Derivada” / “Classe filla” / “Subclasse”:
És la classe que hereda les propietats i els mètodes de la classe Base, en pot afegir de nous,
sobreescriure (override) o completar (accés mitjançant super) els mètodes de la classe Base.
classe “PortaEntrada”
Modificadors d’accés als mètodes // Atributs
estat = {obert, tancat, tancatAmbClau}
// Mètodes
obrir()
tancar()
tancarAmbClau()
 Herència Classes Interfícies
abstractes
Herència
Com heredem en Java… Menys abstracte Més abstracte

class Derivada extends Base {…}

public class Estudiant extends Persona {

//Atributs addicionals
private String carrera;
public class Persona {
public Estudiant(String nom, String carrera) {
super(nom);
// Atributs
this.carrera=carrera;
private String nom;
}

// Aqui constructor public void estudiar() {

public Persona(String nom) { System.out.println("Estic estudiant la carrera " + carrera);
this.nom = nom; }
}
public static void main(String [] args) {
// Mètodes Estudiant e = new Estudiant("Joan","GEI");
public void saludar() { e.saludar();
System.out.println("Hola em dic " + nom); e.estudiar();
} OUTPUT:
}
} Hola em dic Joan
}
Estic estudiant la carrera GEI
Herència: possibles tipus d’herència…
Viable: Persona

Persona
Persona
Estudiant

Estudiant Estudiant Professor EstudiantErasmus

No Viable:
Si EstudiantTreballador hereta d’Estudiant i de Treballador,
què hauria de passar si crido al mètode saludar() ?

public class Estudiant {

Estudiant Treballador // ...
public void saludar() { System.out.println("Hola sóc un Estudiant”);}
}
public class Treballador {
// ...
EstudiantTreballador
public void saludar() { System.out.println("Hola sóc un Treballador”);}
}
Classes abstractes
 Herència Classes Interfícies
Classes abstractes abstractes

Definició Menys abstracte Més abstracte

Una classe abstracta és una classe incomplerta que té mètodes abstractes. Mètode declarat
Un mètode abstracte és un mètode que està declarat però encara no definit. És a dir, és
un mètode que té signatura (sabem quins paràmetres accepta i què retorna) però no té public int ferOperacio(int x, int y);

cos.
Mètode declarat i definit
Per quin motiu ens hauria d’interessar tenir mètodes declarats però no definits?
public int ferOperacio(int x, int y){
Quan fem servir herència, a vegades volem forçar que una classe derivada implementi un mètode, return (x+y*2);
però aquest mètode pot no tenir sentit en la classe Base. }

Diferents classes que extenguin de la classe abstracta poden tenir implementacions/funcionalitats:

millora de rendiment, diferents estructures internes o simplement diferent procediment.

public class Ovella { public class Gat {

// Atributs ... // Atributs ...
// Mètodes // Mètodes
public void caminar() { public void caminar() { Com que les dues classes estan
System.out.println("Estic caminant"); System.out.println("Estic caminant"); relacionades estretament i hi ha
} }
duplicitat de codi, el programador
public void so() { public void so() {
decideix fer servir herència…
System.out.println("BEEEE"); System.out.println(“MIAU");
} }
} }
Classes abstractes

public class Animal {

// Atributs ... Problema: la funció “so” vull que la tinguin tots els
// Mètodes animals, però quina implementació li dono a Animal? Un
public void caminar() { “Animal” en general no fa cap so en concret!
System.out.println("Estic caminant");
}
Solució: fer la classe “Animal” abstracta. Així m’asseguro
public void so() {
que tots els “fills” d’”Animal” tindran un so, però no
System.out.println(“????”);
n’especifico cap per defecte, perquè no tindria sentit.
}
}

public class Ovella extends Animal { public class Gat extends Animal {
// Atributs ... // Atributs ...
// Mètodes // Mètodes

public void so() { public void so() {

System.out.println("BEEEE"); System.out.println(“MIAU");
} }
} }
Classes abstractes

public abstract class Animal {

// Atributs ... Problema: la funció “so” vull que la tinguin tots els
// Mètodes animals, però quina implementació li dono a Animal? Un
public void caminar() { “Animal” en general no fa cap so en concret!
System.out.println("Estic caminant");
}
Solució: fer la classe “Animal” abstracta. Així m’asseguro
public abstract void so();
que tots els “fills” d’”Animal” tindran un so, però no
n’especifico cap per defecte, perquè no tindria sentit.
}

public class Ovella extends Animal { public class Gat extends Animal {
// Atributs ... // Atributs ...
// Mètodes // Mètodes

public void so() { public void so() {

System.out.println("BEEEE"); System.out.println(“MIAU");
} }
} }
Classes abstractes
Sintaxi en Java:

abstract class ClasseAbstracta {…} class DerivadaNoAbstracta extends ClasseAbstracta {…}

abstract class DerivadaAbstracta extends ClasseAbstracta {…}

Característiques
La paraula clau “abstract” només es pot aplicar a classes i mètodes non-static.
Una classe pot ser declarada abstracta i no tenir cap mètode abstracte dins.
Una classe abstracta no es pot instanciar (perquè està
Si la classe té com a mínim un mètode abstracte, s’ha de declarar com abstract per
incompleta i no es podria garantir el funcionament de tots
força.
els seus mètodes).
Una classe que hereti d’una classe abstracta, o bé:
public abstract class Animal { a) Implementa tots els mètodes de la classe pare abstracta
... b) Es declara com abstracta
} En una classe abstracta que hereti d’una altra els mètodes poden canviar de modificador
Animal a = new Animal();
d’accés sempre que aquest sigui menys restrictiu.

Només se’n poden instanciar els fills:

Gat g = new Gat();

Ovella o = new Ovella();
Interfícies
Interfícies

Definició i característiques Exemple

• Una interfície és el recurs que proporciona més abstracció.

• Les intefícies proporcionen un prototip o un plànol d’una classe.
public interface Animal {
// Atributs ...
• A diferència de l’herència i de les classes abstractes no està pensat
// Mètodes
per formar jerarquies d’abstracció.
void caminar();
• En aquest cas el principal ús es per forçar un contracte a les void so();
classes que l’implementin. Una propietat, un mètode. Per exemple, }
la interfície comparable.
• Una interface no pot contenir cap mètode implmentat, similar a un .h public class Ovella implements Animal {
en C. Tots els mètodes han de ser abstractes. // Atributs ...
// Mètodes
• Les interfícies no tenen els mètodes implementats per definició → No es pot instanciar!! public void caminar() {
System.out.println(“
Estic caminant com una ovella");
}
interface Animal { abstract interface Animal { public void so() {
int ID = 99; public static final int ID = 99; System.out.println("BEEEE");
// Mètodes = // Mètodes }
void caminar(); public abstract void caminar(); }
void so(); public abstract void so();
} }

• Els mètodes d’una interfície són tots per definició, public i abstract.
• Els atributs d’una interfície són tots, per definició, public, static i final.
Es poden accedir, però no modificar.
Interfícies
Sintaxi en Java

• Una interfície pot ser: • Al ser interpretat com un contracte de funcionament, una classe pot
A. Implementada per una classe (com en l’exemple anterior) implementar diverses interfícies

interface Animal { ... }

interface Animal { ... }
class Ovella implements Animal { ... }
interface Robot { ... }

Es diu que una classe “implementa” una interfície si class AnimalRobot implements Animal, Robot { ... }
defineix un codi per tots i cadascun dels mètodes que
es declaren en aquella interfície.
A més, també en pot definir més.
• Una classe pot implementar diverses interfícies i heretar d’una altra classe

B. “Extended” per una altra interfície. class Ovella implements Animal { ... }

interface Animal { ... } interface Robot { ... }

class OvellaRobotica extends Ovella
interface Mamifer extends Animal { ... } implements Robot { ... }
Interfícies vs Classes Abstractes

Diferències conceptuals

• Classe abstracta: • Interfície

• Quan implementes classes que estan estretament
relacionades (herència) però algunes classes (o
mètodes) no tenen sentit en la classe Base.
• Diverses classes poden tenir implementacions
diferents en alguns mètodes però no en altres.
• Quan vols que classes que no estan relacionades
tinguin les mateixes funcionalitats. E.g.
Comparable, Iterable, etc
• Per amagar els detalls d’implementació.
• Permeten herència múltiple.

Diferències des del punt de vista tècnic

Classes abstractes Interfaces

Accés Membres poden tenir modificador d’accés (públic…) Tots els seus membres són públics
Mètodes Pot tenir mètodes abstractes i concrets Cap mètode està implementat
Variables de classe Poden ser final/non-final, static/non-static, publiques o no. Totes les variables són final i static i públiques
Sintaxi afegir “abstract” a una classe la converteix en abstracta “interface” en comptes de “class”
Si una classe fa “extend” d’una interface, aquesta ha de ser una
Classe filla ha de fer “extends”, i implementar els mètodes interface també. Si una classe fa “implements” d’una interface,
Herència
que falten o declarar-se com abstract també. ha d’implementar tots els seus mètodes (si no ho fa, s’ha de
declarar abstract).
Herència múltiple No permet herència múltiple per si sola Es pot assolir herència múltiple extenent diverses interfaces