Classi, oggetti e pacchetti
Comprenda come definire classi, creare oggetti e organizzare il codice utilizzando i pacchetti in Scala.
Classi, oggetti e pacchetti è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 1 di 2. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 2 lezioni in totale.
Benvenuti nella programmazione a oggetti in Scala
In questa lezione approfondirà il cuore della programmazione orientata agli oggetti (OOP) in Scala. Esploreremo come strutturare il codice usando le classi, creare istanze di tali classi (oggetti) e mantenere tutto organizzato con i package.
Iniziamo a creare applicazioni robuste e modulari!
Classi: i progetti di base
Consideri una classe come un modello per creare oggetti. Definisce le proprietà (dati) e i comportamenti (metodi) che avranno i suoi oggetti. Le classi non contengono dati direttamente, ma descrivono quali dati può contenere un oggetto.
Ecco una definizione di classe di base:
class Car {
// Properties and methods go here
}Definire una classe semplice
In Scala, si definisce una classe usando la parola chiave class seguita dal suo nome. Creiamo una semplice classe Dog. Per ora non fa ancora molto, ma è un inizio!
Provi a eseguire questa definizione di classe vuota:
class Dog {
// This dog has no properties or behaviors yet
}
object Main {
def main(args: Array[String]): Unit = {
println("Dog class defined!")
}
}Creare oggetti (istanze)
Un oggetto è un'istanza di una classe. È una vera «entità» creata a partire dal modello. Per creare un oggetto, si usa la parola chiave new seguita dal nome della classe.
Ogni oggetto dispone del proprio insieme di dati, come definito dalla classe.
class Dog {
// Still an empty dog blueprint
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog()
val yourDog = new Dog()
println("Two dog objects created!")
}
}Aggiungere proprietà a una classe
Le classi possono avere proprietà (chiamate anche campi o membri) che memorizzano dati. È possibile definirle nel costruttore della classe, rendendole parametri quando si crea un oggetto.
Aggiungiamo a Dog un name e un breed:
class Dog(val name: String, val breed: String) {
// 'val' makes name and breed immutable properties
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog("Buddy", "Golden Retriever")
println(s"My dog's name is ${myDog.name} and breed is ${myDog.breed}.")
}
}Aggiungere comportamenti (metodi)
Le classi definiscono anche i metodi, ovvero funzioni che descrivono il comportamento dell'oggetto. I metodi possono accedere alle proprietà dell'oggetto e modificarle.
Ora il nostro Dog può eseguire bark():
class Dog(val name: String, val breed: String) {
def bark(): String = {
s"${name} says Woof!"
}
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog("Max", "Labrador")
println(myDog.bark())
}
}Gli `object` di Scala (singleton)
In Scala, la parola chiave object definisce un singleton. Ciò significa che può esistere una sola istanza. Non si usa new per crearlo: basta fare riferimento al suo nome.
Vengono spesso usati per i metodi di utilità o come unico punto di accesso.
object MathUtils {
def add(a: Int, b: Int): Int = a + b
def subtract(a: Int, b: Int): Int = a - b
}
object Main {
def main(args: Array[String]): Unit = {
val sum = MathUtils.add(5, 3)
println(s"5 + 3 = ${sum}")
}
}Oggetti companion
Un companion object è un object che ha lo stesso nome di una class ed è definito nello stesso file sorgente. Ha un accesso speciale ai membri privati dell'altra entità, e viceversa.
- La classe contiene dati e metodi specifici dell'istanza.
- Il companion object contiene metodi simili a quelli statici o metodi factory.
class Circle(val radius: Double) {
def area: Double = Circle.PI * radius * radius
}
object Circle {
// This is the companion object for the Circle class
val PI: Double = 3.14159
def apply(r: Double): Circle = new Circle(r) // Factory method
}
object Main {
def main(args: Array[String]): Unit = {
val c = Circle(5.0) // Using the apply method from companion object
println(s"Circle area: ${c.area}")
}
}Organizzare il codice con i package
I package sono un modo per organizzare classi e oggetti in gruppi logici, evitando conflitti tra nomi e migliorando la manutenibilità del codice.
Li si può considerare come cartelle per il codice. La parola chiave package dichiara il package all'inizio di un file Scala.
package com.coddykit.animals
class Cat(val name: String) {
def meow(): String = s"${name} says Meow!"
}
// This class is now inside com.coddykit.animals packageImportare membri dai package
Per usare classi o oggetti definiti in un altro package, è necessario importarli. La parola chiave import rende disponibili i membri di un package nell'ambito corrente.
Importiamo la nostra classe Cat:
package com.coddykit.app
// Define a class in a package first for import example
package com.coddykit.animals {
class Cat(val name: String) {
def meow(): String = s"${name} says Meow!"
}
}
import com.coddykit.animals.Cat
object Main {
def main(args: Array[String]): Unit = {
val myCat = new Cat("Whiskers")
println(myCat.meow())
}
}Verifica rapida: classe o oggetto?
Ha imparato a conoscere classi, oggetti e package. Verifichiamo la sua comprensione!
Riepilogo: classi, oggetti e package
Ottimo lavoro! Ha appreso i fondamenti della programmazione orientata agli oggetti in Scala:
- Le classi sono modelli che definiscono proprietà e comportamenti.
- Gli oggetti sono istanze create dalle classi usando
new. - La parola chiave
objectdi Scala crea singleton, utili per le utility o le factory. - Gli oggetti companion si associano alle classi per fornire membri simili a quelli statici.
- I package organizzano il codice, evitando conflitti tra nomi e migliorandone la struttura.
Ora costruiremo su queste basi esplorando ereditarietà e polimorfismo!
Domande Frequenti
La lezione «Classi, oggetti e pacchetti» è gratuita?
Sì — il testo completo di «Classi, oggetti e pacchetti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 2 lezioni in totale.
Cosa imparerò in «Classi, oggetti e pacchetti»?
Comprenda come definire classi, creare oggetti e organizzare il codice utilizzando i pacchetti in Scala. Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 2.
Quanto tempo richiede la lezione «Classi, oggetti e pacchetti»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Classi, oggetti e pacchetti
- Ereditarietà e polimorfismo