what is abstraction java learn with examples
Questo tutorial spiega cos'è Abstraction in Java insieme a esempi di programmazione. Imparerai anche cos'è una classe astratta e perché viene utilizzata:
In questa serie JAVA, discuteremo le caratteristiche importanti della programmazione orientata agli oggetti (OOP), note anche come quattro pilastri, ovvero astrazione, incapsulamento, ereditarietà e polimorfismo.
Il primo pilastro di OOP è 'Astrazione'. 'L'astrazione è il processo di selezione dei dati per mostrare all'utente solo le informazioni pertinenti.'
=> Dai un'occhiata alla guida per principianti di Java qui.
Cosa imparerai:
Astrazione in OOP
In termini semplici, l'astrazione 'mostra' solo gli attributi rilevanti degli oggetti e 'nasconde' i dettagli non necessari.
Per esempio, quando guidiamo un'auto, ci preoccupiamo solo di guidare l'auto come avviare / arrestare l'auto, accelerare / frenare, ecc. Non ci preoccupiamo di come funziona internamente il meccanismo di avvio / arresto effettivo o il processo di accelerazione / frenata. Semplicemente non siamo interessati a quei dettagli.
Quello che ci interessa è la visione 'astratta' di queste operazioni che ci aiuterà a spingere avanti la macchina e raggiungere la nostra destinazione. Questo è un semplice esempio di astrazione.
Quindi l'auto ha tutti i meccanismi e i processi in atto, ma dal punto di vista dell'utente finale, cioè dal punto di vista del conducente dell'auto, sarà interessato solo alla visione astratta di questi processi.
L'astrazione riduce gli sforzi di programmazione e quindi la complessità. Un utente finale che utilizza l'applicazione non deve preoccuparsi di come viene implementata una particolare funzionalità. Lui / lei può semplicemente utilizzare le funzionalità come richiesto.
Così nell'astrazione ci occupiamo di idee e non di eventi. Ciò significa che nascondiamo i dettagli di implementazione all'utente ed esponiamo solo la funzionalità all'utente finale. In questo modo l'utente saprà solo 'cosa fa' anziché 'come fa'.
L'astrazione in OOP può essere di due tipi.
# 1) Astrazione dei dati
Nell'astrazione dei dati, creiamo principalmente tipi di dati complessi e ne nascondiamo l'implementazione. Esponiamo solo le operazioni per manipolare questi tipi di dati senza entrare nei dettagli della loro implementazione.
Un vantaggio di questo approccio è che possiamo modificare l'implementazione in qualsiasi momento senza modificare il comportamento esposto all'utente.
# 2) Controlla l'astrazione
L'astrazione del controllo raccoglie tutte le istruzioni di controllo che fanno parte dell'applicazione e le espone come un'unità. Questa funzione viene utilizzata quando dobbiamo eseguire una funzione di lavoro utilizzando questa unità di controllo.
come creare un array generico in java
L'astrazione dei controlli costituisce l'unità principale della programmazione strutturata e utilizzando l'astrazione dei controlli possiamo definire semplici funzioni in framework complessi.
Cos'è l'astrazione in Java
Poiché Java è un linguaggio OOP, l'astrazione può essere vista come una delle caratteristiche e degli elementi costitutivi importanti del linguaggio Java. In Java, l'astrazione viene implementata utilizzando una classe e un'interfaccia astratte.
Quindi come implementiamo l'astrazione in Java? Java fornisce un modificatore di non accesso 'abstract' per l'implementazione dell'astrazione. Questo modificatore astratto può essere utilizzato con classi e metodi ma non con variabili.
L'interfaccia fornisce un'astrazione completa, ovvero fornisce solo prototipi di metodi e non la loro implementazione. Una classe astratta fornisce un'astrazione parziale in cui almeno un metodo non dovrebbe essere implementato.
In questo tutorial, discuteremo in dettaglio l'astrazione con le classi astratte. Esploreremo le interfacce in dettaglio nei nostri tutorial successivi.
Esempio di astrazione Java
Consideriamo l'esempio seguente.
//abstract class abstract class Car{ abstract void accelerate(); } //concrete class class Suzuki extends Car{ void accelerate(){ System.out.println('Suzuki::accelerate'); } } class Main{ public static void main(String args()){ Car obj = new Suzuki(); //Car object =>contents of Suzuki obj.accelerate(); //call the method } }
Produzione:
Il semplice esempio di astrazione fornito sopra ha una classe Auto. In questa classe Car, abbiamo un metodo astratto per accelerate (). Quindi ereditiamo questa classe nella classe Suzuki. All'interno della classe Suzuki, implementiamo il metodo accelerate.
L'esempio precedente mostra semplicemente il modo in cui una classe astratta viene definita, ereditata e quindi utilizzata nel programma.
Cos'è Java Abstract Class
Abbiamo già detto che Java implementa l'astrazione usando classi e interfacce astratte. Esploriamo prima tutto sulla classe astratta.
Una classe astratta può essere definita come una classe dichiarata con la parola chiave 'abstract' e ha una restrizione che non può essere istanziata.
Una classe astratta può o non può avere alcun metodo astratto (un metodo senza implementazione). Per quanto riguarda JVM, una classe astratta è una classe incompleta che non ha un comportamento completo.
miglior software per migliorare le prestazioni del PC
Di seguito viene fornita la sintassi generale di una classe astratta:
abstract class { public abstract void abstractMethod(); public void normalMethod() { //method body } }
Come mostrato nella sintassi della classe astratta sopra, possiamo avere metodi astratti e non astratti in una classe astratta. La parola chiave 'abstract' precede la dichiarazione della classe.
In poche parole, una classe astratta può essere descritta come mostrato di seguito.
Metodo astratto in Java
Un metodo astratto è un metodo preceduto da una parola chiave 'astratta' senza alcuna implementazione. Un metodo astratto viene dichiarato all'interno di una classe astratta.
Un metodo astratto è quello che rende una classe incompleta in quanto non ha un'implementazione. Quindi quando includiamo un metodo astratto nella classe, naturalmente la classe diventa incompleta.
Possiamo usare il metodo astratto implementandolo in una sottoclasse, ovvero una classe eredita la classe astratta e quindi implementa o fornisce il codice per tutti i metodi astratti dichiarati nella classe astratta sovrascrivendoli.
Diventa quindi obbligatorio ignorare il metodo astratto nella sottoclasse. Se il metodo astratto non è implementato anche nella sottoclasse, allora dobbiamo dichiarare anche la sottoclasse come 'astratta'.
La dichiarazione generale del metodo astratto è:
astratto vuoto methodName (parameter_list);
Durante la scrittura del metodo astratto, dobbiamo ricordare le seguenti regole:
- Una classe contenente uno o più metodi astratti è una classe astratta.
- Alcune altre parole chiave non devono essere utilizzate con la parola chiave abstract.
Pertanto, le seguenti combinazioni sono illegali in Java.
- finale
- nativo astratto
- statica astratta
- privato astratto
- astratto sincronizzato
- abstract strictfp
Implementiamo un esempio di una classe astratta e un metodo astratto.
//abstract class abstract class Bank{ abstract int getInterestRate(); } //concrete class class Citi extends Bank{ int getInterestRate(){return 7;} } //concrete class class HSBC extends Bank{ int getInterestRate(){return 6;} } class Main{ public static void main(String args()){ Bank b; b = new Citi (); // concrete class object System.out.println('Citi Rate of Interest is: '+b.getInterestRate()+'%'); b = new HSBC (); // concrete class object System.out.println('HSBC Rate of Interest is: '+b.getInterestRate()+'%'); } }
Produzione:
Nell'esempio sopra, abbiamo una classe Bank. In questa classe, abbiamo un metodo astratto, getInterestRate (). Quindi dichiariamo due classi - ICICI e BOI che ereditano dalla classe Bank. Entrambe queste classi implementano il metodo getInterestRate () restituendo i rispettivi tassi di interesse.
Quindi, nel metodo principale, creiamo un oggetto banca. Innanzitutto, l'oggetto banca contiene un oggetto della classe ICICI e visualizza il tasso di interesse. Successivamente, l'oggetto BOI viene creato e visualizza il tasso di interesse.
Quindi, possiamo supporre che la classe Bank sia una sorta di schizzo o di una struttura che ci consente di ottenere un tasso di interesse. Da questa struttura, possiamo creare tutte le classi concrete che vogliamo e quindi possiamo ottenere i rispettivi tassi di interesse per ogni oggetto banca (questo è mostrato nel metodo principale).
Qual è l'uso di una classe astratta in Java
Perché usiamo una classe astratta quando in realtà non ha alcuna implementazione propria?
Insieme alla risposta alla domanda precedente, illustreremo anche come utilizzare una classe astratta nell'esempio che segue.
Consideriamo un esempio di veicoli. Sappiamo che i veicoli possono essere di molti tipi. Possiamo avere auto, scooter, biciclette, ciclomotori, autobus, ecc. Anche se ci sono molti tipi di veicoli, hanno alcune proprietà o attributi che sono comuni a tutti i veicoli indipendentemente dal tipo.
Per esempio, ogni veicolo ha un modello, numero di telaio, colore, ecc. Ognuno di essi ha funzioni come avviamento, arresto, accelerazione, freno, ecc. Ora ogni veicolo avrà le proprietà e i metodi di cui sopra che sono comuni anche agli altri. Allo stesso tempo come utente di un veicolo, potremmo non essere interessati ad alcuni aspetti.
Per esempio, se una persona è alla guida di un'auto, ciò che gli interesserà sarà solo avviare e fermare il veicolo o accelerare o frenare il veicolo. Non sarà interessato a sapere come il veicolo si avvia o si ferma. Ci interessa solo il funzionamento astratto delle funzioni e non i loro dettagli.
Ora, se vogliamo rappresentare il sistema di esempio sopra in un'applicazione software, allora come lo progettiamo? Prima di tutto, implementeremo alcune astrazioni. Ora, sappiamo che alcune funzioni sono comuni ma a seconda di ogni modello l'implementazione di queste funzioni sarà diversa.
Per cominciare, dichiariamo una classe astratta 'Veicolo'.
Abbiamo mostrato questo sistema di seguito:
Quindi avremo una classe astratta Veicolo e ci sarà una classe concreta che rappresenterà ogni modello del veicolo. A scopo illustrativo, abbiamo utilizzato solo tre modelli, ovvero auto, bici e scooter.
Di seguito è riportata la gerarchia delle classi del sistema precedente.
abstract class Vehicle{ abstract void start () ; abstract void stop (); abstract void accelerate (); abstract void brake (); } class Car extends Vehicle{ void start () { //code here…} void stop () { //code here…} void accelerate () { //code here…} void brake () { //code here…} } class Bike extends Vehicle{ void start () { //code here…} void stop () { //code here…} void accelerate () { //code here…} void brake () { //code here…} } class Scooter extends Vehicle{ void start () { //code here…} void stop () { //code here…} void accelerate () { //code here…} void brake () { //code here…} }
Quindi avremo una classe astratta Veicolo e tre classi Auto, Moto e Scooter. Ciascuna di queste classi estenderà la classe Vehicle e sovrascriverà ciascuno dei metodi astratti.
Quindi, in generale, ogni volta che dobbiamo rappresentare un tale sistema che ha metodi o operazioni comuni da rappresentare, quindi per presentare all'utente solo la prospettiva esterna, andiamo per l'astrazione. Di conseguenza, estraiamo i metodi comuni e li rappresentiamo come metodi astratti e raccogliamo questi metodi astratti in una classe astratta comune.
Una volta che abbiamo lo schema di un sistema rappresentato come una classe astratta e le operazioni come metodi astratti, possiamo quindi derivare un numero qualsiasi di classi dalla classe astratta data e sovrascrivere i metodi astratti per implementare queste operazioni per ciascuna classe.
In questo modo diventa utile progettare un sistema.
Classe E Interfaccia Astratte
Abbiamo visto la classe astratta sopra. Le interfacce sono ancora altri elementi costitutivi che implementano l'astrazione. Le interfacce sono contratti e le classi che implementano l'interfaccia devono onorare questi contratti.
I contratti nelle interfacce non sono altro che metodi non implementati. All'interno delle interfacce, avremo solo prototipi di metodo. Non ci sarà una singola implementazione di metodi all'interno delle interfacce.
Se abbiamo una dichiarazione di interfaccia come segue:
public interface interfaceA{ void myInterfaceMethod (); }
Quindi qualsiasi classe che implementa l'interfacciaA deve sovrascrivere 'myInterfaceMethod'.
Se non sovrascriviamo affatto il metodo in una classe, allora quella classe è rappresentata come astratta.
abstract class TestClass implements interfaceA{ // not a compulsion to override myInterfaceMethod. }
In seguito avremo un tutorial separato sull'interfaccia.
Successivamente, discutiamo alcune delle differenze tra le classi Abstract e le interfacce in Java.
Differenza tra classe astratta e interfaccia
Classe astratta | Interfaccia |
---|---|
Una classe astratta può avere membri dati privati o protetti oltre ai membri pubblici. | I membri dell'interfaccia sono pubblici per impostazione predefinita. |
Una classe astratta può avere metodi astratti e / o non astratti. | Un'interfaccia può avere solo metodi astratti. |
L'abstract può contenere o meno le variabili finali. | Le interfacce possono definire variabili finali come variabili predefinite. |
Una classe astratta può avere variabili finali, statiche o non statiche o non finali. | Le interfacce possono avere solo variabili finali e statiche. |
Una classe astratta può fornire l'implementazione dell'interfaccia. | Le interfacce non possono implementare una classe astratta. |
Una classe astratta viene ereditata utilizzando la parola chiave 'extends'. | L'interfaccia viene implementata utilizzando la parola chiave 'implements'. |
Una classe astratta può estendere altre classi o implementare più interfacce. | L'interfaccia può implementare solo un'altra interfaccia. |
Quando utilizzare la classe astratta e l'interfaccia in Java
La decisione su quando utilizzare la classe astratta e quando utilizzare le interfacce nell'applicazione Java dovrebbe essere presa in modo intelligente dopo aver compreso a fondo il problema in questione. Ci sono due aspetti che dobbiamo considerare come mostrato di seguito.
Classi astratte con comportamento parziale
Sappiamo che le classi astratte potrebbero non essere completamente implementate di meno. Possono avere un comportamento parziale. D'altra parte, le interfacce non hanno alcuna implementazione. Quindi, quando dobbiamo scegliere tra una classe astratta e un'implementazione, dobbiamo considerare questo aspetto della nostra applicazione.
Ciò significa che dobbiamo prima decidere se l'applicazione che stiamo progettando ha un'implementazione parziale comune che possiamo separare in una classe astratta.
Per esempio, considera che stiamo progettando un'applicazione web. Per questo, dovremo utilizzare alcune tecnologie web come Servlet, API REST, ecc. Ora ciascuna di queste tecnologie web ha alcune tecniche o passaggi che devono essere implementati indipendentemente dall'applicazione che stiamo sviluppando. Quindi costruiamo la nostra applicazione personalizzata.
Quindi, in questo caso, il codice definito che la tecnologia web deve eseguire può essere inserito in una classe astratta. Possiamo avere un'interfaccia per questo? No. Questo perché l'interfaccia non può avere un'implementazione.
Interfacce solo contratto
Sappiamo che le interfacce hanno contratti o metodi che ne fanno parte. Questi metodi sono solo prototipi. Dobbiamo implementare queste interfacce in una classe e quindi sovrascrivere i metodi.
qual è il miglior account di posta elettronica
Consideriamo ora l'interfaccia Map di Java Collections Framework. Molte classi come HashMap, TreeMap e HashTable, ecc. Implementano questa interfaccia. Ciascuna di queste classi ha un'implementazione diversa. Non hanno alcun comportamento comune che possa essere rappresentato nella classe astratta.
Quindi quello che facciamo è progettare un'interfaccia con prototipi di metodi e quindi implementare ciascuna delle classi.
In questo modo dovremmo valutare correttamente ogni fattore prima di scegliere tra una classe astratta e un'interfaccia.
Differenza tra astrazione e incapsulamento
Discutiamo alcune delle differenze tra l'astrazione e un'altra caratteristica importante dell'OOP, ovvero l'incapsulamento.
Astrazione | Incapsulamento |
---|---|
Processo di acquisizione e astrazione delle informazioni | Processo di associazione delle informazioni. |
La tecnica di astrazione è a livello di progettazione o interfaccia. | Il meccanismo di incapsulamento è a livello di implementazione. |
L'astrazione nasconde i dettagli. | L'incapsulamento lega le informazioni in un'unità garantendo la sicurezza delle informazioni. |
L'astrazione viene implementata utilizzando classi e interfacce astratte. | I modificatori di accesso, vale a dire pubblico, privato e protetto e predefinito, giocano un ruolo nell'incapsulamento. |
Nell'astrazione, all'utente viene presentata l'unica vista astratta mentre i dati complessi e dettagliati sono nascosti all'utente. | Nell'incapsulamento, i dati vengono raggruppati come un'unità e possono essere protetti o resi accessibili utilizzando modificatori di accesso e metodi getter e setter. |
Domande frequenti
D # 1) Astrazione e dati si nascondono allo stesso modo?
Risposta: No, l'astrazione e l'occultamento dei dati non sono la stessa cosa. Ma entrambe sono caratteristiche importanti della programmazione orientata agli oggetti. Mentre l'astrazione è un processo per nascondere i dettagli di sfondo, l'occultamento dei dati è una tecnica per isolare i dati dall'accesso diretto.
D # 2) Quali sono i vantaggi dell'astrazione?
Risposta: Di seguito sono riportati alcuni vantaggi di Abstraction:
- Nascondendo i dettagli dello sfondo ed esponendo all'utente solo la vista astratta, l'astrazione rende il codice più semplice e leggibile.
- Poiché l'astrazione protegge i dettagli non necessari, riduce le dimensioni del codice.
- La manutenzione del codice può diventare complessa e difficile senza astrazioni.
D # 3) Perché l'astrazione è così importante?
Risposta: L'astrazione ci consente di nascondere i dettagli di sfondo che sono importanti e possono portare al caos se trapelati nel mondo. Nascondendo i dettagli dello sfondo ed esponendo all'utente solo l'interfaccia richiesta, l'astrazione rende le applicazioni più semplici.
D # 4) Spiega l'astrazione con un esempio in tempo reale.
Risposta: Ci sono molti esempi in tempo reale di astrazione tra cui forme geometriche, veicoli, ecc. Un altro esempio è l'ATM (Automated Teller Machine). L'ATM supporta operazioni come prelievo di contanti, controllo del saldo, trasferimento di denaro, ecc. Ma non siamo a conoscenza di come funzionino internamente queste operazioni.
Ci viene fornito solo un monitor con un'interfaccia utente per selezionare ed eseguire le operazioni richieste.
D # 5) Possiamo ottenere l'astrazione senza l'incapsulamento?
Risposta: L'astrazione protegge i dettagli dell'implementazione e l'incapsulamento nasconde i dettagli dell'oggetto. L'oggetto è la forma astratta del mondo reale ei suoi dettagli sono nascosti mediante l'incapsulamento. Quindi l'incapsulamento è necessario per l'astrazione.
Conclusione
In questo tutorial, abbiamo discusso in dettaglio l'astrazione in Java. L'astrazione è una tecnica per nascondere all'utente dettagli non necessari. L'utente ha accesso solo ai dettagli rilevanti. Le operazioni sui veicoli o le operazioni ATM sono classici esempi di astrazioni nel mondo reale.
Quando usiamo ATM, siamo interessati solo a eseguire operazioni come il prelievo di contanti, ecc. Senza dover conoscere i dettagli su come esattamente tale operazione viene eseguita internamente.
Java fornisce l'astrazione tramite classi e interfacce astratte. Mentre le interfacce forniscono un'astrazione al 100%, le classi astratte forniscono un'astrazione parziale. La scelta tra interfacce e classi astratte dovrebbe essere fatta a seconda dell'applicazione da sviluppare e anche delle informazioni che devono essere esposte all'utente.
Abbiamo anche discusso i metodi astratti in questo tutorial insieme alle differenze tra classi astratte e interfacce.
=> Controlla TUTTI i tutorial Java qui.
Lettura consigliata
- Tutorial sull'interfaccia Java e sulla classe astratta con esempi
- Java Integer e Java BigInteger Class con esempi
- Tutorial di classe per scanner Java con esempi
- Cos'è Java Vector | Tutorial Java Vector Class con esempi
- Java Enum: Tutorial sull'enumerazione Java con esempi
- Nozioni di base su Java: sintassi Java, classe Java e concetti principali di Java
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Iteratore Java: impara a utilizzare gli iteratori in Java con esempi