In questa lezione iniziamo a descrive in modo più dettagliato l'architettura delle applicazioni software ad oggetti.

Nella lezione precedente abbiamo visto che oggi le applicazioni software sono insiemi di componenti che collaborano tra loro per per soddisfare le specifiche funzionali richieste.

Gli oggetti che compongono le applicazioni sono di tre tipi:

1) MODEL - Contengono dati (sono entità).
2) VIEW - Hanno il compito di permettere la visualizzazione oppure l'inserimento dei dati negli oggetti di tipo MODE, ad esempio in un'applicazione Web corrispondono alle Pagine HTML, mentre in un'applicazione Desktop corrispondono alle interfacce grafiche (GUI).
3) CONTROLLER, che hanno il compito di gestire il flusso logico applicativo. Un controller può svolgere anche il ruolo di servizio, mettendo a disposizione dell'applicazioni in cui è presente, funzionalità oppure azioni specifiche, che si possono richiamare attraverso i metodi dell'interfaccia esposta.

I simboli UML (Unified Modeling Language) che si usano per indicare i tre tipi di oggetti utilizzati per creare le applicazioni software, sono i seguenti:

Il diagramma UML che descrive l'architettura di un'applicazione software si chiama "Diagramma dei Componeti".

Diagramma dei componenti che descrive il processo di login di un'applicazione.

COME SI CREANO I COMPONENTI DELLE APPLICAZIONI
I componenti delle applicazione software si creano con i linguaggi di programmazione ad oggetti, questi linguaggi si differenziano da quelli procedurali o funzionali perché si basano prevalentemente sull'uso di classi ed oggetti e permettono d'implemetare i seguenti paradigmi di programmazione:

1) Incapsulamento;

2) Polimorfismo di metodi ed oggetti;

3) Ereditarietà.

I principali linguaggi di programmazione ad oggetti sono:

1) C++ (pronuncia: c plus plus);

2) Java (pronuncia: giava);

3) C# (pronuncia: c sharp);

4) Python (pronuncia: paiton).

Per i nostri esempi useremo il C++ il linguaggio di programmazione ad oggetti più insegnato nelle scuole superiori.

CLASSI ED OGGETTI
Le Classi  sono template creati dai programmatori, con i linguaggi di programmazione ad oggetti, servono per creare gli oggetti.
L'esempio seguente mostra una classe scritta in C++, che definisce il template di un oggetto di tipo Persona:

class Persona {
    private:
    string nome;
    string cognome;
    int eta;
    public:
    void setNome(string nome){
            this->nome=nome;
        };
    void setCognome(string cognome){
            this->cognome=cognome;
        };
    void setEta(int eta){
            this->eta=eta;
        };
     string getNome(){
            return this->nome;
        }
     string getCognome(){
            return this->cognome;
        }
    int getEta(){
            return this->eta;
        }
    Persona(){};
    Persona(string nome, string cognome, int eta){
            this->nome=nome;
            this->cognome=cognome;
            this->eta=eta;
        }
};

<Per approfondire la conoscenza del linguaggio C clicca qui.>

Gli Oggeti sono istanze delle Classi, istanziare significa creare un oggetto in memoria utlizzando la classe corrispondente.
Con la stessa classe si possono creare tanti oggetti dello stesso tipo.

L'esempio seguente mostra come s'istanzia l'oggetto persona di tipo Persona:

Attenzione *persona diventerà il puntatore che conterrà l'indirizzo dove è stato allocato l'oggetto costruito con il comando new.

I metodi e gli attributi degli oggetti istanziati possono essere usati associando il nome dell'oggetto all'elemento che si vuole usare con il simbolo ->, come mostra l'esempio seguente:

persona->setNome("Mario");
persona->setCognome("Rossi");
persona->setEta(35);

Le Classi definiscono il tipo di oggetto che state usando nell'applicazione, in fase di progettazione per disegnare una classe con il linguaggio UML (Unified Modeling Language) dovete usare un "Diagramma di Classe".

L'esempio seguente mostra il diagramma di classe dell'oggetto persona:

Per convenzione i nomi delle Classi iniziano sempre con la lettera maiuscola, se sono composti da più parole, devono iniziare tutte con la lettera maiuscola.
I nomi degli Oggetti  sono sempre scritti in minuscolo, se sono composti da più parole, le altre parole devono iniziare con la lettera maiuscola.

Gli Oggetti sono  Componenti  che contengono i seguenti elementi:

- attributi
- metodi
- costruttori

I programmatori per capire come sono fatti i componenti di un'applicazione e qual è il loro stato, devono leggere rispettivamente il  "Diagrammi di Classe" e il "Diagrammi degli Oggetti".

Nell'esempio seguente, il "Diagramma di componete" a sinistra, indica che il componete applicativo persona è un MODEL.
Il "Diagramma di Classe" al centro ne descrive la struttura  ed il tipo, infatti corrisponde alla classe Persona.
Il "Diagramma di Oggetto" a destra ne descrive lo stato in memoria dopo che è stato istanziato (creato), il Titolo del diagramma: persona:Persona indica rispettivamente il nome dell'oggetto e la classe corrispondente, cioè il tipo.

INCAPSULAMENTO
L'Incapsulamento è una proprietà dei linguaggi di programmazione ad oggetti, permette di utilizzare dei modificatori di accesso per regolare la visibilità degli elementi di una classe (attributi, metodi e costruttori), verso i metodi di altre classi che vogliono usarli.

I modificatori di accesso più usati sono:

1) public (in un diagramma UML corrisponde al segno +);

2) private (in un diagramma UML corrisponde al segno -);

3) prrotected (in un diagramma UML corrisponde al segno #), si comporta come private in caso d'istanza, come public in caso di ereditarietà, come vedremo nelle prossime lezioni;

ATTRIBUTI
Gli Attributi sono variabili che contengono informazioni, si possono definire le proprietà dell'oggetto. Ad esempio nei MODEL, gli attributi si usano per memorizzare i dati delle entità corrispondenti, come mostra l'esempio seguente:

persona->nome="Mario";
persona->cognome="Rossi";
persona->eta=30;

persona contiene l'indirizzo dell'oggetto a cui facciamo riferimento;
nome è un attributo dell'oggetto.

Gli Attributi  possono essere usati direttamente, come nell'esempio, da metodi di altre classi, solo se sono pubblici (+), se gli Attributi in una classe sono privati (-)  sono visibili solo ai metodi della stessa classe.

Quindi l'unico modo per gestire gli  Attributi privati di una classe è quello di usare i Metodi ed i Costruttori pubblici presenti nella stessa classe.

METODI
I Metodi sono funzioni che eseguono operazioni, le azioni dei Metodi determinano il comportamento ed il ruolo dell'oggetto.
I linguaggi di programmazione ad oggetti, permettono di scrivere le istruzioni necessarie per implementare la logica delle applicazioni, unicamente all'interno dei Metodi.

I  Metodi che hanno il nome che inizia con i prefissi get e set si usano per assegnare o leggere i valori degli Attributi privati dell'oggetto a cui appartengono. 
Ad esempio,  dato che gli  Attributi della clappe  Persona sono privati, per gestirli sono stati creati i seguenti Metodi pubblici:

- setNome
- getNome
- setCognome
- getCognome
- setEta
- getEta 

Nell'esempio seguente vediamo come si possono assegnare i valori agli  Attributi privati dell'oggetto  persona usando i  Metodi  set corrispondenti:

persona->setNome("Mario");
persona->setCognome("Rossi");
persona->setEta(30);

Mentre nel prossimo esempio vediamo come si possono leggere i valori degli  Attributi privati dell'oggetto  persona usando i  Metodi  get corrispondenti:

String nome = persona->getNome();
String cognome = persona->getCognome();
int eta = persona->getEta();

I Metodi se sono pubblici possono essere eseguiti anche dai Metodi di altri oggetti, se sono privati possono essere eseguiti solo dai Metodi dello stesso oggetto, perché non sono visibili a metodi di altre classi.
 

OVERLOAD
I'Overload insieme all'Override può essere definito polimorfismo dei metodi, è una prorpietà dei linguaggi di programmazione ad oggetti che permette di usare metodi con lo stesso nome, ma firma diversa, all'interno della stessa classe.
La firma di un metodo è composta dal nome del metodo più i tipi degli argomenti passati al metodo, come mostra l'immagine seguente:

Vediamo un esempio di Overload in C++:

Immaginate di voler colorare una figura geometrica, dando la possibilità al programmatore di usare le seguenti modalità d'impostazione del colore:

1) fornire direttamente il nome del colore da assegnare alla figura geometrica sotto forma di stringa;

2) indicare il colore da assegnare alla figura geometrica con un numero intero;

3) fornire i codici RGB del colore da assegnare alla figura geometrica.

Per evitare di assegnare nomi diversi ai metodi per colorare la figura geometrica,  dato che per ogni modalità d'impostazione del colore si usano tipi sono diversi, possiamo usare l'Overload.

class ColoraFiguraGeometrica{
// Attributi privati non visibli a metodi di altre classi classi
private:
string tipoFigura;
string coloreFigura;
// Metodi pubblici visibli a metodi di altre classi classi
public:
// Restituisce il tipo di figura geometrica
string getTipoFigura(){
return this->tipoFigura;
}
// Restituisce il colore della figura geometrica
string getColoreFigura(){
return this->coloreFigura;
}
// 1-Overload Firma = setColore string
void setColore(string colore){
    this->coloreFigura=colore;
}
// 2-Overload Firma = setColore int
void setColore(int colore){
    switch(colore){
    case 1:
         this->coloreFigura="Rosso";
         break;
    case 2:
         this->coloreFigura="Verde";
         break;
    case 3:
         this->coloreFigura="Giallo";
         break;
    default:
         this->coloreFigura="Nero";
         break;
    }
}
// 3-Overload Firma = setColore int int int
void setColore(int r,int g, int b){
        stringstream sr;
        stringstream sg;
        stringstream sb;
        sr << r;
        sg << g;
        sb << b;
        this->coloreFigura="R="+sr.str()+", G="+sg.str()+"B="+sb.str();
}
// Costruttore parametrizzato usato per indicare il tipo di figura geometrica
ColoraFiguraGeometrica(string tipoFigura){
      this->tipoFigura=tipoFigura;
}
};

<Per approfondire la conoscenza del linguaggio C clicca qui.>

COSTRUTTORI
I Costruttori sono Metodi che si usano per istanziare gli oggetti, vanno sempre indicati dopo il comando new usato per creare un oggetto, come mostra l'esempio seguente:

I Costruttori servono per inizializzare gli Attributi degli oggetti istanziati.

Ci sono due tipi costruttori, quello di base, senza parametri e quello parametrizzato, usato per inizializzare gli Attributi dell'oggetto con valori esterni, si riconoscono perché hanno lo stesso nome della Calsse e nella loro dichiarazione non è indicato il tipo restituito,

I Costruttori sono sempre pubblici, solo gli oggetti di tipo Singletone, particolari oggetti che possono essere istanziati una sola volta, hanno il costruttore privato.
 

COMUNICAZIONE E COLLABORAZIONE TRA COMPONENTI
Gli elementi pubblici di un oggetto rappresentano la sua Interfaccia. Come avviene anche per i componenti elettronici, l'Interfaccia viene usata per permettere la comunicazione con gli altri componenti.

Ad esempio l'Interfaccia dell'oggetto persona è la seguente:

- setNome
- getNome
- setCognome
- getCognome
- setEta
- getEta 

Gli attributi dell'oggetto persona non sono visibili, perche sono privati, quindi non appartengono all'interfaccia.

I Metodi degli oggetti che devono gestire l'oggetto persona lo fanno attraverso la sua interfaccia, come mostra Il "Diagramma dei Componeti" seguente:

Il simbolo usato in UML per rappresentare un'interfaccia è il lecca lecca (lollipop).

Quindi il metodo  di un componente applicativo (oggetto), per comunicare e  collaborare con un altro componente, usando i metodi e gli attributi pubblici della sua interfaccia, lo deve prima istanziare con il comando new, successivamente usando il riferimento del componente creato, può usare tutti gli elementi della  sua interfaccia.

In pratica il riferimento contiene l'indirizzo dell'oggetto che espone l'interfaccia, come mostra l'immagine seguente:

L'APPLICAZIONE GESTIONE PERSONE
Adesso vediamo quali sono i passaggi fondamentali per creare un'applicazione che permette di gestire persone.

Prima di tutto disegniamo il diagramma UML che mostra i principali  componenti applicativi e in che modo collaborano tra loro:

                                                            Figura 1

Analizzado i componenti del diagramma in Figura 1, vediamo che il componente gestionePersone, ha il ruolo di controller. Questo oggetto attraverso l'uso di due view:  inserimeto_persona e visualizza_persona, permette di gestire i componenti persona,  che hanno  il ruolo di model.

Il Diagramma di Classi seguente, mostra la struttura degli oggetti che compongono l'applicazione Gestione Persone.

COME SI GESTISCE IL FLISSO LOGICO (PROCESSO) DELL'APPLICAZIONE GESTIONE PERSONE
Il metodo main() della classe GestionePersone , il controller, permette d'implementare il flusso logico dell'applicazione per gestire le persone.

Per fare questo lavoro, il metodo main()  esegue le seguenti operazioni:

1) usa il metodo inserimentoPersona() per  permette l'inserimento dei dati attraverso la maschera "Inserimento Persona" (Figura 2);

                                              Figura 2

2) usa i metodi set dell'intercaccia dell'oggetto persona:

persona->setNome(nome);
persona>setCognome(cognome);
persona->setEta(eta);

per memorizza i dati inseriti della maschera all'interno dell'oggetto persona;

3) usa Il metdo visualizzaPersona(persona:Persona) per visualizzare attraverso la maschera "Visualizza Persona" (Figura 3) il contenuto dell'oggeto persona.
Questo metodo usa i metodi get dell'intercaccia dell'oggetto persona:

persona->getNome();
persona>getCognome();
persona->getEta();

per leggere i dati memorizzati negli attributi dell'oggetto persona e visualizzarli nella maschera.

                                              Figura 3

Il Diagramme delle Attività in Figura 4, mostra il flusso delle attività svolte dal metodo  inserimentoPersona() per gestire l'inserimento dei dati nell'oggetto persona:

                                      Figura 4

Nella prossima lezione parleremo di Ereditarietà, per riusare e specializzare classi già esistenti.

<< Lezione precedente           Lezione successiva >>

Laboratori di Logica di Programmazione in C