Ciao.
Questa è la stanza della Lulu.
E bentornato.
Fateci sapere conoscere generici che è stato introdotto nel 5 luglio.
Abbiamo fatto uso di generici in una certa misura nel capitolo quadro delle collezioni e questo deve averti dato
una qualche forma di un'idea.
Ma ora è tempo per noi di avere una comprensione approfondita di questo argomento perché diamo un'occhiata a quali
motivati progettisti di linguaggi introducono i generici.
Ora sappiamo che il polimorfismo promuove la generalizzazione, per esempio le super classi possono essere usate come tipi polimorfi per
i parametri di metodo e di costruzione e possono anche essere usate come tipi di metodi scritti che ci
permettono di passare oggetti di sottoclasse come argomenti.
E possiamo anche restituire oggetti di sottoclasse dai metodi.
Allo stesso modo le interfacce forniscono ancor più generalizzazione in quanto possono essere implementate dalle classi da gerarchie
di classi completamente diverse.
In questo momento consideriamo questo frammento di codice qui.
Il codice categoria è denominato il nostro deposito e memorizza semplicemente un oggetto del segnalibro.
Potete vedere che c'è un setter e getter per impostare e recuperare un oggetto segnalibro e il problema qui è
che il tipo di segnalibro è hardcoded che è un'istanza di un negozio può contenere solo un oggetto segnalibro o
uno dei suoi oggetti sottotipo.
Quindi un modo per generalizzare ulteriormente è definendo il tipo come oggetto come la classe dell'oggetto è la classe e
ogni altra classe discende da essa prima di giustificare l'uso di una classe di oggetti poichè il tipo polimorfico
era un framework di raccolte molto comune avrebbe archiviato istanze di oggetti come elementi e anche come chiavi e valori nelle
mappe, ad esempio prima del file java, il metodo di aggiunta nella nostra classe lista avrebbe come parametro il metodo
ma da Java 5 in poi non è più il caso e fa uso di generici.
Ora vediamo quali problemi possiamo fare usando l'oggetto come tipo qui.
Diamo un'occhiata ad un codice che viene eseguito sequenzialmente.
Supponiamo anche che il codice sia stato scritto da due sviluppatori che lavorano per la stessa società, supponiamo che questo sia un
primo pezzo di codice che viene eseguito su supponiamo che John abbia scritto questo trimestre.
Qui sono archiviate le istanze create sotto l'oggetto Date che è memorizzato all'interno dell'istanza del negozio qui.
La data proviene dal pacchetto Java dot a school in un momento successivo nel codice in cui l'oggetto data che
è stato memorizzato all'interno dell'istanza del negozio viene recuperato, ma poiché il tipo di metodo restituito è object viene applicato un
cast esplicito.
Ora supponiamo anche che su di esso sia stato eseguito il secondo sviluppatore di Harcourt.
In qualche altro posto nel progetto e usa la stessa istanza memorizzata che John ha segnato in
precedenza e ora fa una buona ricerca su tale oggetto.
Tuttavia, Harcourt crea un'istanza della classe data che proviene da un punto Java che hai fatto pacchettizzare l'istanza della
data precedente che era stata impostata da John proveniva finalmente dal pacchetto Java dot school.
Supponiamo che, mentre l'esecuzione del software continua, questo codice venga eseguito.
Supponiamo che la discordia sia scritta ancora una volta da John e che questo codice funzioni ancora sulla stessa istanza
di archivio.
E John sta recuperando l'oggetto Date e tenta di assegnarlo a una variabile di tipo punto Java come carburante che Dot ha fatto
in quanto era il tipo che aveva usato in precedenza.
Quindi si aspettava la stessa istanza di data e ottiene un'eccezione di classe in quanto l'oggetto ora è un'istanza
di punto di Java che indica puntino anziché virgola Java come ha fatto Cuellar.
Quindi c'è una differenza nell'istanza di classe che sta causando questa eccezione.
Quindi questi sono il tipo di problemi che si sono incontrati quando un oggetto è stato usato come un
tipo polimorfico, nessun primo problema qui è che l'oggetto pipe era troppo generico.
E in questo caso particolare permette di memorizzare istanze di input che Jawad non ha
oscurato la nostra data così come Joe o punto per indirizzare il secondo problema è la necessità di un cast esplicito
quindi ottenere il metodo è invocare l'oggetto deve essere fatto castato terzo è l'eccezione sgradevole e grugnendo.
Sappiamo che Java è un linguaggio sicuro per tipo e in questo caso è entrato in gioco il
controllo di sicurezza del tipo eseguito in runtime, quindi i progettisti di linguaggio desiderano risolvere questo problema ed evitare tali eccezioni di runtime.
Volevano che tali problemi venissero identificati in fase di compilazione e così via, così hanno
introdotto la funzione genetica che non genera un concetto di tempo puramente compilativo che non esiste un runtime impostato.
Viene solo in gioco compilato da e qui è lo stesso codice in cui vengono utilizzati i generici.
L'oggetto qui è sostituito da qualcosa chiamato parametro type e ne discuteremo più tardi.
Quindi ecco un parametro di tipo.
Ora vediamo cosa succede a Jonathan e qui chiama John.
John crea un'istanza di store ma afferma esplicitamente che l'istanza di archiviazione memorizzerebbe solo un'istanza di punto
Java come ha fatto il tuo cane o una delle sue forniture ma nient'altro.
Quindi, se si guarda la definizione della classe ha la notazione P e quando John crea l'istanza
del negozio con ha fatto che le parentesi angolari poi fatte si applica a ogni istanza della nella definizione della classe.
Come esattamente quello che funziona internamente è qualcosa che discuteremo più avanti.
Per ora sarebbe sufficiente capire che corrispondeva alla definizione della classe successiva nella seconda data dell'istruzione l'istanza è stata impostata
in un secondo momento e viene recuperata usando il getter ora non che, a differenza dell'esempio
precedente, non è possibile eseguire il casting qui.
Quindi è un codice dall'aspetto più pulito.
Successivo Anita tenta di impostare un'istanza di data dal nostro solito pacchetto sul compilatore che segnala istantaneamente
che non può farlo poiché quella particolare istanza di archivio può essere analizzata solo l'istanza dal pacchetto di
alimentazione di Jordan che è stata applicata da John scope.
Quindi, come potete vedere dal momento che stiamo usando i generici, non vi è spazio per l'eccezione di runtime che abbiamo
visto nell'esempio precedente in cui la classe dell'oggetto era usata come tipo.
Quindi questo è il tipo di sicurezza al momento della compilazione stesso.
Questo è davvero interessante, in quanto è sempre meglio sapere come è stato rilevato in fase di compilazione, in quanto non si desidera che il
programma smetta di funzionare in fase di esecuzione a causa di un errore di runtime.
Infine, poiché viene utilizzata la generica, viene di nuovo istanziata la stessa classe di archivio, ma
questa volta conterrà un'istanza di libro che è completamente diversa dall'istanza di data, quindi con i generici otteniamo il vantaggio
dalla sicurezza del tipo all'eccezione della compilazione.
Questo è il principale vantaggio.
Ora hai dimenticato la sicurezza del tipo.
Si prega di fare riferimento al tipo conferenza di sicurezza che faceva parte di uno dei gruppi capitolo secondo
beneficio è il codice dall'aspetto più pulito in quanto non esiste un typecasting esplicito come nell'esempio precedente il terzo vantaggio è che
il codice è molto più esplicito.
Ad esempio qui lo sviluppatore afferma esplicitamente quale tipo di oggetto è archiviato istanza quale archivio.
Va bene che anche l'espressività è molto importante, ecco perché il nome indica che il codice è generico.
Ad esempio qui il codice cliente è in grado di creare un'istanza di paglia che potrebbe chiamare qualsiasi.
Il primo John sta creando un'istanza di negozio chiamata il codice chiamato mentre Raj sta creando un'altra istanza di negozio
che terrebbe un oggetto libro.
Quindi il potere giace ma il codice gentile del codice Klein può trasmettere tutto ciò che desiderano in termini di genericità.
È molto simile all'uso di un oggetto come tipo ma al vantaggio della sicurezza del tipo a tempo di compilazione.
Ecco perché il codice generico è stato introdotto in Java per ridurre gli errori di runtime garantendo la sicurezza del tipo
al momento della compilazione stesso.
No, quel framework di collezioni usa un bel po 'di genetica come abbiamo visto prima.
Ora esaminiamo molto rapidamente l'agenda di questo capitolo.
Inizieremo osservando la sintassi della genetica selvatica a prescindere dalle classi sulle interfacce, la genetica può
essere associata solo a metodi con metodi meno genetici, quindi vedremo una proprietà della genetica chiamata in
radianti che è necessaria per garantire la sicurezza.
È un argomento molto importante
Successivamente vedremo i caratteri jolly.
Ora, se vogliamo costruire librerie ampiamente utilizzate, è fondamentale utilizzare correttamente i caratteri jolly.
Di seguito vedremo un'altra caratteristica del compilatore chiamata cancellazione dei tipi che aiuta il punteggio generico a
interagire con il codice Java precedente che non utilizza genera.
Si noti che i generici sono stati introdotti quasi 10 anni dopo il rilascio della prima versione di Java.
Quindi ci può essere molto codice legacy.
Un nuovo programma dovrebbe essere in grado di lavorare con loro senza problemi.
Successivamente vedremo anche alcune restrizioni che abbiamo con l'uso di generici.
Ovviamente guarderemo molto codice e estenderemo il progetto anche in questo capitolo.
Infine esamineremo anche alcune richieste di Java interessato.
Quindi questo è ciò che studieremo nel capitolo.
Basta notare che molti sviluppatori in generale trovano i generici che confondono di non avere problemi a utilizzarli leggendo le
classi del framework delle raccolte che sono semplici.
Ma oltre a questo tendono a mancare di chiarezza.
Una ragione per questo non sono molte risorse che spiegano questo argomento molto bene, un'altra ragione è che questi
sviluppatori, chiunque stia cercando di imparare, probabilmente non sta facendo abbastanza per impararlo mentre i generici richiedono
qualche sforzo in più.
Ma il concetto stesso è piuttosto semplice.
Una volta che lo hai capito concettualmente, sembra molto semplice.
Considerando quello che ho appena detto molto è stato pensato per costruire questo capitolo, è venuto fuori
piuttosto bene ed è stato accolto molto bene da molti studenti.
Gli studenti che hanno familiarità con i generici ma non sono ancora chiari mi hanno informato che questo capitolo
li ha aiutati immensamente.
Il mio consiglio per questo capitolo non è quello di correre attraverso le lezioni, ma lentamente e
farlo bene e una volta che hai finito una lezione o qualche argomento fai un po 'di
brainstorming per assicurarti di avere un concetto anche dopo aver finito il capitolo probabilmente una volta ogni settimana
o due settimane provate a pensare a tutti i diversi concetti e quella visualizzazione dovrebbe essere davvero utile
per interiorizzare completamente questo concetto.
Quindi lasciatemi fermarsi qui e ora andiamo avanti e cominciamo con il capitolo.
Grazie.