Corso
Introduction to Scala
3 ore
27.2K
DataCamp ha recentemente lanciato il suo primo corso di Scala: Introduction to Scala. Dagli un'occhiata!
Dai un'occhiata anche ai seguenti tutorial:
Introduzione
In generale, la programmazione orientata agli oggetti (OOP) è composta da classi e oggetti e mira a rappresentare entità del mondo reale come polimorfismo ed ereditarietà.
L'OOP rende lo sviluppo molto più rapido ed economico, con una migliore manutenibilità del software. Il motivo principale di questa “magia” è l'insieme di funzionalità che supporta: hai classi e oggetti che possono essere facilmente riutilizzati in futuro in base alle esigenze, al contrario di un programma che non li utilizza. Questo, a sua volta, porta a software di qualità superiore, che è anche estensibile con nuovi metodi e attributi.
Mettiamo il caso che tu abbia un autosalone: ogni pochi mesi viene lanciata una nuova auto e, per informare il pubblico su nome e caratteristiche, devi definire da zero nuovi metodi e attributi. Tuttavia, se hai un programma orientato agli oggetti con una classe car, tutto quello che aggiungerai sarà un oggetto per la nuova auto, che richiamerà i metodi e gli attributi della classe con le informazioni del veicolo.
La classe può essere vista come una rappresentazione o un progetto per gli oggetti. Le classi di solito hanno i propri metodi (comportamento) e attributi.
Gli attributi sono entità che differenziano ogni oggetto dagli altri e ne determinano varie qualità. I metodi, invece, funzionano come una normale funzione in programmazione. Determinano come opera l'istanza della classe. È soprattutto grazie ai metodi (comportamento) che gli oggetti possono subire delle azioni.
La figura sopra ti dà più intuizioni sul flusso della programmazione orientata agli oggetti o, più nello specifico, su come appare una classe. Nell'immagine, c'è una class car con attributes: fuel, max speed, e può avere altri attributi come model, make, ecc. Ha diversi methods come refuel(), getFuel(), setSpeed(), e ulteriori metodi come change gear, start the engine, stop the engine, ecc.
Quindi, quando parli di un'auto specifica, avrai un oggetto, che è un'istanza di una classe.
Ora, parliamo della programmazione orientata agli oggetti in Scala.
Classi e oggetti in Scala
Proprio come in C++ e Java, la programmazione orientata agli oggetti in Scala segue pressoché le stesse convenzioni. Esiste il concetto di definire classes e objects e, all'interno della classe, i constructors: questo è tutto ciò che serve per l'OOP in Scala.
Dichiarazione di una classe
class Class_name{
// methods and attributes
}
In Scala una classe è definita dalla parola chiave class seguita dal nome della classe, e in genere il nome della classe inizia con una lettera maiuscola. Ci sono alcune parole chiave opzionali che possono essere usate nella dichiarazione di una classe in Scala, come: class-name, dovrebbe iniziare con una lettera maiuscola; superclass, il nome della classe padre preceduto dalla parola chiave extend; traits, un elenco separato da virgole implementato dalla classe e preceduto dalla parola chiave extend.
Una classe in Scala può ereditare una sola classe padre, il che significa che Scala non supporta l'ereditarietà multipla. Tuttavia, può essere ottenuta con l'uso dei Traits.
Infine, il corpo di una classe in Scala è racchiuso tra parentesi graffe {}.
// Name of the class is Car
class Car
{
// Class variables
var make: String = "BMW"
var model: String = "X7"
var fuel: Int = 40
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Class object
var obj = new Car();
obj.Display();
}
}
Puoi salvare il codice qui sopra con il nome class.scala ed eseguirlo nel terminale con scala class.scala; dovresti vedere l'output seguente.
Beh, il codice sopra non sfrutta appieno i vantaggi di cui è capace un programma orientato agli oggetti. L'output sarà sempre lo stesso, indipendentemente da quante volte lo esegui. Hai definito variabili statiche all'interno della classe e i loro valori rimarranno costanti anche se crei infiniti nuovi oggetti. In conclusione, non puoi aspettarti che ti dia i dettagli per una Mercedes-Benz o una Ferrari.
Costruttore in Scala
I costruttori sono usati principalmente per inizializzare lo stato dell'oggetto. Questa inizializzazione avviene al momento della creazione dell'oggetto e vengono chiamati una sola volta.
In Scala ci sono due tipi di costruttori: Primary e Auxiliary. In questo tutorial imparerai il costruttore primario (Fonte: O'Reilly).
class Class_name(Parameter_list){
// methods, attributes
}
Il costruttore primario condivide lo stesso corpo della classe ed è creato implicitamente insieme alla definizione della classe. Inizia dalla definizione della classe e si estende all'intero corpo della classe. Inoltre, quando c'è un solo costruttore nel programma Scala, è detto costruttore primario. Un costruttore primario può essere definito con zero, uno o più parametri.
Riprendiamo quindi l'esempio precedente, ma questa volta aggiungiamo il costruttore primario e osserviamo l'effetto.
Qui imparerai anche una nuova caratteristica di una classe: una classe può avere più oggetti o istanze, indipendenti l'uno dall'altro.
// Name of the class is Car
class Car(make: String, model: String, fuel: Int)
{
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Multiple Class object
var obj1 = new Car("BMW", "X7", 40);
var obj2 = new Car("Mercedes Benz", "S350D", 50);
obj1.Display();
obj2.Display();
}
}
Vediamo rapidamente l'output:
Non è fantastico? Con l'aiuto di un costruttore, sei riuscito a ottenere risultati più efficaci.
Dichiarare oggetti in Scala
Dichiarare oggetti in Scala può anche essere chiamato istanziare una classe o invocare una classe. Come le classi, anche gli oggetti sono un'unità fondamentale della programmazione orientata agli oggetti.
Un oggetto può avere tre caratteristiche (Fonte: GeeksforGeeks):
State:gli attributi di un oggetto lo rappresentano. Riflettono anche le proprietà di un oggetto.Behavior:i metodi di un oggetto lo rappresentano. Riflettono anche la risposta di un oggetto con altri oggetti.Identity:fornisce un nome univoco a un oggetto e consente a un oggetto di interagire con altri oggetti.
Considera Dog come un oggetto e guarda il diagramma qui sotto per la sua identità, stato e comportamento.
Tutte le istanze o gli oggetti condividono gli attributi e i metodi della classe. Una singola classe può avere più oggetti, come hai visto qui. Tuttavia, lo stato o i valori di ciascun oggetto sono unici.
Infine, scriverai un codice che abbia costruttori primari, variabili di classe, attributi e metodi tutti combinati in un unico esempio.
Qui sotto trovi una rappresentazione grafica dei componenti riuniti nella classe Motorcycle.
Il codice seguente è piuttosto autoesplicativo; in sintesi, verifica se il motore della moto è on o off. Inizialmente, il motore è impostato su spento e il programma ti informerà del suo stato e lo avvierà.
class Motorcycle(make:String,color:String) {
var engineState: Boolean = false;
def startEngine() {
if (engineState == true){
println("The engine is already on.");
}
else {
engineState = true
println("The engine is now on.");
}
}
def showAtts() {
println("This motorcycle is a "+ color + " " + make);
if (engineState == true){
println("The engine is on.");
}
else{
println("The engine is off.");
}
}
}
object Main
{
def main (args: Array[String])
{
var m = new Motorcycle("BMW K 1600 GTL","White");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
println("------");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
}
}
Congratulazioni!
Congratulazioni per aver completato questo tutorial.
Ora sai come dichiarare classi e metodi, istanziare oggetti, impostarne gli attributi e chiamare i metodi di istanza in Scala. Questi concetti ti saranno utili non solo in Scala ma anche in altri linguaggi di programmazione.
I concetti di programmazione orientata agli oggetti sono interessanti e allo stesso tempo molto potenti. Aggiungono una nuova dimensione al tuo codice e lo rendono riutilizzabile. Man mano che il programma cresce, anche la complessità del codice aumenta. C'è molta sostanza nei concetti OOP come ereditarietà, polimorfismo, metodi di istanza. Un'altra funzionalità potente è il Singleton. I principi di design aiutano a mantenere il codice più strutturato e leggibile. Per approfondire i design pattern, prendi in considerazione la lettura di questo libro.
Per qualsiasi domanda relativa a questo tutorial, scrivi pure nella sezione commenti qui sotto.
Infine, non dimenticare di seguire il nuovo corso di Scala su DataCamp, Introduction to Scala.
Argomenti
