Programmazione Dart - Classi

Dart è un linguaggio orientato agli oggetti. Supporta funzionalità di programmazione orientata agli oggetti come classi, interfacce, ecc. Aclassin termini di OOP è un modello per la creazione di oggetti. UNclassincapsula i dati per l'oggetto. Dart fornisce il supporto integrato per questo concetto chiamatoclass.

Dichiarazione di una classe

Utilizzare il class parola chiave per dichiarare un file classa Dart. Una definizione di classe inizia con la parola chiave class seguita daclass name; e il corpo di classe racchiuso da un paio di parentesi graffe. La sintassi per lo stesso è data di seguito:

Sintassi

class class_name {  
   <fields> 
   <getters/setters> 
   <constructors> 
   <functions> 
}

Il classla parola chiave è seguita dal nome della classe. Le regole per gli identificatori devono essere considerate durante la denominazione di una classe.

Una definizione di classe può includere quanto segue:

• Fields- Un campo è una qualsiasi variabile dichiarata in una classe. I campi rappresentano i dati relativi agli oggetti.

• Setters and Getters- Consente al programma di inizializzare e recuperare i valori dei campi di una classe. Un getter / setter predefinito è associato a ogni classe. Tuttavia, quelli di default possono essere sovrascritti definendo esplicitamente un setter / getter.

• Constructors - responsabile dell'allocazione della memoria per gli oggetti della classe.

• Functions- Le funzioni rappresentano le azioni che un oggetto può intraprendere. A volte sono anche indicati come metodi.

Questi componenti messi insieme sono chiamati data members della classe.

Esempio: dichiarazione di una classe

class Car {  
   // field 
   String engine = "E1001";  
   
   // function 
   void disp() { 
      print(engine); 
   } 
}

L'esempio dichiara una classe Car. La classe ha un campo denominatoengine. Ildisp() è una semplice funzione che stampa il valore del campo engine.

Creazione di istanza della classe

Per creare un'istanza della classe, usa il newparola chiave seguita dal nome della classe. La sintassi per lo stesso è data di seguito:

Sintassi

var object_name = new class_name([ arguments ])

• Il new la parola chiave è responsabile dell'istanza.

• Il lato destro dell'espressione richiama il costruttore. Al costruttore dovrebbero essere passati valori se è parametrizzato.

Esempio: creazione di un'istanza di una classe

var obj = new Car("Engine 1")

Accesso ad attributi e funzioni

È possibile accedere agli attributi e alle funzioni di una classe tramite l'oggetto. Utilizzare il '.' notazione punto (chiamata comeperiod) per accedere ai membri dati di una classe.

//accessing an attribute 
obj.field_name  

//accessing a function 
obj.function_name()

Esempio

Dai un'occhiata al seguente esempio per capire come accedere ad attributi e funzioni in Dart -

void main() { 
   Car c= new Car(); 
   c.disp(); 
}  
class Car {  
   // field 
   String engine = "E1001";  
   
   // function 
   void disp() { 
      print(engine); 
   } 
}

Il output del codice sopra è il seguente -

E1001

Costruttori di freccette

Un costruttore è una funzione speciale della classe responsabile dell'inizializzazione delle variabili della classe. Dart definisce un costruttore con lo stesso nome di quello della classe. Un costruttore è una funzione e quindi può essere parametrizzato. Tuttavia, a differenza di una funzione, i costruttori non possono avere un tipo restituito. Se non dichiari un costruttore, un file predefinitono-argument constructor è previsto per te.

Sintassi

Class_name(parameter_list) { 
   //constructor body 
}

Esempio

L'esempio seguente mostra come utilizzare i costruttori in Dart:

void main() { 
   Car c = new Car('E1001'); 
} 
class Car { 
   Car(String engine) { 
      print(engine); 
   } 
}

Dovrebbe produrre quanto segue output -

E1001

Costruttori denominati

Dart fornisce named constructors per abilitare una definizione di classe multiple constructors. La sintassi dei costruttori con nome è la seguente:

Sintassi: definizione del costruttore

Class_name.constructor_name(param_list)

Esempio

L'esempio seguente mostra come utilizzare i costruttori con nome in Dart:

void main() {           
   Car c1 = new Car.namedConst('E1001');                                       
   Car c2 = new Car(); 
}           
class Car {                   
   Car() {                           
      print("Non-parameterized constructor invoked");
   }                                   
   Car.namedConst(String engine) { 
      print("The engine is : ${engine}");    
   }                               
}

Dovrebbe produrre quanto segue output -

The engine is : E1001 
Non-parameterized constructor invoked

Questa parola chiave

Il thisparola chiave si riferisce all'istanza corrente della classe. Qui, il nome del parametro e il nome del campo della classe coincidono. Quindi, per evitare ambiguità, il campo della classe è preceduto dathisparola chiave. L'esempio seguente spiega lo stesso:

Esempio

Il seguente esempio spiega come utilizzare il this parola chiave in Dart -

void main() { 
   Car c1 = new Car('E1001'); 
}  
class Car { 
   String engine; 
   Car(String engine) { 
      this.engine = engine; 
      print("The engine is : ${engine}"); 
   } 
}

Dovrebbe produrre quanto segue output -

The engine is : E1001

Classe Dart ─ Getters e Setter

Getters e Setters, chiamato anche come accessors e mutators, consentono al programma di inizializzare e recuperare i valori dei campi di classe rispettivamente. Getter o funzioni di accesso vengono definiti utilizzandogetparola chiave. I setter o mutatori vengono definiti utilizzando ilset parola chiave.

Un getter / setter predefinito è associato a ogni classe. Tuttavia, quelli di default possono essere sovrascritti definendo esplicitamente un setter / getter. Un getter non ha parametri e restituisce un valore e il setter ha un parametro e non restituisce un valore.

Sintassi: definizione di un getter

Return_type  get identifier 
{ 
}

Sintassi: definizione di un setter

set identifier 
{ 
}

Esempio

Il seguente esempio mostra come puoi usare getters e setters in una classe Dart -

class Student { 
   String name; 
   int age; 
    
   String get stud_name { 
      return name; 
   } 
    
   void set stud_name(String name) { 
      this.name = name; 
   } 
   
   void set stud_age(int age) { 
      if(age<= 0) { 
        print("Age should be greater than 5"); 
      }  else { 
         this.age = age; 
      } 
   } 
   
   int get stud_age { 
      return age;     
   } 
}  
void main() { 
   Student s1 = new Student(); 
   s1.stud_name = 'MARK'; 
   s1.stud_age = 0; 
   print(s1.stud_name); 
   print(s1.stud_age); 
}

Questo codice di programma dovrebbe produrre quanto segue output -

Age should be greater than 5 
MARK 
Null

Eredità di classe

Dart supporta il concetto di ereditarietà che è la capacità di un programma di creare nuove classi da una classe esistente. La classe che viene estesa per creare classi più recenti è chiamata classe genitore / super classe. Le classi appena create sono chiamate classi figlio / sotto.

Una classe eredita da un'altra classe utilizzando la parola chiave "extends". Child classes inherit all properties and methods except constructors from the parent class.

Sintassi

class child_class_name extends parent_class_name

Note - Dart non supporta l'ereditarietà multipla.

Esempio: ereditarietà della classe

Nell'esempio seguente, stiamo dichiarando una classe Shape. La classe è estesa dalCircleclasse. Poiché esiste una relazione di ereditarietà tra le classi, la classe figlia, ovvero la classeCar ottiene un accesso implicito al membro dati della sua classe genitore.

void main() { 
   var obj = new Circle(); 
   obj.cal_area(); 
}  
class Shape { 
   void cal_area() { 
      print("calling calc area defined in the Shape class"); 
   } 
}  
class Circle extends Shape {}

Dovrebbe produrre quanto segue output -

calling calc area defined in the Shape class

Tipi di ereditarietà

L'ereditarietà può essere dei seguenti tre tipi:

• Single - Ogni classe può estendersi al massimo da una classe genitore.

• Multiple- Una classe può ereditare da più classi. Dart non supporta l'ereditarietà multipla.

• Multi-level - Una classe può ereditare da un'altra classe figlia.

Esempio

L'esempio seguente mostra come funziona l'ereditarietà multilivello:

void main() { 
   var obj = new Leaf(); 
   obj.str = "hello"; 
   print(obj.str); 
}  
class Root { 
   String str; 
}  
class Child extends Root {}  
class Leaf extends Child {}  
//indirectly inherits from Root by virtue of inheritance

La classe Leafderiva gli attributi dalle classi Root e Child in virtù dell'ereditarietà multi-livello. Suooutput è il seguente -

hello

Dart - Ereditarietà della classe e sostituzione del metodo

L'override del metodo è un meccanismo mediante il quale la classe figlia ridefinisce un metodo nella sua classe genitore. L'esempio seguente illustra lo stesso:

Esempio

void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   void m1(int a){ print("value of a ${a}");} 
}  
class Child extends Parent { 
   @override 
   void m1(int b) { 
      print("value of b ${b}"); 
   } 
}

Dovrebbe produrre quanto segue output -

value of b 12

Il numero e il tipo dei parametri della funzione devono corrispondere durante l'override del metodo. In caso di mancata corrispondenza nel numero di parametri o nel loro tipo di dati, il compilatore Dart genera un errore. La seguente illustrazione spiega lo stesso:

import 'dart:io'; 
void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   void m1(int a){ print("value of a ${a}");} 
} 
class Child extends Parent { 
   @override 
   void m1(String b) { 
      print("value of b ${b}");
   } 
}

Dovrebbe produrre quanto segue output -

value of b 12

La parola chiave statica

Il static la parola chiave può essere applicata ai membri di dati di una classe, ad esempio fields e methods. Una variabile statica mantiene i propri valori fino al termine dell'esecuzione del programma. I membri statici sono referenziati dal nome della classe.

Esempio

class StaticMem { 
   static int num;  
   static disp() { 
      print("The value of num is ${StaticMem.num}")  ; 
   } 
}  
void main() { 
   StaticMem.num = 12;  
   // initialize the static variable } 
   StaticMem.disp();   
   // invoke the static method 
}

Dovrebbe produrre quanto segue output -

The value of num is 12

La super parola chiave

Il superviene utilizzata per fare riferimento al genitore immediato di una classe. La parola chiave può essere utilizzata per fare riferimento alla versione super class di avariable, property, o method. L'esempio seguente illustra lo stesso:

Esempio

void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   String msg = "message variable from the parent class"; 
   void m1(int a){ print("value of a ${a}");} 
} 
class Child extends Parent { 
   @override 
   void m1(int b) { 
      print("value of b ${b}"); 
      super.m1(13); 
      print("${super.msg}")   ; 
   } 
}

Dovrebbe produrre quanto segue output -

value of b 12 
value of a 13 
message variable from the parent class