ASTRAZIONE IN JAVA

Astrazione in Java è il processo in cui mostriamo all'utente solo i dettagli/funzionalità essenziali. I dettagli di implementazione non essenziali non vengono visualizzati all'utente.

In questo articolo impareremo l'astrazione e cosa significa astratto.

Semplice esempio per comprendere l'astrazione:

Il telecomando della televisione è un eccellente esempio di astrazione . Semplifica l'interazione con una TV nascondendo la complessità dietro semplici pulsanti e simboli, rendendola semplice senza la necessità di comprendere i dettagli tecnici del funzionamento della TV.

Cos'è l'astrazione in Java?

In Java, l'astrazione è ottenuta da interfacce E classi astratte . Possiamo raggiungere il 100% di astrazione utilizzando le interfacce.

L'astrazione dei dati può anche essere definita come il processo di identificazione solo delle caratteristiche richieste di un oggetto ignorando i dettagli irrilevanti. Le proprietà e i comportamenti di un oggetto lo differenziano da altri oggetti di tipo simile e aiutano anche a classificare/raggruppare gli oggetti.

Esempio di astrazione nella vita reale:

Considera un esempio di vita reale di un uomo che guida un'auto. L'uomo sa solo che premendo l'acceleratore la velocità dell'auto aumenterà o che frenando l'auto si fermerà, ma non sa come premendo l'acceleratore la velocità aumenti effettivamente, non conosce il meccanismo interno dell'auto o l'implementazione dell'acceleratore, dei freni, ecc. nell'auto. Ecco cos'è l'astrazione.

Classi Java Abstract e metodi Java Abstract

Una classe astratta è una classe dichiarata con una parola chiave astratta.
Un metodo astratto è un metodo dichiarato senza implementazione.
Una classe astratta può avere o meno tutti i metodi astratti. Alcuni di essi possono essere metodi concreti
Un abstract definito dal metodo deve sempre essere ridefinito nella sottoclasse, creando così prevalente obbligatorio o rendere astratta la sottoclasse stessa.
Qualsiasi classe che contenga uno o più metodi astratti deve essere dichiarata anche con una parola chiave abstract.
Non può esserci oggetto di una classe astratta. Cioè, una classe astratta non può essere istanziata direttamente con il file nuovo operatore .
Una classe astratta può avere costruttori parametrizzati e il costruttore predefinito è sempre presente in una classe astratta.

Algoritmo per implementare l'astrazione in Java

Determinare le classi o le interfacce che faranno parte dell'astrazione.
Creare una classe o un'interfaccia astratta che definisca i comportamenti e le proprietà comuni di queste classi.
Definire metodi astratti all'interno della classe astratta o dell'interfaccia che non presentano dettagli di implementazione.
Implementa classi concrete che estendono la classe astratta o implementano l'interfaccia.
Sostituisci i metodi astratti nelle classi concrete per fornire le loro implementazioni specifiche.
Utilizzare le classi concrete per implementare la logica del programma.

Quando utilizzare classi astratte e metodi astratti?

Ci sono situazioni in cui vorremo definire una superclasse che dichiari la struttura di una data astrazione senza fornire un'implementazione completa di ogni metodo. A volte vorremo creare una superclasse che definisca solo un modulo di generalizzazione che sarà condiviso da tutte le sue sottoclassi, lasciando a ciascuna sottoclasse il compito di compilare i dettagli.

Consideriamo un esempio di forma classica, magari utilizzata in un sistema di progettazione assistita da computer o in una simulazione di gioco. Il tipo di base è forma e ogni forma ha un colore, una dimensione e così via. Da ciò derivano (ereditati) tipi specifici di forme: cerchio, quadrato, triangolo e così via, ognuna delle quali può avere caratteristiche e comportamenti aggiuntivi. Ad esempio, alcune forme possono essere capovolte. Alcuni comportamenti potrebbero essere diversi, ad esempio quando desideri calcolare l'area di una forma. La gerarchia dei tipi incarna sia le somiglianze che le differenze tra le forme.

Classe astratta in Java

Esempio di astrazione Java

Esempio 1:

Giava

sql in ordine per data

// Java program to illustrate the> // concept of Abstraction> abstract> class> Shape {> >String color;> > >// these are abstract methods> >abstract> double> area();> >public> abstract> String toString();> > >// abstract class can have the constructor> >public> Shape(String color)> >{> >System.out.println(>'Shape constructor called'>);> >this>.color = color;> >}> > >// this is a concrete method> >public> String getColor() {>return> color; }> }> class> Circle>extends> Shape {> >double> radius;> > >public> Circle(String color,>double> radius)> >{> > >// calling Shape constructor> >super>(color);> >System.out.println(>'Circle constructor called'>);> >this>.radius = radius;> >}> > >@Override> double> area()> >{> >return> Math.PI * Math.pow(radius,>2>);> >}> > >@Override> public> String toString()> >{> >return> 'Circle color is '> +>super>.getColor()> >+>'and area is : '> + area();> >}> }> class> Rectangle>extends> Shape {> > >double> length;> >double> width;> > >public> Rectangle(String color,>double> length,> >double> width)> >{> >// calling Shape constructor> >super>(color);> >System.out.println(>'Rectangle constructor called'>);> >this>.length = length;> >this>.width = width;> >}> > >@Override> double> area() {>return> length * width; }> > >@Override> public> String toString()> >{> >return> 'Rectangle color is '> +>super>.getColor()> >+>'and area is : '> + area();> >}> }> public> class> Test {> >public> static> void> main(String[] args)> >{> >Shape s1 =>new> Circle(>'Red'>,>2.2>);> >Shape s2 =>new> Rectangle(>'Yellow'>,>2>,>4>);> > >System.out.println(s1.toString());> >System.out.println(s2.toString());> >}> }>

esportare gimp in formato jpg

Produzione

Shape constructor called Circle constructor called Shape constructor called Rectangle constructor called Circle color is Redand area is : 15.205308443374602 Rectangle color is Yellowand area is : 8.0>

Esempio 2:

Giava

// Java Program to implement> // Java Abstraction> > // Abstract Class declared> abstract> class> Animal {> >private> String name;> > >public> Animal(String name) {>this>.name = name; }> > >public> abstract> void> makeSound();> > >public> String getName() {>return> name; }> }> > // Abstracted class> class> Dog>extends> Animal {> >public> Dog(String name) {>super>(name); }> > >public> void> makeSound()> >{> >System.out.println(getName() +>' barks'>);> >}> }> > // Abstracted class> class> Cat>extends> Animal {> >public> Cat(String name) {>super>(name); }> > >public> void> makeSound()> >{> >System.out.println(getName() +>' meows'>);> >}> }> > // Driver Class> public> class> AbstractionExample {> >// Main Function> >public> static> void> main(String[] args)> >{> >Animal myDog =>new> Dog(>'Buddy'>);> >Animal myCat =>new> Cat(>'Fluffy'>);> > >myDog.makeSound();> >myCat.makeSound();> >}> }>

Produzione

java legge il file riga per riga

Buddy barks Fluffy meows>

Spiegazione del programma Java sopra:

Questo codice definisce una classe astratta Animal con un metodo astratto makeSound(). Le classi Dog e Cat estendono Animal e implementano il metodo makeSound(). Il metodo main() crea istanze di Dog e Cat e chiama su di esse il metodo makeSound().

Ciò dimostra il concetto di astrazione in Java, dove definiamo un modello per una classe (in questo caso Animal), ma lasciamo che l'implementazione di determinati metodi sia definita dalle sottoclassi (in questo caso makeSound()).

Interfaccia

Le interfacce sono un altro metodo per implementare l'astrazione in Java. La differenza fondamentale è che, utilizzando le interfacce, possiamo ottenere il 100% di astrazione nelle classi Java. In Java o in qualsiasi altro linguaggio, le interfacce includono sia metodi che variabili ma mancano di un corpo del metodo. Oltre all'astrazione, le interfacce possono essere utilizzate anche per implementare interfacce in Java.

Implementazione: Per implementare un interfaccia usiamo la parola chiave implementa con classe.

Giava

coda di Giava

// Define an interface named Shape> interface> Shape {> >double> calculateArea();>// Abstract method for> >// calculating the area> }> > // Implement the interface in a class named Circle> class> Circle>implements> Shape {> >private> double> radius;> > >// Constructor for Circle> >public> Circle(>double> radius) {>this>.radius = radius; }> > >// Implementing the abstract method from the Shape> >// interface> >public> double> calculateArea()> >{> >return> Math.PI * radius * radius;> >}> }> > // Implement the interface in a class named Rectangle> class> Rectangle>implements> Shape {> >private> double> length;> >private> double> width;> > >// Constructor for Rectangle> >public> Rectangle(>double> length,>double> width)> >{> >this>.length = length;> >this>.width = width;> >}> > >// Implementing the abstract method from the Shape> >// interface> >public> double> calculateArea() {>return> length * width; }> }> > // Main class to test the program> public> class> Main {> >public> static> void> main(String[] args)> >{> >// Creating instances of Circle and Rectangle> >Circle myCircle =>new> Circle(>5.0>);> >Rectangle myRectangle =>new> Rectangle(>4.0>,>6.0>);> > >// Calculating and printing the areas> >System.out.println(>'Area of Circle: '> >+ myCircle.calculateArea());> >System.out.println(>'Area of Rectangle: '> >+ myRectangle.calculateArea());> >}> }>

Produzione

Area of Circle: 78.53981633974483 Area of Rectangle: 24.0>

Vantaggi dell'astrazione

Ecco alcuni vantaggi dell’astrazione:

Riduce la complessità della visione delle cose.
Evita la duplicazione del codice e aumenta la riusabilità.
Aiuta ad aumentare la sicurezza di un'applicazione o di un programma poiché all'utente vengono forniti solo i dettagli essenziali.
Migliora la manutenibilità dell'applicazione.
Migliora la modularità dell'applicazione.
Il miglioramento diventerà molto semplice perché senza influenzare gli utenti finali saremo in grado di eseguire qualsiasi tipo di modifica nel nostro sistema interno.
Migliora la riusabilità e la manutenibilità del codice.
Nasconde i dettagli di implementazione ed espone solo le informazioni rilevanti.
Fornisce un'interfaccia chiara e semplice per l'utente.
Aumenta la sicurezza impedendo l'accesso ai dettagli interni della classe.
Supporta la modularità, poiché i sistemi complessi possono essere suddivisi in parti più piccole e più gestibili.
L'astrazione fornisce un modo per nascondere all'utente la complessità dei dettagli di implementazione, rendendoli più facili da comprendere e utilizzare.
L'astrazione consente flessibilità nell'implementazione di un programma, poiché è possibile apportare modifiche ai dettagli di implementazione sottostanti senza influire sull'interfaccia rivolta all'utente.
L'astrazione consente la modularità e la separazione degli aspetti, rendendo il codice più gestibile e più semplice da eseguire il debug.

Svantaggi dell'astrazione in Java

Ecco i principali svantaggi dell'astrazione in Java:

L’astrazione può rendere più difficile capire come funziona il sistema.
Può portare ad una maggiore complessità, soprattutto se non utilizzato correttamente.
Ciò potrebbe limitare la flessibilità dell’implementazione.
L'astrazione può aggiungere complessità non necessaria al codice se non utilizzata in modo appropriato, comportando un aumento dei tempi e degli sforzi di sviluppo.
L'astrazione può rendere più difficile il debug e la comprensione del codice, in particolare per coloro che non hanno familiarità con i livelli di astrazione e i dettagli di implementazione.
L'uso eccessivo dell'astrazione può comportare una riduzione delle prestazioni a causa dei livelli aggiuntivi di codice e di riferimenti indiretti.