Menu

Concetti OOPS in C #: tutorial sui concetti di programmazione orientata agli oggetti

  • Principale
  • Altro
  • Concetti OOPS in C #: tutorial sui concetti di programmazione orientata agli oggetti

oops concepts c object oriented programming concept tutorial

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega i concetti di OOPS in C #. Puoi conoscere i principi di programmazione orientata agli oggetti come polimorfismo, incapsulamento, ereditarietà e astrazione:

La programmazione orientata agli oggetti è un modello di programmazione che funziona su un principio che ruota attorno agli oggetti piuttosto che all'azione o alla logica. Consente agli utenti di creare oggetti in base ai requisiti e quindi creare metodi per operare su tali oggetti.

Lavorare su questi oggetti per ottenere il risultato desiderato è l'obiettivo della programmazione orientata agli oggetti.

=> Esplora l'intera serie di esercitazioni di formazione per C # qui

Concetti di OOPS in C #

Rivediamo alcuni dei concetti che abbiamo appreso nei nostri tutorial precedenti !!

Spazio dei nomi

Uno spazio dei nomi in C # è una raccolta di classi. Fornisce una struttura per mantenere un nome di classe separato da un altro nome di classe dichiarandoli in uno spazio dei nomi diverso. In modo che le classi con lo stesso nome non siano in conflitto tra loro.

Classe

Una classe è un modello di un tipo di dati. In realtà è una raccolta di oggetti. Contiene oggetti e la definizione per l'operazione che deve essere eseguita su quell'oggetto.

Oggetti

Gli oggetti sono le istanze della classe.

Nei nostri tutorial precedenti, abbiamo già imparato a conoscere in dettaglio Class e Objects.

Cosa imparerai:

Concetti di OOPS in C #

La programmazione orientata agli oggetti offre diversi vantaggi rispetto agli altri modelli di programmazione come:

  1. L'approccio modulare preciso e chiaro per i programmi offre una facile comprensione e manutenzione.
  2. Le classi e gli oggetti creati nel progetto possono essere utilizzati in tutto il progetto.
  3. L'approccio modulare consente a diversi moduli di esistere in modo indipendente, consentendo così a diversi sviluppatori diversi di lavorare insieme su moduli diversi.

In questo tutorial, ci concentreremo maggiormente su altri importanti concetti fondamentali di OOPS:

  1. Incapsulamento
  2. Polimorfismo
  3. Eredità
  4. Astrazione

Incapsulamento

L'incapsulamento è un concetto di programmazione orientato agli oggetti che consente ai programmatori di racchiudere dati e frammenti di codice all'interno di un contenitore. Utilizzando il programma di incapsulamento, è possibile nascondere i membri di una classe da un'altra classe. È come circondare un elemento logico all'interno di un pacchetto. Permette solo informazioni rilevanti disponibili e visibili all'esterno e anche solo a membri specifici.

L'incapsulamento viene implementato utilizzando gli specificatori di accesso. Lo specificatore di accesso viene utilizzato per definire la visibilità e l'accessibilità del membro della classe in C #.

C # contiene i seguenti specificatori di accesso.

ricorsivo merge sort c ++
  • Pubblico
  • Privato
  • Protetto
  • Interno

Gli specificatori di accesso definiscono la visibilità della classe e dei suoi valori. Ti consente di rendere visibili i dati per una parte particolare del codice e nasconderli da un'altra parte. La visibilità più comunemente utilizzata è pubblica e privata.

Diamo un'occhiata a loro.

Pubblico: La parola chiave public consente ai suoi membri di essere visibili da qualsiasi punto all'interno del progetto. Questo identificatore di accesso ha la restrizione minima di visibilità.

Privato: Ai membri privati ​​può accedere solo il membro all'interno della stessa classe. Questo ha una delle visibilità più limitate.

Protetto: L'accessibilità protetta consente di accedere al membro dall'interno della classe e da un'altra classe che eredita questa classe.

Interno: Interno fornisce l'accessibilità dall'interno del progetto. Un'altra accessibilità interna simile è protetta dall'interno. Ciò consente lo stesso dell'interno e l'unica differenza è che una classe figlia può ereditare questa classe e raggiungere i suoi membri anche da un altro progetto.

Polimorfismo

Il polimorfismo deriva dal dizionario greco, significa uno con molte forme. Poly sta per molti e Morph significa forme. Consente alla classe in C # di avere più implementazioni con lo stesso nome.

Il polimorfismo è fondamentalmente diviso in due parti:

  1. Polimorfismo in fase di compilazione
  2. Polimorfismo a tempo di esecuzione

# 1) Polimorfismo statico o in tempo di compilazione

Il polimorfismo in fase di compilazione è anche noto come polimorfismo statico. Il sovraccarico dei metodi è uno dei modi in cui si ottiene il polimorfismo in fase di compilazione. È noto come polimorfismo in fase di compilazione poiché la decisione sulla chiamata del metodo viene presa al momento della compilazione.

Si ottiene mantenendo lo stesso nome del metodo ma passando diversi set di parametri. Nel sovraccarico del metodo, il sistema controlla prima il parametro utilizzato e in base al set di parametri decide di chiamare il metodo appropriato.

Esempio:

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i+j) ); } void print(string a, string b) { Console.WriteLine('Printing String: ' , (a+b)); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello','World'); Console.ReadKey(); } }

Nell'esempio precedente, abbiamo chiamato lo stesso metodo 'print' due volte utilizzando parametri diversi. All'inizio, passiamo due interi come parametri, quindi abbiamo passato due stringhe come parametri. Esistono due metodi di 'stampa' con lo stesso nome.

Quando passiamo un parametro con il sistema interi, cercherà il metodo denominato 'print' che accetta due parametri interi e lo eseguirà ignorando altri metodi con lo stesso nome.

Nella seconda parte, abbiamo passato il parametro stringa. Anche in questo caso il sistema cercherà il metodo che accetta due parametri di stringa. Quindi, in base ai parametri passati, il primo metodo aggiungerà due numeri interi e il successivo concatenerà due stringhe.

# 2) Polimorfismo dinamico o polimorfismo di runtime

Il polimorfismo di runtime o il polimorfismo dinamico si verifica quando sia il nome del metodo che la firma del metodo hanno lo stesso nome e parametri. L'override del metodo è un esempio di polimorfismo dinamico. Consente all'utente di creare una classe astratta con un'implementazione parziale dell'interfaccia.

La sostituzione del metodo si ottiene utilizzando l'ereditarietà. Per ottenere il metodo che sovrascrive sia la classe base che la classe derivata, è necessario che abbiano lo stesso nome e parametro. Durante la fase di compilazione, il compilatore non è in grado di riconoscere il metodo di sovrascrittura, quindi non genera alcun errore. La decisione di eseguire un metodo viene presa durante il runtime.

Esempio:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public void print() { Console.WriteLine('Printing from class Execute'); } public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

Se eseguiamo il programma precedente, otterremo il seguente output:

Printing from class Execute

Anche se la classe Execute ha ereditato tutti i metodi della classe Program ma quando abbiamo chiamato il metodo print che è presente in entrambe le classi, il metodo presente nella classe figlia sovrascriverà il metodo dalla classe genitore.

Il polimorfismo dinamico viene utilizzato per implementare l'astrazione. Consente all'utente di creare una classe astratta che viene utilizzata per fornire un'implementazione per un'interfaccia quando viene ereditata da una classe derivata. La classe astratta può contenere nomi / firme dei metodi e la classe derivata può avere una definizione più specializzata per il metodo.

Eredità

L'ereditarietà è una parte importante del concetto di OOPS. Nell'ereditarietà, definiamo le classi padre e figlio. La classe figlia può ereditare tutti i metodi, oggetti e proprietà della classe genitore. Una classe figlia può anche avere i propri metodi e un'implementazione specifica.

La classe genitore è anche nota come classe base e la classe figlia che eredita la classe base è anche nota come classe derivata.

Esempio:

class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public static void Main(string() args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }

Qui abbiamo una classe denominata come programma che ha un metodo. Abbiamo un'altra classe Execute che eredita la classe Program. La classe Execute è la classe derivata e il programma di classe è noto come classe base.

Ora, invece di creare un'istanza di oggetto per il programma di classe, abbiamo creato un'istanza di oggetto per la classe Execute. Usando questa istanza possiamo accedere al metodo print dalla classe base.

Quindi, l'output del codice sopra sarà:

Printing from class Program

La classe derivata non eredita solo i metodi, ma eredita anche quasi tutti i membri della classe come i campi, le proprietà, ecc. A seconda della visibilità. L'ereditarietà in C # non consente l'uso di più eredità, ovvero una classe non può ereditare da più classi diverse, tuttavia, una classe può ereditare da un'altra classe che può ereditare da una classe diversa.

Astrazione

L'astrazione è uno dei principali principi della programmazione orientata agli oggetti. L'astrazione consente al programmatore di visualizzare solo i dettagli necessari al mondo nascondendo gli altri. L'astrazione si ottiene in C # utilizzando la classe e l'interfaccia Abstract.

Una classe può essere dichiarata come una classe astratta utilizzando la parola chiave 'Abstract'. La classe Abstract in C # è sempre la classe base nella gerarchia. Ciò che li rende diversi dall'altra classe è che non possono essere istanziati. Una classe astratta C # deve essere ereditata.

Esempio:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public void Describe() { return 'Description of the car'; } } class Hyundai : Car { }

L'output di quanto segue è:

Description of the car

Se lo confronti con i nostri esempi precedenti durante l'ereditarietà o il polimorfismo dinamico, troverai le somiglianze. La differenza più riconoscibile è l'uso della parola chiave astratta prima della classe Auto. Nel caso in cui desideri sovrascriverlo o fornire la tua implementazione simile a ciò che abbiamo fatto nel polimorfismo dinamico. Quindi puoi ottenerlo in questo modo.

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

Quindi, se esegui questo codice ora, darà il seguente output:

Description of the car is now Hyundai

Il metodo della classe derivata sovrascrive il metodo della classe base. In questo modo, puoi creare una classe derivata diversa come Ferrari, Porsche, BMW, ecc. Con i propri metodi di implementazione.

Se guardi da vicino, puoi vedere che il nostro metodo di descrizione nella classe astratta non contiene alcuna implementazione.

Allora, perché stiamo definendo metodi vuoti?

Questo perché una classe Abstract fornisce una firma dei metodi e rende obbligatorio per le sottoclassi creare un'implementazione per tutti questi metodi. Ciò consente la condivisione della classe base ma, allo stesso tempo, mantiene anche un controllo sull'implementazione del metodo della classe derivata.

Interfaccia

In C #, l'interfaccia è il progetto di una classe. L'interfaccia è simile a una classe astratta e viene utilizzata per ottenere un'astrazione al cento per cento. Tutti i metodi descritti all'interno dell'interfaccia sono astratti per impostazione predefinita. Non ha alcun corpo del metodo e non può essere istanziato.

L'interfaccia viene utilizzata principalmente per ottenere ereditarietà multipla e astrazione completa. Tutta la firma del metodo dichiarata all'interno dell'interfaccia dovrebbe essere fornita con l'implementazione dalla classe o dalla struttura che la implementa.

Esempio:

class Program { static void Main(string() args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } interface Car { string Describe(); } class Hyundai : Car { public string Describe() { return 'Description of the car is now Hyundai'; } }

L'output del codice precedente sarà:

Description of the car is now Hyundai

Qui abbiamo creato un'interfaccia Car. Poiché l'interfaccia non può avere alcuna definizione di metodo, abbiamo fornito solo il nome del metodo e il tipo restituito nell'interfaccia. Abbiamo quindi implementato l'interfaccia Car su un'altra classe Hyundai. Nella classe implementata abbiamo fornito la definizione dei metodi definiti all'interno dell'interfaccia.

Conclusione

Nel concetto di programmazione orientata agli oggetti, ogni parte del programma viene trattata come un oggetto. La classe è una raccolta di tipi simili di elementi e un oggetto è l'istanza della classe.

L'incapsulamento in C # consente all'utente di stabilire la visibilità della classe e dei suoi membri. Il polimorfismo consente ai metodi di avere lo stesso nome ma con parametri diversi all'interno della stessa classe o con lo stesso parametro in una classe diversa.

L'ereditarietà è quando una classe figlia, nota anche come classe derivata, eredita tutte le proprietà inclusi metodi, oggetti, campi, ecc. Della classe genitore, nota anche come classe base. L'astrazione consente al programma di visualizzare solo la firma nascondendo i dettagli di implementazione.

Programma consolidato

class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i + j)); } void print(string a, string b) { Console.WriteLine('Printing String '+ a + b); } static void Main(string() args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello', 'World'); Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }

=> Esplora l'intera serie di esercitazioni di formazione per C # qui

Lettura consigliata

^