01 - Intro-Dal-C-al-OOP

Introduzione all’OOP!
–  Introdurre l’evoluzione dei linguaggi di
programmazione e la loro classificazione
–  Introdurre l’OOP (astrazione, incapsulamento,
ereditarietà)
–  Dal C a Java … un primo esempio
1
1
LINGUAGGI DI ALTO LIVELLO!
Si basano su una
macchina virtuale le
cui “mosse” non
sono quelle della
macchina hardware
2
Un po’ di storia sui linguaggi
1957
John Backus e colleghi della IBM rilasciano
la prima versione del compilatore per il
linguaggio di programmazione FORTRAN
(Formula Translator) alla Westinghouse.
1959
Si forma il Comitato per i linguaggi di sistemi di dati
e nasce il COBOL (Common Business Oriented
Language).
1959
John McCarthy sviluppa il linguaggio LISP
(List Processing) per le applicazioni di
Intelligenza Artificiale.
1964
Nasce il linguaggio BASIC (Beginner's Allpurpose Symbolic Instruction Code). E'
sviluppato a Dartmouth da John Kemeny e
Thomas Kurtz. Ne deriveranno molte
varianti.
3
Un po’ di storia sui linguaggi
1967
Ole-Johan Dahl e Kristen Nygaard del Centro
Computer Norvegese, completano una versione
general-purpose del linguaggio SIMULA, il
primo linguaggio object-oriented.
1972
Dennis Ritchie sviluppa il linguaggio "C" ai
laboratori Bell. Così chiamato semplicemente perchè
il suo predecessore era stato battezzato "B".
1995
Nasce il linguaggio di programmazione Java, piattaforma
indipendente per sviluppo di applicazioni.
4
EVOLUZIONE DEI LINGUAGGI
ADA
C++
VISICALC
PROLOG
SMALLTALK
FORTRAN77
LISP
PASCAL
SIMULA67
LISP
ALGOL
APL
COBOL
LISP
ALGOL
LISP
FORTRAN
C
Linguaggi-macchina
PlanKalcul 1945
1950
1960
1970
1980
1990
2000
5
LINGUAGGI DI ALTO LIVELLO
Barriera di astrazione
Fortran
C
Modula-2
Smalltalk
Java
Cobol
Basic
Pascal
Python
Algol
Simula67
C++
Ada
Lisp
Scheme
Prolog
ML
6
LINGUAGGI DI ALTO LIVELLO
Barriera di astrazione
IMPERATIVI
Fortran
C
Modula-2
Smalltalk
Java
Cobol
Basic
Pascal
Python
Algol
Lisp
Simula67
C++
A OGGETTI
Ada
Scheme
Prolog
DICHIARATIVI
FUNZIONALI
ML
7
EVOLUZIONE DEI LINGUAGGI
FORTRAN
BASIC
ALGOL60
PASCAL
ADA
SIMULA67
SMALLTALK
C++
8
Quali astrazioni?
•  Sui dati: da indirizzi fisici a nomi simbolici per le
variabili (Assembler)
•  Sul controllo (programmazione strutturata,
Pascal, C):
–  sequenza (;),
–  blocco,
–  if else, while do, etc.
{ int p=1;
for (i=1 ; i <= n ; ++i)
. . .
}
p *= x;
9
Astrazioni funzionali
•  Sulle operazioni (funzioni):
long potenza(int x, int n) /* par. formali */
{ int i;
long p = 1;
/* var. locali */
for (i=1 ; i <= n ; ++i) p *= x;
return p;
}
long Y;
Y=potenza(X,10);
10
Encapsulation
•  Coniugare l’astrazione su dati e operazioni
(astrazioni di dato, tipi di dato astratto, classi e
oggetti)
–  Incapsulamento (dati e operazioni)
–  Protezione
–  Coesione
–  Riuso
–  … (Ereditarietà)
11
Astrazioni di dato!
•  Il componente ha dati locali (nascosti) e rende visibili
all’esterno i prototipi delle operazioni invocabili (procedure e
funzioni) su questi dati locali, ma non gli identificatori dei dati.
Attraverso una di queste operazioni si può assegnare un valore
iniziale ai dati locali nascosti.!
Interfaccia
Operazioni
Dati
Corpo
12
12
Esempio: il contatore!
1.  file header contatore.h"
void reset(void);
void inc(void);
void stampa(void);
Definisce cosa si può fare
con il contatore!
2.  file di implementazione contatore.c"
#include "contatore.h" Incapsula il contatore c (IL dato)
e specifica il codice delle
static int c;
funzioni con cui si agisce sul
void reset(void){ c=0; } contatore!
void inc(void){ c++; }
void stampa(void) { printf(“%d”, c); }
13
13
Tipo di dato astratto !
(Abstract Data Type – ADT)!
•  Il componente esporta un identificatore di tipo T ed
i prototipi delle operazioni eseguibili su dati dichiarati
di questo tipo. I “clienti” del componente dichiarano
e controllano quindi il tempo di vita delle variabili di
tipo T.!
Interfaccia
Id_tipo
Operazioni
Def.
Tipo di
Dato
Corpo
14
14
Esempio: ADT counter!
1.  file header counter.h"
typedef int counter;
void reset(counter*);
void inc(counter*);
Definisce in astratto che
cos’è un counter e che
cosa si può fare con esso!
2.  file di implementazione counter.c"
#include "counter.h"
void reset(counter *c){ *c=0; }
void inc(counter* c){ (*c)++; }
Specifica come funziona (quale è
l’implementazione) di counter!
15
15
ADT counter: un cliente!
Per usare un counter :!
#include "counter.h"
int main(){
counter c1, c2;
reset(&c1); reset(&c2);
inc(&c1); inc(&c2); inc(&c2);
c1++;
}
16
16
Programmazione Orientata agli Oggetti
(OOP)
•  Astrazione: separazione fra interfaccia e implementazione
•  Incapsulamento: insieme di meccanismi che consentono di
proteggere lo stato di un oggetto e in generale di
nascondere gli aspetti che non si vogliono rendere pubblici
–  Linguaggi object-based
17
OOP e Java – l’ADT Counter
public class Counter {
private int x;
public void reset() { x = 0; }
public void inc()
{ x++; }
public int getValue() { return x;}
}
Counter Y;
Y = new Counter();
Y.reset();
Y.inc();
18
OOP e Java
public class Counter {
private int x;
public void reset() { x = 0; }
public void inc()
{ x++; }
public int getValue() { return x;}
}
Counter Y;
Y = new Counter();
Y.reset();
Y.inc();
19
Programmazione Orientata agli Oggetti
(OOP)
•  Astrazione: separazione fra interfaccia e implementazione
•  Incapsulamento: insieme di meccanismi che consentono di
proteggere lo stato di un oggetto e in generale di
nascondere gli aspetti che non si vogliono rendere pubblici
–  Linguaggi object-based
•  Ereditarietà: consente di creare un componente (classe)
che riusa metodi e attributi di un componente (classe) già
esistente
–  Linguaggi object-oriented
public class BiCounter extends Counter {
public void dec()
{ x--; }
}
20
Ereditarietà
public class Counter {
private int x;
public void reset() { x = 0; }
public void inc()
{ x++; }
public int getValue() { return x;}
}
public class BiCounter extends Counter {
public void dec()
{ x--; } }
BiCounter Y; Y = new BiCounter();
Y.reset(); Y.inc(); Y.dec();
21