Students Save 30%! Learn & create with unlimited courses & creative assets Students Save 30%! Save Now
Advertisement
  1. Code
  2. Kotlin
Code

Kotlin From Scratch: classi astratte, interfacce, eredità e alias di tipo

by
Difficulty:IntermediateLength:LongLanguages:
This post is part of a series called Kotlin From Scratch.
Kotlin From Scratch: Advanced Properties and Classes
Kotlin From Scratch: Exception Handling

Italian (Italiano) translation by Loris Pizii (you can also view the original English article)

Kotlin è un moderno linguaggio di programmazione che compone il bytecode di Java. È libero e open source e promette di rendere codifica per Android ancora più divertente.

Nell'articolo precedente, hai imparato di più sulle proprietà di Kotlin, come le proprietà di inizio inizializzazione, estensione e inline. Non solo, hai anche imparato a conoscere classi avanzate come dati, enum, nidificati e lezioni chiuse a Kotlin.

In questo post, continuerai a conoscere la programmazione orientata agli oggetti a Kotlin imparando le classi astratte, le interfacce e l'ereditarietà. Per un bonus potrai anche conoscere gli alias dei tipi.

1. Classi astratte

Kotlin supporta classi astratte - proprio come Java, queste sono classi che non si intende mai creare oggetti. Una classe astratta è incompleta o inutile senza alcune sottoclassi concrete (non astratte), da cui è possibile creare istanze di oggetti. Una sottoclasse concreta di una classe astratta implementa tutti i metodi e le proprietà definiti nella classe astratta - altrimenti la sottoclasse è anche una classe astratta!

Creiamo una classe astratta con il modificatore astratto (simile a quello di Java).

Si noti che non tutti i membri devono essere astratti. In altre parole, possiamo avere l'implementazione di default di metodo in una classe astratta.

Qui abbiamo creato la funzione non-astratta fullName () in un dipendente di classe astratta. Le classi concreti (sottoclassi della classe astratta) possono ignorare l'implementazione predefinita di un metodo astratto, ma solo se il metodo ha specificato il modificatore aperto (si informerà di più in poco tempo).

Possiamo anche memorizzare lo stato in classi astratte.

Anche se la classe astratta non definisce alcun metodo, dobbiamo creare una sottoclasse prima di poterla istanziarla, come nell'esempio riportato di seguito.

La nostra classe Programmatore estende la classe astratta Employee. In Kotlin usiamo un carattere singolo del colon (:) anziché il Java estende la parola chiave per estendere una classe o implementare un'interfaccia.

Possiamo quindi creare un oggetto di tipo Programmer e metodi di chiamata su di esso - sia nella sua classe o nella superclasse (classe di base).

Una cosa che potrebbe sorprendere è che abbiamo la capacità di ignorare una proprietà di val (immutabile) con var (mutable).

Assicurati di usare questa funzionalità con saggezza! Tieni presente che non possiamo fare il reverse-override una proprietà var con val.

2. Interfacce

Un'interfaccia è semplicemente una collezione di metodi correlati che in genere consentono di indicare agli oggetti che cosa fare e come farlo per impostazione predefinita. (Metodi predefiniti nelle interfacce sono una nuova funzionalità aggiunta a Java 8.) In altre parole, un'interfaccia è un contratto che le classi di implementazione devono rispettare.

Viene definita un'interfaccia utilizzando la parola chiave dell'interfaccia in Kotlin (simile a Java).

Nel codice precedente abbiamo dichiarato un'interfaccia StudentRepository. Questa interfaccia contiene due metodi astratti: getById () e getResultsById (). Si noti che includere la parola chiave astratta è ridondante in un metodo di interfaccia perché sono già implicitamente astratti.

Un'interfaccia è inutile senza uno o più implementatori, quindi creiamo una classe che implementi questa interfaccia.

Qui abbiamo creato una classe StudentLocalDataSource che implementa l'interfaccia StudentRepository.

Utilizziamo il modificatore di override per etichettare i metodi e le proprietà che desideriamo ridefinire dall'interfaccia o dalla superclasse: questo è simile all'annotazione @Override in Java.

Si noti le seguenti regole aggiuntive di interfacce in Kotlin:

  • Una classe può implementare tante interfacce come si desidera, ma può solo estendere una singola classe (simile a Java).
  • Il modificatore di override è obbligatorio in Kotlin, a differenza di Java.
  • Oltre ai metodi, possiamo anche dichiarare le proprietà in un'interfaccia di Kotlin.
  • Un metodo di interfaccia Kotlin può avere un'implementazione predefinita (simile a Java 8).

Vediamo un esempio di un metodo di interfaccia con un'implementazione predefinita.

Nel codice precedente, abbiamo aggiunto un nuovo metodo delete () con un'implementazione predefinita (anche se non ho aggiunto il codice di implementazione effettivo a scopo dimostrativo).

Abbiamo anche la libertà di superare l'implementazione predefinita se vogliamo.

Come affermato, un'interfaccia di Kotlin può avere proprietà, ma nota che non è in grado di mantenere lo stato. (Tuttavia, ricorda che classi astratte possono mantenere lo stato.) Quindi la seguente definizione di interfaccia con una dichiarazione di proprietà funzionerà.

Ma se cerchiamo di aggiungere un certo stato all'interfaccia assegnando un valore alla proprietà, non funzionerà.

Tuttavia, una proprietà di interfaccia in Kotlin può avere metodi getter e setter (anche se solo quest'ultima se la proprietà è mutevole). Notare inoltre che la proprietà di un'interfaccia non può avere un campo di backup.

Possiamo anche ignorare una proprietà di interfaccia se si desidera, per ridefinirla.

Vediamo un caso in cui abbiamo una classe che implementa più interfacce con la stessa firma del metodo. Come decida la classe che metodo di interfaccia da chiamare?

Qui abbiamo due interfacce che dispongono di un metodo con la stessa funD (). Creiamo una classe che implementi queste due interfacce e sovrascrive il metodo funD ().

Il compilatore è confuso circa chiamare il metodo super.funD () perché le due interfacce che la classe implementa hanno la stessa firma del metodo.

Per risolvere questo problema, avvolgiamo il nome dell'interfaccia per cui desideriamo chiamare il metodo in parentesi angolari . (IntelliJ IDEA o Android Studio ti darà un suggerimento per risolvere questo problema quando si verifica).

Qui intendiamo chiamare il metodo funD () di InterfaceA. Problema risolto!

3. Eredità

Viene creata una nuova classe (sottoclasse) acquisendo un membro di una classe esistente (superclass) e forse ridefinendo l'implementazione predefinita. Questo meccanismo è conosciuto come ereditarietà nella programmazione orientata agli oggetti (OOP). Una delle cose che rendono Kotlin così impressionante è che comprende entrambi i paradigmi di programmazione funzionale e OOP - tutti in una sola lingua.

La classe di base per tutte le classi di Kotlin è Any.

Il tipo Any è equivalente al tipo di oggetto che abbiamo in Java.

Il tipo Any contiene i seguenti membri: equals (), hashcode () e anche toString () (simili a Java).

Le nostre classi non hanno bisogno di estendere esplicitamente questo tipo. Se non specificate esattamente quale classe si estende una nuova classe, la classe estende qualsiasi implicitamente. Per questo motivo, di solito non è necessario includere: : Any nel tuo codice - lo facciamo nel codice qui sopra per scopi dimostrativi.

Cerchiamo ora di creare classi in Kotlin con l'eredità in mente.

Nel codice di cui sopra, la classe GraduateStudent estende la Superclass Student. Ma questo codice non verrà compilato. Perché? Poiché le classi e i metodi sono definitive per default in Kotlin. In altre parole, non possono essere estesi per impostazione predefinita, a differenza di Java dove le classi e i metodi sono aperti per impostazione predefinita.

Le migliori pratiche di ingegneria software raccomandano di iniziare a preparare le classi e i metodi per impostazione predefinita, ad es. se non sono specificamente destinati ad essere ridefiniti o sovrascritti nelle sottoclassi. Il team di Kotlin (JetBrains) ha applicato questa filosofia di codifica e molte altre pratiche migliori per lo sviluppo nello sviluppo di questo linguaggio moderno.

Per consentire di creare sottoclassi da una superclasse, dobbiamo esplicitamente contrassegnare la superclasse con il modifier aperto. Questo modificatore si applica anche a qualsiasi proprietà superclass o metodo che deve essere ignorato dalle sottoclassi.

Abbiamo semplicemente messo il modificatore aperto prima della parola chiave di classe. Ora abbiamo istruito il compilatore per consentire alla nostra classe Studente di essere aperto per l'estensione.

Come detto in precedenza, i membri di una classe di Kotlin sono anche definitivi per impostazione predefinita.

Nel codice precedente, abbiamo segnato la funzione schoolFees come aperta, in modo che le sottoclassi possano ignorarla.

Qui, la funzione di scuola aperta dalla Superclass Studente viene superata dalla classe GraduateStudent - aggiungendo il modificatore di override prima della parola chiave divertente. Si noti che se si ignora un membro di una superclasse o di un'interfaccia, l'utente prevalente sarà aperto anche per impostazione predefinita, come nell'esempio seguente:

Anche se non abbiamo contrassegnato il metodo schoolFees () nella classe GraduateStudent con il modificatore aperto, possiamo ancora ignorarlo - come abbiamo fatto nella classe ComputerScienceStudent. Per evitare questo, dobbiamo contrassegnare l'ultimo membro come ultimo.

Ricorda che possiamo aggiungere nuove funzionalità a una classe - anche se è finale - con l'utilizzo di funzioni di estensione a Kotlin. Per un aggiornamento sulle funzioni di estensione, controlla le mie funzioni avanzate nel post di Kotlin. Inoltre, se hai bisogno di un aggiornamento su come regalare anche una classe finale nuove proprietà senza ereditarne, leggere la sezione sulle proprietà di estensione nel mio post di proprietà avanzate e classi.

Se la nostra superclasse ha un costruttore principale come questo:

Quindi ogni sottoclasse deve chiamare il costruttore principale della superclasse.

Possiamo semplicemente creare un oggetto della classe GraduateStudent come al solito:

Se la sottoclasse desidera chiamare il costruttore della superclasse dal suo costruttore secondario, utilizziamo la parola chiave super (simile a come i costruttori di superclass sono invocati in Java).

Se hai bisogno di un aggiornamento sui costruttori di classe a Kotlin, visita la mia sezione Classi e oggetti.

4. Bonus: tipo Alias

Un'altra cosa impressionante che possiamo fare a Kotlin è dare un tipo un alias.

Vediamo un esempio.

Nella classe precedente, possiamo assegnare i tipi String e Int per gli alias delle proprietà di Persona utilizzando il modificatore typealias in Kotlin. Questo modificatore viene utilizzato per creare un alias di qualsiasi tipo in Kotlin, inclusi quelli creati.

Come potete vedere, abbiamo creato un nome e l'età alias per entrambi i tipi String e Int. Ora abbiamo sostituito il tipo di proprietà firstName e lastName nel nostro Nome alias e anche nel tipo Int per l'alias di età. Si noti che non abbiamo creato nuovi tipi, ma abbiamo creato un alias per i tipi.

Questi possono essere utili quando si desidera fornire un significato migliore o semantico ai tipi nella tua base di codice di Kotlin. Usatele con saggezza!

Conclusione

In questo tutorial, hai imparato di più sulla programmazione orientata agli oggetti a Kotlin. Abbiamo ricoperto quanto segue:

  • classi astratte
  • interfacce
  • ereditarietà
  • tipo alias

Se hai imparato Kotlin attraverso la nostra serie Kotlin From Scratch, assicuratevi di aver digitato il codice che vedi e l'esecuzione sul tuo IDE. Un'ottima soluzione per comprendere veramente un nuovo linguaggio di programmazione (o qualsiasi concetto di programmazione) che stai imparando è assicurarsi di non solo leggere la risorsa o la guida di apprendimento, ma anche digitare il codice effettivo e eseguirlo!

Nel tutorial successivo della serie Kotlin From Scratch, sarai introdotto nella gestione delle eccezioni a Kotlin. A presto!

Per saperne di più sulla lingua Kotlin, consiglio di visitare la documentazione di Kotlin. O controlla alcuni degli altri post di sviluppo di applicazioni Android qui su Envato Tuts!


Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.