Classi e Oggetti in Scala

DataCamp ha recentemente lanciato il suo primo corso su Scala: Introduzione a Scala. Dai un’occhiata!

Controlla anche i seguenti tutorial:

• Guida per principianti su Scala
• IF ELSE in Scala
• Operatori in Scala
• Liste in Scala

Introduzione

In generale, la Programmazione Orientata agli Oggetti (OOP) consiste in classi e oggetti e mira a implementare entità del mondo reale come la polimorfismo, l’ereditarietà.

La programmazione orientata agli oggetti rende lo sviluppo più veloce e meno costoso con una migliore manutenibilità del software. La ragione principale di questa magia è il numero di funzionalità supportate; hai classi e oggetti che possono essere facilmente riutilizzati in futuro in base alla richiesta, al contrario di un programma che manca di classi e oggetti. Ciò, a sua volta, porta a software di qualità superiore, che è anche estensibile con nuovi metodi e attributi.

Pensate ad una showroom di automobili; ogni qualche mese, viene lanciato un nuovo modello e per informare il pubblico del suo nome e delle sue caratteristiche, devi definire nuovi metodi e attributi da zero. tuttavia, se hai un programma orientato agli oggetti che ha una classe auto, tutto ciò che aggiungeresti è un oggetto per quella nuova auto, che chiamerà i metodi e gli attributi della classe con le informazioni dell’veicolo.

La classe può essere considerata come una rappresentazione o un design per gli oggetti. Le classi hanno di solito i loro metodi (comportamento) e attributi.

Gli attributi sono entità individuali che differentiano ogni oggetto dall’altro e determinano varie qualità di un oggetto. I metodi, d’altro canto, sono più come come una funzione solitamente opera nel programmazione. Determinano come funziona l’istanza della classe. E ‘soprattutto grazie ai metodi (comportamento) che gli oggetti hanno la possibilità di subire operazioni.

La figura soprastante dà un’intuizione migliore sulla logica dell’orientamento agli oggetti o, per essere più specifici, come si presenta una classe. Nell’immagine soprastante, c’è una classe auto che ha attributi: carburante, velocità massima e può avere altri attributi come il modello, marca, ecc. Ha diversi set di metodi come ricaricaCarburante(), getCarburante(), setVelocità(), e possono essere metodi aggiuntivi come cambiaRazza, accende il motore, spegne il motore, ecc.

Quindi, quando viene menzionato un determinato modello di auto, avrai un oggetto, che è una istanziazione di una classe.

Ora parliamo di programmazione orientata agli oggetti in Scala.

Classi e Oggetti in Scala

Come in C++ e Java, la programmazione orientata agli oggetti in Scala segue più or meno le stesse convenzioni. Presenta il concetto di definire classi e oggetti e costruttori all’interno della classe, e questo è tutto ciò che c’è nella programmazione orientata agli oggetti in Scala.

Dichiarazione di Classe

class Class_name{
// metodi e attributi
}

In Scala, la classe viene definita dal keyword class seguito dal nome della classe, e generalmente, il nome della classe inizia con una lettera maiuscola.Ci sono alcuni keyword opzionali ma possono essere usati nella dichiarazione di classe in Scala come: nome-classe, dovrebbe iniziare con una lettera maiuscola: classe-padre, il nome della classe padre preceduto dalla parola chiave extend: tratti, è un elenco separato da virgole implementato dalla classe preceduto dalla parola chiave extend.

Una classe può ereditare solo una classe padre in Scala, il che significa che Scala non supporta l’eredità multipla. Tuttavia, questo può essere ottenuto usando i Tratti.

Infine, il corpo di una classe in Scala è racchiuso da parentesi graffe {}.

// Il nome della classe è Car
class Car
{

    // Variabili di classe
    var make: String = "BMW"
    var model: String = "X7"
    var fuel: Int = 40

    // Metodo di classe
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}
object Main  
{

    // Metodo main
    def main(args: Array[String])  
    {

        // Oggetto di classe
        var obj = new Car();
        obj.Display();
    }
}

Puoi salvare il codice sopra indicato con il nome class.scala e eseguirlo sul terminale come scala class.scala, e dovresti vedere l’output come segue.

Beh, il codice sopra non utilizza completamente i privilegi di un programma orientato agli oggetti. Poiché l’output del codice sopra restituirà lo stesso risultato a prescindere dalla quantità di volte in cui lo esegui. Hai definito variabili statiche all’interno della classe, e i valori di queste variabili rimarranno costanti, anche se crei infinite nuove istanze di oggetti. In conclusione, non puoi aspettarti di ottenere dettagli per una Mercedes Benz o una Ferrari.

Costruttore in Scala

I costruttori sono principalmente utilizzati per inizializzare lo stato dell’oggetto. Questa inizializzazione dell’oggetto avviene al momento della creazione dell’oggetto e viene chiamata solo una volta.

In Scala ci sono due tipi di costruttori: Primary e Auxiliary. Per questo tutorial, imparerai riguardo il costruttore primario (Fonte: O’Reilly).

class Class_name(Parameter_list){
// metodi, attributi
}

Il costruttore primario ha lo stesso corpo della classe e viene creato implicitamente insieme alla definizione della classe. Inizia alla definizione della classe e occupa tutto il corpo della classe. Anche, quando c’è solo un costruttore nel programma Scala, si dice che è un costruttore primario. Un costruttore primario può essere definito con zero, uno o più parametri.

Prendiamo l’esempio precedente, ma questa volta aggiungiamo la caratteristica del costruttore primario ed osserviamo l’effetto.

Inoltre, qui imparerete una nuova caratteristica di una classe, ossia una classe può avere più oggetti o istanze ma entrambi indipendenti l’uno dall’altro.

// Il nome della classe è Car
class Car(make: String, model: String, fuel: Int)
{

    // Metodo di classe
    def Display()
    {
        println("Make of the Car : " + make);
        println("Model of the Car : " + model);
        println("Fuel capacity of the Car : " + fuel);
    }
}

object Main

{

    // Metodo principale
    def main(args: Array[String])  
    {

        // Oggetti di classe multipli
        var obj1 = new Car("BMW", "X7", 40);
        var obj2 = new Car("Mercedes Benz", "S350D", 50);
        obj1.Display();
        obj2.Display();
    }
}

Vediamo velocemente l’output:

Beh, non è questo grandioso? Con l’aiuto del costruttore, si sono ottenuti risultati più efficaci.

La dichiarazione di oggetti in Scala

La dichiarazione di oggetti in Scala può anche essere definita come l’istanziazione di una classe o l’invocazione di una classe. Come le classi, anche gli oggetti sono una unità fondamentale del programming orientato agli oggetti.

Un oggetto può consistere di tre caratteristiche (Fonte: GeeksforGeeks:

• Stato: gli attributi di un oggetto lo rappresentano. Riflette anche le proprietà di un oggetto.
• Comportamento: i metodi di un oggetto lo rappresentano. Riflette anche la risposta di un oggetto con gli altri oggetti.
• Identità: dà un nome univoco ad un oggetto e consente ad uno oggetto di interagire con gli altri oggetti.

Pensare al Cane come a un oggetto e osservare il diagramma seguente per la sua identità, lo stato e il comportamento.

Tutte le istanze o oggetti condividono le classi attributi e metodi. Un’unica classe può avere molti oggetti, come hai imparato qui. Tuttavia, lo stato o i valori di ciascun oggetto sono unici.

Infine, scriverai del codice che avrà costruttori primari, classi variabili, attributi e metodi tutti combinati in un solo codice.

Ecco una rappresentazione grafica dei componenti messi insieme nella classe Motorcycle.

Il codice seguente è piuttosto auto-esplicativo; a livello di alto livello, tuttavia, controlla se il motore della motocicletta è on o off. Inizialmente, il motore viene impostato su uno stato off, e ti notificherà il suo stato e lo cambierà su.

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, impostare i loro attributi e chiamare metodi di istanza in Scala. Questi concetti saranno utili a te non solo in Scala ma anche in altre lingue di programmazione.

I concetti di programmazione orientata agli oggetti sono interessanti e allo stesso tempo, molto potenti. Aggiungono una nuova dimensione al tuo codice, lo rendono riutilizzabile. Man mano che il tuo programma cresce, il tuo codice aumenterà in complessità. C’è molto da digerire nei concetti di programmazione orientata agli oggetti come ereditarietà, polimorfismo, metodi di istanza. Un’altra caratteristica potente è il Singleton. I principi di design aiutano a mantenere il codice più strutturato e leggibile. Per ulteriori informazioni sui pattern di design, considera la lettura di questo libro.

Non esiti a porre domande relative a questo tutorial nella sezione commenti qui sotto.

Infine, non dimenticare di seguire il nuovo corso Scala su DataCamp, Introduzione a Scala.