Docsity
Docsity

Prepara i tuoi esami
Prepara i tuoi esami

Studia grazie alle numerose risorse presenti su Docsity


Ottieni i punti per scaricare
Ottieni i punti per scaricare

Guadagna punti aiutando altri studenti oppure acquistali con un piano Premium


Guide e consigli
Guide e consigli


Interfacce, Appunti di Elementi di Informatica

interfacce

Tipologia: Appunti

2015/2016

Caricato il 02/06/2016

maria.ladu1
maria.ladu1 🇮🇹

6 documenti

1 / 21

Toggle sidebar

Questa pagina non è visibile nell’anteprima

Non perderti parti importanti!

bg1
18 - Classi parzialmente definite:
Classi Astratte e Interfacce
Programmazione e analisi di dati
Modulo A: Programmazione in Java
Paolo Milazzo
Dipartimento di Informatica, Universit`a di Pisa
http://www.di.unipi.it/milazzo
milazzo di.unipi.it
Corso di Laurea Magistrale in Informatica Umanistica
A.A. 2013/2014
Paolo Milazzo (Universit`a di Pisa) Programmazione - Cl. Astratte e Interfacce A.A. 2013/2014 1 / 21
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15

Anteprima parziale del testo

Scarica Interfacce e più Appunti in PDF di Elementi di Informatica solo su Docsity!

18 - Classi parzialmente definite:

Classi Astratte e Interfacce

Programmazione e analisi di dati

Modulo A: Programmazione in Java

Paolo Milazzo

Dipartimento di Informatica, Universit`a di Pisa http://www.di.unipi.it/∼milazzo milazzo di.unipi.it

Corso di Laurea Magistrale in Informatica Umanistica

A.A. 2013/

Ereditariet`a come meccanismo di astrazione (1)

L’esempio delle classi Persona-Studente-Professore mostra come

usando l’ereditarieta si possono raggruppare informazioni comuni a piu

classi.

Ereditariet`a come meccanismo di astrazione (3)

public class Cubo {

private double lato ; private double pesoSpecifico ;

public Cubo ( double lato , double ps ) { this. lato = lato ; pesoSpecifico = ps ; }

public double volume () { return Math. pow ( lato ,3); }

public double superficie () { return 6* lato * lato ; }

public double peso () { return pesoSpecifico * volume (); } }

Ereditariet`a come meccanismo di astrazione (4)

Le classi Sfera e Cubo hanno diverse cose in comune

Potremmo quindi pensare di creare una classe Solido che raggruppa i

membri comuni di Sfera e Cubo

La classe Solido dovrebbe contenere:

la variabile pesoSpecifico

il metodo peso() identico nelle due classi (e che quindi potrebbe

essere ereditato senza overriding)

i metodi volume() e superficie(), per due motivi:

I tutti i solidi hanno un volume e una superficie

I il metodo peso() invoca volume()

Ma come si calcolano superficie e volume di un solido generico?

non si pu`o fare... ogni solido ha le sue formule...

Classi Astratte (2)

Ecco la classe astratta Solido:

public abstract class Solido { // classe astratta

private double pesoSpecifico ;

public Solido ( double ps ){ pesoSpecifico = ps ; }

public double peso (){ return volume () * pesoSpecifico ; }

public abstract double volume (); // metodo astratto

public abstract double superficie (); // metodo astratto }

Classi Astratte (3)

Nella classe astratta Solido

Viene definita tramite il modificatore abstract (prima di class)

Il modificatore abstract viene usato anche nei metodi astratti

I metodi astratti consistono della sola intestazione seguita da ;

Nel metodo peso() si puo richiamare volume() anche see astratto

Una classe astratta

non puo essere usata per creare oggetti (la classe none completa...)

Solido x = new Solido () // ERRORE

pu`o solo essere estesa da un’altra classe che ne definisce i metodi

astratti (tramite overriding)

pu`o prevedere costruttori che saranno richiamati dalle sottoclassi

(tramite super)

Classi Astratte (5)

public class Cubo extends Solido {

private double lato ;

// pesoSpecifico e ’ definito nella superclasse

public Cubo ( double lato , double ps ) { super ( ps ); this. lato = lato ; }

public double volume () { return Math. pow ( lato ,3); }

public double superficie () { return 6* lato * lato ; }

// peso () e ’ definito nella superclasse

public String toString (){ return " Cubo [ " + lato + " ] " ; } }

Classi Astratte (6)

E ora un main...

import java. util. Scanner ;

public class UsaSolido { public static void main ( String args []) { Scanner input = new Scanner ( System. in );

System. out. println ( " Vuoi creare una sfera o un cubo ( s / c )? " ); char scelta = input. nextLine (). charAt (0);

if ( scelta == ’s ’ || scelta == ’c ’) { System. out. print ( " Peso Specifico? " ); double ps = input. nextDouble ();

Solido sol ; // variabile di tipo Solido

if ( scelta == ’s ’) { System. out. print ( " Raggio? " ); double raggio = input. nextDouble (); sol = new Sfera ( raggio , ps ); } else { System. out. print ( " Lato? " ); double lato = input. nextDouble (); sol = new Cubo ( lato , ps ); } System. out. println ( " Ho creato un solido " + sol + " con volume " + sol. volume () + " e peso " + sol. peso () ); }

Dalle Classi Astratte alle Interfacce (2)

Una classe che consiste di soli metodi astratti (o anche costanti) pu`o

essere meglio descritta tramite una interfaccia

// non e ’ una classe ... e ’ una interfaccia public interface ProdottoPrezzato {

// restituisce una descrizione del prodotto public String getDescrizione ();

// restituisce il prezzo del prodotto public double getPrezzo (); }

Interfacce (1)

Un’interfaccia si definisce in maniera simile a una classe astratta, ma:

e costituita da soli metodi astratti (e completamente non definita)

non usa il modificatore abstract

usa la parola chiave interface al posto di class

Inoltre, una classe che implementa i metodi dell’interfaccia deve usare la

parola chiave implements invece che extends

public class DVD extends ProdottoPrezzato { // NO !!!

public class DVD implements ProdottoPrezzato { // OK !!!

Interfacce (3)

Un altro esempio:

public class Farina implements ProdottoPrezzato {

private double prezzoAlKg ; private double peso = 0.

public Farina ( double prezzoAlKg ) { this. prezzoAlKg = prezzoAlKg ; }

public String getDescrizione () { return " Farina " ; }

public void setPeso ( double peso ) { if ( peso >0) this. peso = peso ; }

public double getPrezzo () { return prezzoAlKg * peso ; } }

Interfacce (4)

Ma... che vantaggio offrono le interfacce rispetto alle classi astratte?

Una classe pu`o estendere una sola classe (astratta o meno)

Una classe pu`o implementare tante interfacce

Ad esempio, consideriamo un’altra interfaccia:

public interface ProdottoPesabile {

public void setPeso ( double peso );

}

Interfacce (6)

Come si usano gli oggetti di classi che implementano determinate

interfacce?

Esempio: La classe Scontrino usa oggetti che implementano

ProdottoPrezzato

public class Scontrino {

... // altri membri

public void aggiungiProdotto ( ProdottoPrezzato x ) { ... this. totScontrino += x. getPrezzo (); ... }

}

Interfacce (7)

Altro esempio: La classe Bilancia usa oggetti che implementano

ProdottoPesabile

public class Bilancia {

... // altri membri

public void pesa ( ProdottoPesabile x ) { ... double peso = leggipeso (); // metodo ausiliario x. setPeso ( peso ); ... }

}