Come implementare l'astrazione dei dati in Java?

Astrazione, polimorfismo, incapsulamento ed ereditarietà sono i quattro elementi di base della programmazione orientata agli oggetti. Uno di questi, l'astrazione dei dati, sarà discusso in dettaglio nel seguente articolo. Impareremo anche come eseguire l'astrazione dei dati in Java.

Che cos'è l'astrazione dei dati?

L'astrazione dei dati è la caratteristica in cui vengono mostrati all'utente solo i dettagli più importanti. L'utente è tenuto all'oscuro di dettagli banali o non essenziali. Ad esempio, un'automobile è considerata nel suo insieme piuttosto che nelle sue parti distinte. La pratica di identificare solo gli attributi necessari di un elemento mentre si scartano le informazioni estranee è nota come astrazione dei dati.

In termini semplici, l'astrazione dei dati mostra elementi importanti all'utente mantenendo nascosti elementi insignificanti.

Usiamo la parola chiave “abstract” per implementare l'astrazione con l'aiuto di classi e interfacce. Possiamo avere metodi sia astratti che concreti in classi astratte.

Cosa sono le classi astratte?

Nella programmazione orientata agli oggetti, una classe astratta è una classe che dichiara uno o più metodi astratti. L'unica distinzione tra classi Java astratte e normali è che le classi astratte contengono la parola chiave abstract, mentre le classi Java normali no. Per la dichiarazione di una classe astratta, utilizziamo la parola chiave abstract prima del nome della sua classe. Ci possono essere metodi sia astratti che concreti nelle classi. Tuttavia, i metodi astratti non possono essere presenti nelle classi regolari. Una classe con almeno un metodo astratto viene definita classe astratta.

La sua sintassi è:

classe astratta pubblica Nome_della_classe

{

abstract pubblico Nome_del_metodo();

}

Un esempio di implementazione della classe astratta è:

//denominazione della classe astratta

classe astratta DemoClass

{

//denominazione del metodo astratta

abstract void disp();

}

//procedendo con la classe astratta

public class MainClass estende DemoClass

{

//definizione del corpo del metodo della classe astratta

visualizzazione vuota ()

{

System.out.println("Metodo astratto chiamato.");

}

public static void main(String[] args)

{

MainClass obj = new MainClass ();

//invocando il metodo astratto

obj.display();

}

}

Per elencare in modo puntuale:

• Una classe deve essere definita astratta se ha almeno un metodo astratto.
• Una classe che è stata dichiarata astratta non può essere istanziata.
• Devi ereditare una classe astratta da un'altra classe e fornire implementazioni per i suoi metodi astratti per utilizzarla.
• Devi fornire implementazioni per tutti i metodi astratti in una classe astratta se la eredi.

Cosa sono i metodi astratti?

Un metodo astratto ha solo la dichiarazione del metodo e nessuna implementazione. Un metodo astratto può essere rappresentato da un metodo senza un proprio corpo. I metodi astratti devono essere dichiarati esclusivamente all'interno di classi astratte.

Se vuoi che una classe abbia un metodo ma l'effettiva implementazione di quel metodo sia determinata dalle classi figlie, designa il metodo come abstract nella classe genitore.

Vantaggi dell'astrazione dei dati nella programmazione orientata agli oggetti

• Nella programmazione orientata agli oggetti, l'astrazione riduce la complessità della progettazione del programma e il processo della sua implementazione sul software.
• Il principale vantaggio dell'implementazione dell'astrazione nella programmazione Java è che gli utenti possono quindi organizzare facilmente classi basate su somiglianze, come i fratelli, e quindi l'ereditarietà dei dati e la migrazione dei dati diventa facile e fattibile.
• L'eredità è possibile. Per esempio:

/* Nome file: DemoAbstract.java */

public class DemoAbstract {

public static void main(String [] args) {

/* quanto segue non può essere scritto e genera errori */

dipendente e = nuovo dipendente(“Peter D.”, “Hartford, CT”, 35);

System.out.println(“\n Usa riferimento dipendente e chiama MailCheck–“);

e.mailCheck();

}

}

Questo mostra il seguente errore:

Employee.java:46: Il dipendente è astratto; non può essere istanziato

dipendente e = nuovo dipendente(“Peter D.”, “Hartford, CT”, 35);

^

1 errore

Quindi usiamo l'utilizzo della classe astratta come:

/* Nome file: employee.java */

dipendente pubblico di classe astratta {

stringa privata N;

Aggiungi stringa privata;

numero int privato;

dipendente pubblico(String N, String Add, int Num) {

System.out.println(“Costruire un dipendente”);

questo.nome = N;

questo.indirizzo = Aggiungi;

questo.numero = Num;

}

public double compute_pay() {

System.out.println("Inside employee compute_pay");

ritorno 0,0;

}

public void Mailcheck() {

System.out.println(“Invio di un assegno a ” + this.name + ” ” + this.address);

}

public String toString() {

restituisce N + ” ” + Aggiungi + ” ” + N;

}

public String getName() {

ritorno N;

}

public String getAddress() {

ritorno Aggiungi;

}

public void setAddress(String newAddress) {

Aggiungi = nuovoIndirizzo;

}

public int getNumber() {

ritorno Num;

}

}

Quando usiamo classi astratte o metodi astratti?

Quando consideriamo l'esempio generale di “forme”, possiamo immaginarlo utilizzato in riferimento a un sistema di progettazione assistita da computer o per una simulazione di un videogioco. Il tipo fondamentale a cui si fa riferimento qui è una "forma", con ogni forma che ha i suoi attributi di colore, dimensione, ecc. Da questa derivano (ereditate) classi specifiche di forme-cerchio, quadrato, triangolo, ecc., ognuna delle quali possono avere proprietà e comportamenti extra unici. Alcune forme, ad esempio, possono essere simmetriche, mentre altre no. Sia le somiglianze che le differenze distinte tra le forme sono incorporate nella gerarchia dei tipi.

Pertanto, la forma può essere analoga a una classe astratta, mentre i diversi tipi di forme possono essere indicati come classi concrete.

Ecco uno scenario di vita reale per spiegare le classi astratte:

// Programma Java per dimostrare l'astrazione

forma di classe astratta {

Colore delle corde;

doppia area astratta();

public abstract String toString();

// la classe astratta può avere il costruttore

forma pubblica (colore della stringa)

{

System.out.println("Costruttore di forme chiamato");

questo.colore = colore;

}

// questo è un metodo concreto

public String getColor() { return colour; }

}

classe Il cerchio estende la forma {

doppia r;

public Circle(String color, double(r)

{

// chiamando il costruttore Shape

super(colore);

System.out.println("Costruttore cerchio chiamato");

questo.r = r;

}

@Sostituisci doppia area()

{

restituisce Math.PI * Math.pow(r, 2);

}

@Esegui l'override della stringa pubblica suString()

{

restituisce "Il colore del cerchio è " + super.getColor()

+ “e l'area è : ” + area();

}

}

classe Rettangolo estende la forma {

doppia lunghezza;

doppia larghezza;

public Rectangle (colore della stringa, doppia lunghezza,

doppia larghezza)

{

// chiamando il costruttore Shape

super(colore);

System.out.println("Costruttore rettangolo chiamato");

questa.lunghezza = lunghezza;

questa.larghezza = larghezza;

}

@Sostituisci doppia area() { lunghezza restituita * larghezza; }

@Esegui l'override della stringa pubblica suString()

{

restituisce "Il colore del rettangolo è" + super.getcolor()

+ “e l'area è : ” + area();

}

}

prova di classe pubblica {

public static void main(String[] args)

{

Forma s1 = nuovo Cerchio(“Rosso”, 2.2);

Forma s2 = new Rectangle(“Yellow”, 2, 4);

System.out.println(s1.toString());

System.out.println(s2.toString());

}

}

Questo segmento di codice è una versione modificata di quello qui .

Un frammento di codice di un programma in cui viene utilizzata l'astrazione dei dati in Java:

// Astrazione in Java

classe astratta ElecBill

{

//metodo astratto

float astratto compBill();

}

class Comm estende ElecBill

{

float compBill() {

ritorno 1,00*100;

}

}

classe Domestic estende ElecBill

{

float compBill() {

ritorno 0,50*75;

}

}

Conclusione

L'astrazione dei dati è un aspetto importante della programmazione orientata agli oggetti. Per linguaggi come Java, l'astrazione e altri concetti OOP come ereditarietà, incapsulamento e polimorfismo svolgono un ruolo cruciale nella scrittura di programmi efficienti.

Se desideri approfondire le OOP e acquisire competenze di programmazione di prim'ordine, ti consigliamo di aderire alla certificazione PG collegata al lavoro di upGrad in Ingegneria del software, progettata per aiutare gli studenti ad acquisire competenze in Java, OODAP, DSA, HTML5, CSS3 , JavaScript, MERN, AWS, database SQL e NoSQL, Spring Boot, ecc. Il corso di 5 mesi copre due specializzazioni: specializzazione MERN Stack e specializzazione Cloud-Native e fornisce accesso a sessioni di consulenza professionale upGrad a 360°.

Impara i corsi di sviluppo software online dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.