TypeScript - Lezione 7: Paradigma Object Oriented (seconda parte)

- AULE GRUPPI
- Le Tue Aule
- I Tuoi Gruppi
- Le Tue Selezioni
- Home
- Login
- Registrati
- Crea azienda
- Assistenza

Lista Blog

Chat

www.skillfactory.it

segreteria@skillfactory.it

08118181361

3270870141

Richiedi informazioni

Skill Factory

Lista post > TypeScript - Lezione 7: Paradigma Object Oriented (seconda parte)

TypeScript - Lezione 7: Paradigma Object Oriented (seconda parte)

Gino Visciano | Skill Factory - 07/08/2020 22:54:12 | in Tutorials

Nella lezione precedente abbiamo introdotto il "Paradigma Object Oriented", descrivendo le seguenti proprietà di programmazione:

1) Incapsulamento;
2) Ereditarietà;
3) Polimorfismo dei metodi.

In questa lezione completiamo le proprietà di programmazione parlando di "Polimorfismo degli oggetti", la proprietà che ci permette di sfruttare le potenzialità offerte dall'Upcasting, successivamente vediamo le proprietà architetturali per creare applicazioni riusabili , scalabili e manutenibili.

POLIMORFISMO DEGLI OGGETTI

Gli oggetti sono Polimorfi se sono simili, due oggetti possono diventare simili per ereditarietà oppure se implementano la stessa interfaccia.

Il Diagramma di classe seguente descrive un esempio di polimorfismo per erditarietà:

La classe Dirigente è la più specializzata, perché contiene maggiori responsabilità e caratteristiche, quindi è più dettagliata, mentre la classe Object è la più generica.

Tutti gli oggetti istanziati con uno dei tipi indicati nel diagramma sono simili, perché appartengono alla stessa gerarchia di ereditarietà.

Quando gli oggetti sono simili è possibile applicare l'upcasting, che permette di assegnare ad una variabile di tipo più generico il riferimento di un oggetto più dettagliato, come mostra l'esempio seguente:

var persona:Persona; // Variabile più generica di tipo Persona
persona=new Dipendente() // Upcasting. Il riferimento dell'oggetto di tipo Dipendente, più dettagliato, viene assegnato ad una variabile più generica di tpo Persona

L'Upcasting è utile perché con questa tecnica è possibile passare alla stesso metodo oggetti di tipo diverso, purché simili tra loro, come mostra l'esempio seguente:

Esempio 1

 
class Persona{
    private id:number;
    private nome:string;
    private cognome:string;
    private dataDiNascita:Date;
    private luogoDiNascita:string;
    private sesso:string;
    public setId(id:number):void{
        this.id=id;
    }
    public getId():number{
        return this.id;
    }
    public setNome(nome:string):void{
        this.nome=nome;
    }
    public getNome():string{
        return this.nome;
    }
    public setCognome(cognome:string):void{
        this.cognome=cognome;
    }
    public getCognome(){
        return this.cognome;
    }
    public setDataDiNascita(dataDiNascita:Date):void{
        this.dataDiNascita=dataDiNascita;
    }
    public getDataDiNascita():Date{
        return this.dataDiNascita;
    }
    public setLuogDiNascita(luogoDiNascita:string):void{
        this.luogoDiNascita=luogoDiNascita;
    }
    public getLuogoDiNascita():string{
        return this.luogoDiNascita;
    }
    public setSesso(sesso:string):void{
        this.sesso=sesso;
    }
    public getSesso():string{
        return this.sesso;
    }
    public toString():string{
        let options: Intl.DateTimeFormatOptions = {
            day: "numeric", month: "numeric", year: "numeric"
        };
           return this.id+","+this.nome+","+this.cognome+","+this.dataDiNascita.toLocaleDateString("en-GB", options)+","+this.luogoDiNascita+","+this.sesso;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
        // Sovraccarico del costruttore
        public constructor();
        public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string);
        public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string){
            this.id=id;
            this.nome=nome;
            this.cognome=cognome;
            this.dataDiNascita=dataDinascita;
            this.luogoDiNascita=luogoDiNascita;
            this.sesso=sesso;
        }    
}
class Dipendente extends Persona {
    private ruolo:string;
    private stipendio:number;
    public setRuolo(ruolo:string):void{
        this.ruolo=ruolo;
    }
    public getRuolo():string{
        return this.ruolo;
    }
    public setStipendio(stipendio:number):void{
        this.stipendio=stipendio;
    }
    public getStipendio():number{
        return this.stipendio;
    }
    public toString():string{
        return super.toString()+","+this.ruolo+","+this.stipendio;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
            // Sovraccarico del costruttore
            public constructor();
            public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string,ruolo:string,stipendo:number);
            public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,ruolo?:string,stipendo?:number){
                super(id,nome,cognome,dataDinascita,luogoDiNascita,sesso); 
                this.ruolo=ruolo;
                this.stipendio=stipendo;
            }      
}
class Vista {
public stampa(persona:Persona){
    console.log(persona.toString())
    }    
public stampaScheda(persona:Persona){
    let options: Intl.DateTimeFormatOptions = {
        day: "numeric", month: "numeric", year: "numeric"
    };
    console.log("Id:"+persona.getId());
    console.log("Nome:"+persona.getNome());
    console.log("Cognome:"+persona.getCognome());
    console.log("Data di nascita:"+persona.getDataDiNascita().toLocaleDateString("en-GB", options));
    console.log("Luogo di nascita:"+persona.getLuogoDiNascita());
    console.log("Sesso:"+persona.getSesso());
    // Se la variabile persona è un riferimento di tipo dipendente visualizza anche ruolo e stipendio
    if(persona instanceof Dipendente){
        console.log("Ruolo:"+persona.getRuolo());
        console.log("Stipendio:"+persona.getStipendio());
    }
    }
}
// Istanza di un oggetto di tipo Vista (view), per stampare gli oggetti simili di tipo Persona e Dipendente (model) 
var vista=new Vista();
// Istanzio due oggetti di tipo Persona (model)
var personaUno=new Persona();
var personaDue=new Persona(2,"Carla","Verdi",new Date("10/05/1992"),"Milano","F");
// Istanzio due oggetti di tipo Dipendente (model)
var dipendenteUno=new Dipendente();
var dipendenteDue=new Dipendente(4,"Paolo","Formisano",new Date("09/02/1970"),"Potenza","M","Commerciale",1800.00);
personaUno.setId(1);
personaUno.setNome("Roberta");
personaUno.setCognome("Bianchi");
personaUno.setDataDiNascita(new Date("09/07/2000"));
personaUno.setLuogDiNascita("Firenze");
personaUno.setSesso("F");
dipendenteUno.setId(3);
dipendenteUno.setNome("Michele");
dipendenteUno.setCognome("Rossi");
dipendenteUno.setDataDiNascita(new Date("08/03/1980"));
dipendenteUno.setLuogDiNascita("Torino");
dipendenteUno.setSesso("M");
dipendenteUno.setRuolo("Project Managaer");
dipendenteUno.setStipendio(1500.00);
console.log("------ Persone stampa orizzontale ------")
vista.stampa(personaUno);
console.log("---------------------------------------")
vista.stampa(personaDue);
console.log("\n------ Dipendenti stampa orizzontale ------")
vista.stampa(dipendenteUno);
console.log("--------------------------------------")
vista.stampa(dipendenteDue);
console.log("\n------ Persone stampa scheda ------")
vista.stampaScheda(personaUno);
console.log("--------------------------------")
vista.stampaScheda(personaDue);
console.log("\n------ Dipendenti stampa scheda ------")
vista.stampaScheda(dipendenteUno);
console.log("--------------------------------")
vista.stampaScheda(dipendenteDue);
 
---------------------------------------------------------------------------------------
------ Persone stampa orizzontale ------

1,Roberta,Bianchi,9/7/2000,Firenze,F

---------------------------------------

2,Carla,Verdi,10/5/1992,Milano,F
------ Dipendenti stampa orizzontale ------

3,Michele,Rossi,8/3/1980,Torino,M,Project Managaer,1500

--------------------------------------

4,Paolo,Formisano,9/2/1970,Potenza,M,Commerciale,1800
------ Persone stampa scheda ------

Id:1

Nome:Roberta

Cognome:Bianchi

Data di nascita:9/7/2000

Luogo di nascita:Firenze

Sesso:F

--------------------------------

Id:2

Nome:Carla

Cognome:Verdi

Data di nascita:10/5/1992

Luogo di nascita:Milano

Sesso:F
------ Dipendenti stampa scheda ------

Id:3

Nome:Michele

Cognome:Rossi

Data di nascita:8/3/1980

Luogo di nascita:Torino

Sesso:M

Ruolo:Project Managaer

Stipendio:1500

--------------------------------

Id:4

Nome:Paolo

Cognome:Formisano

Data di nascita:9/2/1970

Luogo di nascita:Potenza

Sesso:M

Ruolo:Commerciale

Stipendio:1800
 

Gli oggetti possono diventare simili, anche se implementano la stessa interfaccia, il Diagramma di classe seguente descrive un esempio di polimorfismo per interfaccia:

In questo caso l'Upcasting si può applicare utilizzando come tipo l'interfaccia, come mostra l'esempio seguente:

var cerchio:IFiguraGeometrica;
var rettangolo:IFiguraGeometrica;
cerchio=new Cerchio();
rettangolo=new Rettangolo();

Esempio 2

//geometria.ts
interface IFiguraGeometrica{
    getTipoFigura():string;
    getPerimetro():number;
    getArea():number;
}
class Cerchio implements IFiguraGeometrica{
    public constructor(private raggio:number){}
    public getTipoFigura():string{
        return "Cerchio";
    }
    public getPerimetro(): number {
        return 2*Math.PI*this.raggio;
    }
    public getArea(): number {
        return Math.pow(this.raggio,2)*Math.PI;
    }
}
class Quadrato implements IFiguraGeometrica{
    public constructor(private latoA:number){}
    public getTipoFigura():string{
        return "Quadrato";
    }
    public getPerimetro(): number {
        return 4*this.latoA;
    }
    public getArea(): number {
        return Math.pow(this.latoA,2);
    }
}
class Rettangolo implements IFiguraGeometrica{
    public constructor(private latoA:number,private latoB:number){}
    public getTipoFigura():string{
        return "Rettangolo";
    }
    public getPerimetro(): number {
        return (2*this.latoA)+(2*this.latoB);
    }
    public getArea(): number {
        return this.latoA*this.latoB;
    }
}
class Triangolo implements IFiguraGeometrica{
    public constructor(private latoA:number,private latoB:number,private latoC:number){}
    public getTipoFigura():string{
        return "Triangolo";
    }
    public getPerimetro(): number {
        return this.latoA+this.latoB+this.latoC;
    }
    public getArea(): number {
        let sp=this.getPerimetro()/2;
        let area=Math.sqrt(sp*(sp-this.latoA)*(sp-this.latoB)*(sp-this.latoC))
        return area;
    }
}
class Geometria {
    private figureGeometriche:IFiguraGeometrica[]=[]
    public add(figuraGeometrica:IFiguraGeometrica):void{
        this.figureGeometriche.push(figuraGeometrica);
    }
    public stampa(){
        this.figureGeometriche.forEach(figuraGeometrica =>{
            console.log("Tipo figura:"+figuraGeometrica.getTipoFigura());
            console.log("Perimetro  :"+figuraGeometrica.getPerimetro());
            console.log("Area       :"+figuraGeometrica.getArea());
        })
    }
}
class Main{
public static main():void{
    var cerchio:IFiguraGeometrica=new Cerchio(10);
    var quadrato:IFiguraGeometrica=new Quadrato(20);
    var rettangolo:IFiguraGeometrica=new Rettangolo(10,20);
    var triangolo:IFiguraGeometrica=new Triangolo(5,10,10);
    var geometria:Geometria=new Geometria();
    geometria.add(cerchio);
    geometria.add(quadrato);
    geometria.add(rettangolo);
    geometria.add(triangolo);
    geometria.stampa();
}    
}    
//Main
Main.main();
-----------------------------------------------------------------------


Tipo figura:Cerchio

Perimetro  :62.83185307179586

Area       :314.1592653589793

Tipo figura:Quadrato

Perimetro  :80

Area       :400

Tipo figura:Rettangolo

Perimetro  :60

Area       :200

Tipo figura:Triangolo

Perimetro  :25

Area       :24.206145913796355
 

PROPRIETA' ARCHITETTURALI DEL PARADIGMA OBJECT ORIENTED

Le proprietà Architetturali del paradigma object oriented caratterizzano l'organizzazione strutturale di un'applicazione software.
Le proprietà architetturali incidono sulla qualità delle applicazioni, come ad esempio le prestazioni, la scalabilità, la disponibilità la riusabilità e la modificabilità.

COESIONE

Le classi sono Coese se sono disegnate per offrire una soluzione specifica, come ad esempio avviene per i servizi che mettono a disposizione funzioni che risolvono problemi di un particolare dominio applicativo.

Il pattern MVC (Model View Controller), favorisce il disegno di classi coese, perché permette di distinguere le classi in base al ruolo che devono avere all'interno dell'applicazione.

Se più classi hanno responsabilità (metodi) e caratteristiche (attributi) comuni, probabilmente bisogna creare una nuova classe che le contiene tutte.

Un bravo programmatore ad oggetti, quando sviluppa un'applicazione, rispetta sempre questa regola:

"Metti il codice dove gli altri si aspettano di trovarlo" .

Le classi di tipo model sono coese, perché tutti i loro metodi interni servono per gestire gli attributi privati, non accessibili ai metodi di altre classi.

 
class Persona{
    private id:number;
    private nome:string;
    private cognome:string;
    private dataDiNascita:Date;
    private luogoDiNascita:string;
    private sesso:string;
    public setId(id:number):void{
        this.id=id;
    }
    public getId():number{
        return this.id;
    }
    public setNome(nome:string):void{
        this.nome=nome;
    }
    public getNome():string{
        return this.nome;
    }
    public setCognome(cognome:string):void{
        this.cognome=cognome;
    }
    public getCognome(){
        return this.cognome;
    }
    public setDataDiNascita(dataDiNascita:Date):void{
        this.dataDiNascita=dataDiNascita;
    }
    public getDataDiNascita():Date{
        return this.dataDiNascita;
    }
    public setLuogDiNascita(luogoDiNascita:string):void{
        this.luogoDiNascita=luogoDiNascita;
    }
    public getLuogoDiNascita():string{
        return this.luogoDiNascita;
    }
    public setSesso(sesso:string):void{
        this.sesso=sesso;
    }
    public getSesso():string{
        return this.sesso;
    }
    public toString():string{
        let options: Intl.DateTimeFormatOptions = {
            day: "numeric", month: "numeric", year: "numeric"
        };
           return this.id+","+this.nome+","+this.cognome+","+this.dataDiNascita.toLocaleDateString("en-GB", options)+","+this.luogoDiNascita+","+this.sesso;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
        // Sovraccarico del costruttore
        public constructor();
        public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string);
        public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string){
            this.id=id;
            this.nome=nome;
            this.cognome=cognome;
            this.dataDiNascita=dataDinascita;
            this.luogoDiNascita=luogoDiNascita;
            this.sesso=sesso;
        }    
}
 

Un altro esempio di classi coese, sono quelle di tipo CRUD, specializzate per gestire la persistenza delle classi di tipo model.

Una classe CRUD può essere considerata un servizio.

 
 
interface IPersonaCRUD{
    inserisci(persona:Persona):boolean;
    modifica(indice:number,persona:Persona):boolean;
    cancella(indice:number):boolean;
    leggi(indice:number):Persona;
    leggi():Persona[];
}
export class PersonaCRUD implements IPersonaCRUD{
    private persone:Persona[];
    inserisci(persona: Persona): boolean {
       this.persone.push(persona);
       return true;
    }
    modifica(indice:number, persona: Persona): boolean {
        this.persone[indice]=persona;
        return true;
    }
    cancella(indice: number): boolean {
        this.persone.splice(indice,1);
        return true;  
    }
    // Overload (polimorfismo dei metodi)
    leggi(indice: number): Persona;
    leggi(): Persona[];
    leggi(indice?: number): Persona | Persona[] {
        if (arguments.length==1){
            return this.persone[indice];
        } else{
        return this.persone;
        }
    }
}
 

Anche la classe di utilità Math è coesa, perché contiene tutte le funzionalità richieste per gestire operazioni di matematica, di seguito elenchiamo quelle più importanti:

// matematica.ts
class OperazioniMatematiche{
    public static main():void{
        var numeri:number[]=[10,30,20,5,40];
        console.log("Pi greco:"+Math.PI);
        console.log("Arrotonda per eccesso:"+Math.ceil(Math.PI));
        console.log("Arrotonda per difetto:"+Math.round(Math.PI));
        console.log("Valore assoluto di -10:"+Math.abs(-10));
        console.log("Potenza di 5^2:"+Math.pow(5,2));
        console.log("Radice quadrata di 25:"+Math.sqrt(25));
        console.log("Valore massimo di :"+numeri+" -> "+Math.max(10,30,20,5,40));
        console.log("Valore minimo di :"+numeri+" -> "+Math.min(10,30,20,5,40));
        console.log("Valore casuale da 1 a 100:"+Math.ceil(Math.random()*100));
    }
}
OperazioniMatematiche.main();
-----------------------------------------------------------------------------------
Pi greco:3.141592653589793

Arrotonda per eccesso:4

Arrotonda per difetto:3

Valore assoluto di -10:10

Potenza di 5^2:25

Radice quadrata di 25:5

Valore massimo di :10,30,20,5,40 -> 40

Valore minimo di :10,30,20,5,40 -> 5

Valore casuale da 1 a 100:63
 

DISACCOPPIAMENTO

Per Accoppiamento s'intendono i legami (relazioni di dipendenza) esistenti tra classi diverse della stessa applicazione.
Minore è il livello di accoppiamento tra le classi e maggiore è la manutenibilità del software, perché oltre a favorire la leggibilità del codice, eventuali modifiche ad una classe hanno basse ripercussioni sulle altre classi.

Si crea un accoppiamento forte tra due classi tutte le volte che un metodo di una classe Client, istanzia un oggetto per usare i metodi oppure gli attributi pubblici di una classe Server, come mostra il diagramma seguente:

L'accoppiamento è debole se il metodo della classe Client riceve come argomento il riferimento della classe Server senza istanziare un oggetto di tipo Server.

Esempio 3

Una classe Persona ha un attributo di tipo Indirizzo, composto dal nome della strada, il cap, la città e la provincia.
Per creare l'attributo di tipo Indirizzo nella classe Persona utilizziamo la classe seguente:

 
//indirizzo.ts
export class Indirizzo {
    private nomeStrada:string;
    private cap:string;
    private citta:string
    private provincia:string;
    public getNomeStrada():string{
        return this.nomeStrada;
    }
    public setNome(nomeStrada:string):void{
        this.nomeStrada=nomeStrada;
    }
    public getCap():string{
        return this.cap;
    }
    public setCap(cap:string):void{
        this.cap=cap;
    }
    public getCitta():string{
        return this.citta;
    }
    public setCitta(citta:string):void{
        this.citta=citta;
    }    
    public getProvincia():string{
        return this.provincia;
    }
    public setProvincia(provincia:string):void{
        this.provincia=provincia;
    }    
    public toString():string{
        return this.nomeStrada+","+this.cap+","+this.citta+","+this.provincia;
    }
    public constructor();
    public constructor(nomeStrada:string,cap:string,citta:string,provincia:string);
    public constructor(nomeStrada?:string,cap?:string,citta?:string,provincia?:string){
        this.nomeStrada=nomeStrada;
        this.cap=cap;
        this.citta=citta;
        this.provincia=provincia;    
    }
}
 

In questo esempio per creare l'attributo di tipo Indirizzo nella classe Persona, stiamo creando un accoppiamento tra la due classi.

A seconda di come viene impostato il metodo setIndirizzo ed il costruttore della classe Persona, l'accoppiamento diventa alto (forte) oppure basso (debole).

A) Accoppiamento alto

 
//persona_con_indirizzo_accoppiamento_alto.ts
import {Indirizzo} from './indirizzo'
export class Persona{
    private id:number;
    private nome:string;
    private cognome:string;
    private dataDiNascita:Date;
    private luogoDiNascita:string;
    private sesso:string;
    private codiceFiscale:string;
    private indirizzo:Indirizzo=new Indirizzo();
    public setId(id:number):void{
        this.id=id;
    }
    public getId():number{
        return this.id;
    }
    public setNome(nome:string):void{
        this.nome=nome;
    }
    public getNome():string{
        return this.nome;
    }
    public setCognome(cognome:string):void{
        this.cognome=cognome;
    }
    public getCognome(){
        return this.cognome;
    }
    public setDataDiNascita(dataDiNascita:Date):void{
        this.dataDiNascita=dataDiNascita;
    }
    public getDataDiNascita():Date{
        return this.dataDiNascita;
    }
    public setLuogDiNascita(luogoDiNascita:string):void{
        this.luogoDiNascita=luogoDiNascita;
    }
    public getluogoDiNascita():string{
        return this.luogoDiNascita;
    }
    public setSesso(sesso:string):void{
        this.sesso=sesso;
    }
    public getSesso():string{
        return this.sesso;
    }
    public getCodiceFiscale():string{
        return this.codiceFiscale;
    }
    public setCodiceFiscale(codiceFiscale:string):void{
        this.sesso=codiceFiscale;
    }
    public setIndirizzo(nomeStrada:string,cap:string,citta:string,provincia:string){
        this.indirizzo.setNomeStrada(nomeStrada);
        this.indirizzo.setCap(cap);
        this.indirizzo.setCitta(citta);
        this.indirizzo.setProvincia(provincia);
    }
    public getIndirizzo():Indirizzo{
           return this.indirizzo;
    }
    public toString():string{
        let options: Intl.DateTimeFormatOptions = {
            day: "numeric", month: "numeric", year: "numeric"
        };
           return this.id+","+this.nome+","+this.cognome+","+this.dataDiNascita.toLocaleDateString("en-GB", options)+","+this.luogoDiNascita+","+this.sesso+","+this.codiceFiscale+","+this.indirizzo;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
        // Sovraccarico del costruttore
        public constructor();
        public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string,codiceFiscale:string,nomeStrada:string,cap:string,citta:string,provincia:string);
        public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,codiceFiscale?:string,nomeStrada?:string,cap?:string,citta?:string,provincia?:string){
            if(arguments.length>0){
                this.id=id;
                this.nome=nome;
                this.cognome=cognome;
                this.dataDiNascita=dataDinascita;
                this.luogoDiNascita=luogoDiNascita;
                this.sesso=sesso;
                this.codiceFiscale=codiceFiscale;
                this.indirizzo.setNomeStrada(nomeStrada);
                this.indirizzo.setCap(cap);
                this.indirizzo.setCitta(citta);
                this.indirizzo.setProvincia(provincia);
                    }
        }    
}
 

In questo caso l'accoppiamento tra la classe Persona e la classe Indirizzo è alto, perché se si modificano gli attributi della classe Indirizzo, necessariamente bisogna modificare anche gli argomenti del metodo setIndirizzo ed del costruttore della classe Persona.

private indirizzo:Indirizzo=new Indirizzo();
...
public setIndirizzo(nomeStrada:string,cap:string,citta:string,provincia:string){
this.indirizzo.setNomeStrada(nomeStrada);
this.indirizzo.setCap(cap);
this.indirizzo.setCitta(citta);
this.indirizzo.setProvincia(provincia);
}
...
public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,codiceFiscale?:string,nomeStrada?:string,cap?:string,citta?:string,provincia?:string){
if(arguments.length>0){
this.id=id;
this.nome=nome;
this.cognome=cognome;
this.dataDiNascita=dataDinascita;
this.luogoDiNascita=luogoDiNascita;
this.sesso=sesso;
this.codiceFiscale=codiceFiscale;
this.indirizzo.setNomeStrada(nomeStrada);
this.indirizzo.setCap(cap);
this.indirizzo.setCitta(citta);
this.indirizzo.setProvincia(provincia);
}
}

B) Accoppiamento basso

 
//persona_con_indirizzo_accoppiamento_basso.ts
import {Indirizzo} from './indirizzo'
export class Persona{
    private id:number;
    private nome:string;
    private cognome:string;
    private dataDiNascita:Date;
    private luogoDiNascita:string;
    private sesso:string;
    private codiceFiscale:string;
    private indirizzo:Indirizzo;
    public setId(id:number):void{
        this.id=id;
    }
    public getId():number{
        return this.id;
    }
    public setNome(nome:string):void{
        this.nome=nome;
    }
    public getNome():string{
        return this.nome;
    }
    public setCognome(cognome:string):void{
        this.cognome=cognome;
    }
    public getCognome(){
        return this.cognome;
    }
    public setDataDiNascita(dataDiNascita:Date):void{
        this.dataDiNascita=dataDiNascita;
    }
    public getDataDiNascita():Date{
        return this.dataDiNascita;
    }
    public setLuogDiNascita(luogoDiNascita:string):void{
        this.luogoDiNascita=luogoDiNascita;
    }
    public getluogoDiNascita():string{
        return this.luogoDiNascita;
    }
    public setSesso(sesso:string):void{
        this.sesso=sesso;
    }
    public getSesso():string{
        return this.sesso;
    }
    public getCodiceFiscale():string{
        return this.codiceFiscale;
    }
    public setCodiceFiscale(codiceFiscale:string):void{
        this.sesso=codiceFiscale;
    }
    public setIndirizzo(indirizzo:Indirizzo){
        this.indirizzo=indirizzo;
    }
    public getIndirizzo():Indirizzo{
           return this.indirizzo;
    }
    public toString():string{
        let options: Intl.DateTimeFormatOptions = {
            day: "numeric", month: "numeric", year: "numeric"
        };
           return this.id+","+this.nome+","+this.cognome+","+this.dataDiNascita.toLocaleDateString("en-GB", options)+","+this.luogoDiNascita+","+this.sesso+","+this.codiceFiscale+","+this.indirizzo;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
        // Sovraccarico del costruttore
        public constructor();
        public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string,codiceFiscale:string,indirizzo:Indirizzo);
        public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,codiceFiscale?:string,indirizzo?:Indirizzo){
            if(arguments.length>0){
                this.id=id;
                this.nome=nome;
                this.cognome=cognome;
                this.dataDiNascita=dataDinascita;
                this.luogoDiNascita=luogoDiNascita;
                this.sesso=sesso;
                this.codiceFiscale=codiceFiscale;
                this.indirizzo=indirizzo;
            }
        }    
}
 

In questo caso l'accoppiamento tra la classe Persona e la classe Indirizzo è basso perché se si modificano gli attributi della classe Indirizzo, non bisogna modificare gli argomenti del metodo setIndirizzo e del costruttore della classe Persona, poiché contengono semplicemente il riferimento della classe indirizzo.

private indirizzo:Indirizzo;
...
public setIndirizzo(indirizzo;Indirizzo){
this.indirizzo=indirizzo;
}
...
public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,codiceFiscale?:string,indirizzo?:Indirizzo){
if(arguments.length>0){
this.id=id;
this.nome=nome;
this.cognome=cognome;
this.dataDiNascita=dataDinascita;
this.luogoDiNascita=luogoDiNascita;
this.sesso=sesso;
this.codiceFiscale=codiceFiscale;
this.indirizzo=indirizzo;
}
}

DIPENDECY INJECTION

La Dipendency Injection è una particolare forma del pattern Inversion Of Control (IoC), che rende una classe indipendente dell'inizializzazione delle proprie dipendenze.
Questa caratteristica riduce il livello di accoppiamento tra le classi ed aumenta la manutenibilità dell'applicazione.

In parole semplici, con la Dipendency Injection i metodi oppure i costruttori di una classe non istanziano gli oggetti con il comando new, ma ricevono direttamente i loro riferimento come argomento passato dal contesto applicativo.

Nella programmazione tradizionale è lo sviluppatore che si occupa di tutte le operazioni di creazione, inizializzazione ed invocazione dei metodi degli oggetti, l'IoC invece inverte il control flow facendo in modo che non sia più lo sviluppatore a doversi preoccupare di questi aspetti, ma il framework, che reagendo a qualche “stimolo” se ne occuperà per suo conto.

Se sviluppate con Java il framework più usato è SPRING, se sviluppate con TypeScript il più usato è ANGULAR.

Nella prossima lezione vedremo come manipolare gli elementi del DOM delle pagine HTML.

<< Lezione precedente | Vai alla prima lezione

T U T O R I A L S S U G G E R I T I

EDUCATIONAL GAMING BOOK (EGB) "H2O"

Nell'era dello SMART LEARNING e di PYTHON i libri non si scrivono, ma si sviluppano, in questo modo chi studia, può sperimentare ed apprendere contemporaneamente; un libro con queste caratteristiche lo possiamo definire un Educational Gaming Book (EGB).

"H2O" è un EGB che descrive tutte le caratteristiche dell'acqua, la sostanza formata da molecole di H2O, che attraverso il suo ciclo di vita garantisce la sopravvivenza di tutti gli esseri viventi del Pianeta.

L'obiettivo dell'EGB è quello di far conoscere ai giovani le proprietà dell'acqua, sotto molti aspetti uniche, per sensibilizzarli a salvaguardare un bene comune e raro, indispensabile per la vita.

Per il DOWNLOAD di "H2O" clicca qui.

2364 Visualizzazioni

TOP