what is abstraction java learn with examples
Aquest tutorial explica què és Abstraction a Java juntament amb exemples de programació. També aprendràs què és una classe abstracta i per què s’utilitza:
En aquesta sèrie JAVA, parlarem de les característiques importants de la programació orientada a objectes (OOP) que també es coneixen com a quatre pilars, és a dir, Abstracció, Encapsulació, Herència i Polimorfisme.
El primer pilar de l'OOP és 'Abstracció'. 'L'abstracció és el procés de selecció de dades per mostrar només a la informació rellevant a l'usuari'.
=> Feu una ullada a la guia per a principiants de Java aquí.
Què aprendreu:
- Abstracció a POO
- Què és l'abstracció a Java
- Diferència entre l’abstracció i l’encapsulació
- Conclusió
Abstracció a POO
En termes senzills, l'abstracció 'mostra' només els atributs rellevants dels objectes i 'amaga' els detalls innecessaris.
Per exemple, quan conduïm un cotxe, només ens preocupa conduir el cotxe com engegar / aturar el vehicle, accelerar-lo / trencar-lo, etc. Simplement no ens interessen aquests detalls.
El que ens preocupa és la visió “abstracta” d’aquestes operacions que ens ajudaran a impulsar el cotxe cap endavant i arribar al nostre destí. Aquest és un exemple senzill d’abstracció.
Per tant, el cotxe té tots els mecanismes i processos al seu lloc, però des de la perspectiva de l’usuari final, és a dir, la perspectiva del conductor, només s’interessarà per la visió abstracta d’aquests processos.
L’abstracció redueix els esforços de programació i, per tant, la complexitat. L’usuari final que utilitza l’aplicació no ha de preocupar-se per com s’implementa una característica concreta. Només pot fer servir les funcions que calgui.
Així, en abstracció, tractem les idees i no els esdeveniments. Això significa que ocultem els detalls de la implementació de l'usuari i exposem només la funcionalitat a l'usuari final. D'aquesta manera, l'usuari només sabrà 'què fa' en lloc de 'com ho fa'.
L’abstracció en POO pot ser de dos tipus.
# 1) Abstracció de dades
En l’abstracció de dades, creem sobretot tipus de dades complexes i amagem la seva implementació. Només exposem les operacions per manipular aquests tipus de dades sense entrar en els detalls de la seva implementació.
Un dels avantatges d’aquest enfocament és que podem canviar la implementació en qualsevol moment sense canviar el comportament exposat a l’usuari.
# 2) Control de l'abstracció
L'abstracció de control recopila totes les declaracions de control que formen part de l'aplicació i les exposa com a unitat. Aquesta funció s’utilitza quan hem de realitzar una funció de treball mitjançant aquesta unitat de control.
L’abstracció de control constitueix la unitat principal de programació estructurada i mitjançant l’abstracció de control podem definir funcions senzilles a marcs complexos.
Què és l'abstracció a Java
Com que Java és un llenguatge OOP, l’abstracció es pot veure com una de les funcions i blocs importants del llenguatge Java. A Java, l’abstracció s’implementa mitjançant una classe i una interfície abstractes.
Llavors, com implementem l’abstracció a Java? Java proporciona un modificador 'resum' sense accés per implementar l'abstracció. Aquest modificador abstracte es pot utilitzar amb classes i mètodes, però no amb variables.
La interfície proporciona una abstracció completa, és a dir, només proporciona prototips de mètodes i no la seva implementació. Una classe abstracta proporciona abstracció parcial en què no s’hauria d’implementar almenys un mètode.
En aquest tutorial, discutirem l'abstracció amb classes abstractes en detall. Explorarem les interfícies en detall als nostres tutorials posteriors.
Exemple d'abstracció de Java
Vegem l’exemple següent.
//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 } } Sortida:
L’exemple d’abstracció simple que es dóna més amunt té una classe Car. En aquesta classe Car, tenim un mètode abstracte per accelerar (). Després heretem aquesta classe a la classe Suzuki. Dins de la classe Suzuki, implementem el mètode accelerar.
L'exemple anterior mostra simplement la forma en què es defineix, s'hereta i després s'utilitza una classe abstracta al programa.
funcions friend a c ++
Què és la classe abstracta de Java
Ja hem esmentat que Java implementa l’abstracció mitjançant classes i interfícies abstractes. Primer explorem tot sobre la classe abstracta.
Una classe abstracta es pot definir com una classe declarada amb la paraula clau 'abstract' i té una restricció que no es pot instanciar.
Una classe abstracta pot tenir o no cap mètode abstracte (un mètode sense implementació). Pel que fa a JVM, una classe abstracta és una classe incompleta que no té un comportament complet.
A continuació es mostra la sintaxi general d’una classe abstracta:
abstract class { public abstract void abstractMethod(); public void normalMethod() { //method body } } Com es mostra a la sintaxi de la classe abstracta anterior, podem tenir mètodes abstractes i no abstractes en una classe abstracta. La paraula clau 'resum' precedeix la declaració de classe.
En poques paraules, es pot descriure una classe abstracta com es mostra a continuació.
Mètode abstracte a Java
Un mètode abstracte és un mètode precedit d'una paraula clau 'abstracta' sense cap implementació. Es declara un mètode abstracte dins d’una classe abstracta.
Un mètode abstracte és el que fa que una classe sigui incompleta ja que no té cap implementació. Per tant, quan incloem un mètode abstracte a la classe, naturalment la classe queda incompleta.
Podem utilitzar el mètode abstracte implementant-lo en una subclasse, és a dir, una classe hereta la classe abstracta i després implementa o proporciona el codi de tots els mètodes abstractes declarats a la classe abstracta substituint-los.
Per tant, es fa obligatori anul·lar el mètode abstracte a la subclasse. Si el mètode abstracte no s’implementa també a la subclasse, hem de declarar-la també com a “abstracta”.
La declaració general del mètode abstracte és:
resum buit methodName (llista_paràmetre);
Mentre escrivim el mètode resum, hem de recordar les regles següents:
- Una classe que conté un o més mètodes abstractes és una classe abstracta.
- Algunes altres paraules clau no s’han d’utilitzar amb la paraula clau abstracta.
Per tant, les combinacions següents són il·legals a Java.
- final
- natiu abstracte
- estàtic abstracte
- privat abstracte
- resum sincronitzat
- strictfp abstracte
Implantem un exemple de classe abstracta i de mètode abstracte.
//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()+'%'); } } Sortida:
A l'exemple anterior, tenim una classe Bank. En aquesta classe, tenim un mètode abstracte, getInterestRate (). A continuació, declarem dues classes: ICICI i BOI que hereten de la classe Bank. Ambdues classes implementen el mètode getInterestRate () retornant els seus tipus d'interès respectius.
millor eliminació de programari maliciós per a Windows 7
A continuació, en el mètode principal, creem un objecte bancari. En primer lloc, l'objecte bancari conté un objecte de la classe ICICI i mostra el tipus d'interès. A continuació, es crea l'objecte BOI i mostra el tipus d'interès.
Per tant, podem suposar que la classe Bank és una mena d’esbós o estructura que ens permet obtenir un tipus d’interès. A partir d’aquesta estructura, podem crear tantes classes concretes com vulguem i, a continuació, podem obtenir els tipus d’interès respectius per a cada objecte bancari (això es mostra al mètode principal).
Per a què serveix una classe abstracta a Java
Per què fem servir una classe abstracta quan en realitat no té cap implementació pròpia?
Juntament amb la resposta a la pregunta anterior, també il·lustrarem com utilitzar una classe abstracta a l'exemple següent.
Vegem un exemple de vehicles. Sabem que els vehicles poden ser de molts tipus. Podem tenir cotxes, patinets, bicicletes, ciclomotors, autobusos, etc. Tot i que hi ha molts tipus de vehicles, tenen algunes propietats o atributs que són comuns a tots els vehicles, independentment del seu tipus.
Per exemple, cada vehicle té un model, número de xassís, color, etc. Cadascun d'ells té funcions com arrencar, aturar, accelerar, frenar, etc. Ara cada vehicle tindrà les propietats i mètodes anteriors que són comuns als altres. Al mateix temps que un usuari de vehicles, és possible que no ens interessin alguns aspectes.
Per exemple, si una persona condueix un cotxe, el que li interessarà és arrencar i aturar el vehicle o accelerar o frenar el vehicle. No li interessarà saber com arrenca o s’atura el vehicle. Només ens interessa el treball abstracte de les funcions i no les seves dades.
Ara bé, si volem representar el sistema d’exemple anterior en una aplicació de programari, com el dissenyem? En primer lloc, implementarem una mica d’abstracció. Ara sabem que algunes funcions són comunes, però depenent de cada model, la implementació d’aquestes funcions serà diferent.
Per començar, declarem una classe abstracta 'Vehicle'.
A continuació, hem mostrat aquest sistema:
Per tant, tindrem una classe abstracta Vehicle i hi haurà una classe concreta que representarà cada model del vehicle. A títol il·lustratiu, només hem utilitzat tres models: cotxe, bicicleta i patinet.
A continuació es mostra la jerarquia de classes del sistema anterior.
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…} } Així, tindrem una classe de resum de vehicles i tres classes de cotxes, bicicletes i scooters. Cadascuna d’aquestes classes ampliarà la classe Vehicle i anul·larà cadascun dels mètodes abstractes.
Per tant, en general, sempre que hem de representar un sistema que tingui mètodes o operacions comunes per representar, per presentar només la perspectiva exterior a l'usuari, apostem per l'abstracció. Com a resultat, traiem els mètodes comuns i els representem com a mètodes abstractes i recopilem aquests mètodes abstractes en una classe abstracta comuna.
Un cop tenim l'esquema d'un sistema representat com una classe abstracta i les operacions com a mètodes abstractes, podem derivar qualsevol nombre de classes de la classe abstracta donada i anul·lar els mètodes abstractes per implementar aquestes operacions per a cada classe.
D'aquesta manera es fa útil dissenyar un sistema.
Classe i interfície abstractes
Hem vist la classe abstracta anterior. Les interfícies són altres elements bàsics que implementen l’abstracció. Les interfícies són contractes i les classes que implementen la interfície han de complir aquests contractes.
Els contractes en interfícies no són res més que mètodes que no s’implementen. Dins de les interfícies, només disposarem de prototips de mètode. No hi haurà una única implementació de mètodes a les interfícies.
Si tenim una declaració d'interfície de la següent manera:
public interface interfaceA{ void myInterfaceMethod (); } A continuació, qualsevol classe que implementi la interfície A necessita anul·lar el 'mètode de la meva interfície'.
Si en absolut no anul·lem el mètode d’una classe, aquesta classe es representa com a abstracta.
abstract class TestClass implements interfaceA{ // not a compulsion to override myInterfaceMethod. } Més endavant tindrem un tutorial separat a la interfície.
A continuació, analitzem algunes de les diferències entre les classes abstractes i les interfícies a Java.
Diferència entre classe abstracta i interfície
| Classe abstracta | Interfície |
|---|---|
| Una classe abstracta pot tenir membres de dades privats o protegits a part dels membres públics. | Els membres de la interfície són públics per defecte. |
| Una classe abstracta pot tenir mètodes abstractes i / o no abstractes. | Una interfície només pot tenir mètodes abstractes. |
| El resum pot contenir o no les variables finals. | Les interfícies poden ser variables finals com a variables per defecte. |
| Una classe abstracta pot tenir variables finals, estàtiques o no estàtiques o no finals. | Les interfícies només poden tenir variables finals i estàtiques. |
| Una classe abstracta pot proporcionar la implementació de la interfície. | Les interfícies no poden implementar una classe abstracta. |
| Una classe abstracta s'hereta mitjançant la paraula clau 'extends'. | La interfície s’implementa mitjançant la paraula clau “implements”. |
| Una classe abstracta pot ampliar altres classes o implementar múltiples interfícies. | La interfície només pot implementar una altra interfície. |
Quan s'utilitza la classe i la interfície abstractes a Java
La decisió sobre quan s'utilitza la classe abstracta i quan s'utilitzen les interfícies a l'aplicació Java s'ha de prendre de manera intel·ligent després d'entendre bé el problema que ens ocupa. Hi ha dos aspectes que hem de tenir en compte com es mostra a continuació.
Classes abstractes amb comportament parcial
Sabem que és possible que les classes abstractes no s’implementin completament menys. Poden tenir un comportament parcial. D’altra banda, les interfícies no tenen cap implementació. Per tant, quan hem de triar entre una classe abstracta i una implementació, hem de tenir en compte aquest aspecte de la nostra aplicació.
Això vol dir que primer hem de decidir si l'aplicació que estem dissenyant té alguna implementació parcial comuna que puguem separar en una classe abstracta.
Per exemple, considerem que estem dissenyant una aplicació web. Per a això, haurem d’utilitzar alguna tecnologia web com Servlet, API REST, etc. Ara, cadascuna d’aquestes tecnologies web té algunes tècniques o passos que s’han d’implementar independentment de l’aplicació que estem desenvolupant. A continuació, creem la nostra aplicació personalitzada.
Per tant, en aquest cas, el codi definit que ha d’executar la tecnologia web es pot incloure en una classe abstracta. Podem tenir una interfície per a això? No, perquè la interfície no pot tenir cap implementació.
Interfícies només de contracte
Sabem que les interfícies tenen contractes o mètodes que en formen part. Aquests mètodes només són prototips. Hem d'implementar aquestes interfícies en una classe i després anul·lar els mètodes.
Ara considerem la interfície de mapa de Java Collections Framework. Moltes classes com HashMap, TreeMap i HashTable, etc. implementen aquesta interfície. Cadascuna d’aquestes classes té una implementació diferent. No tenen cap comportament comú que es pugui representar a la classe abstracta.
Per tant, el que fem és dissenyar una interfície amb prototips de mètodes i després implementar cadascuna de les classes.
D'aquesta manera hauríem de pesar cada factor correctament abans de triar entre una classe abstracta i una interfície.
Diferència entre l’abstracció i l’encapsulació
Analitzem algunes de les diferències entre l’abstracció i una característica més important de la POO, és a dir, l’encapsulació.
| Abstracció | Encapsulació |
|---|---|
| Procés d’obtenció i abstracció de la informació | Procés de vinculació de la informació. |
| La tècnica d’abstracció és a nivell de disseny o interfície. | El mecanisme d’encapsulació es troba a nivell d’implementació. |
| L’abstracció amaga els detalls. | L’encapsulament uneix la informació en una unitat, cosa que garanteix la seguretat de la informació. |
| L’abstracció s’implementa mitjançant interfícies i classes abstractes. | Els modificadors d’accés, és a dir, públics, privats, protegits i per defecte, tenen un paper en l’encapsulació. |
| En abstracció, l’única vista abstracta es presenta a l’usuari mentre s’amaguen a l’usuari dades complexes i detallades. | En l’encapsulació, les dades s’agrupen com una unitat i es poden protegir o fer accessibles mitjançant modificadors d’accés i mètodes getter i setter. |
Preguntes freqüents
P # 1) S’oculten les dades d’abstracció i dades?
Resposta: No, l’abstracció i l’ocultació de dades no són el mateix. Però tots dos són trets importants de la programació orientada a objectes. Tot i que l’abstracció és un procés d’ocultació dels detalls de fons, l’amagament de dades és una tècnica per aïllar les dades de l’accés directe.
Q # 2) Quins són els avantatges de l'abstracció?
Resposta: A continuació es presenten pocs avantatges de l’abstracció:
- Amagant els detalls del fons i exposant només la vista abstracta a l'usuari, l'abstracció fa que el codi sigui més senzill i més llegible.
- Com que l’abstracció protegeix detalls innecessaris, redueix el codi.
- El manteniment del codi pot esdevenir complex i difícil sense abstracció.
P # 3) Per què és tan important l’abstracció?
Resposta: L’abstracció ens permet amagar detalls de fons que són importants i que poden provocar un caos si es filtren al món. En ocultar els detalls de fons i exposar només a la interfície necessària per a l'usuari, l'abstracció fa que les aplicacions siguin més senzilles.
Q # 4) Expliqueu l'abstracció amb un exemple en temps real.
Resposta: Hi ha molts exemples d'abstracció en temps real que inclouen formes geomètriques, vehicles, etc. Un altre exemple és l'ATM (Automated Teller Machine). El caixer automàtic admet operacions com la retirada d’efectiu, la comprovació del saldo, la transferència de diners, etc. Però no som conscients del funcionament intern d’aquestes operacions.
Només se’ns proporciona un monitor amb una interfície d’usuari per seleccionar i realitzar les operacions necessàries.
Q # 5) Podem aconseguir l'abstracció sense encapsulació?
Resposta: L’abstracció protegeix els detalls de la implementació i l’encapsulament amaga els detalls de l’objecte. L’objecte és la forma abstracta del món real i els seus detalls s’amaguen mitjançant l’encapsulació. Per tant, és necessària l’encapsulació per a l’abstracció.
Conclusió
En aquest tutorial, hem debatut sobre l'abstracció a Java en detall. L’abstracció és una tècnica per amagar a l’usuari les dades innecessàries. L'usuari només té accés a les dades pertinents. Les operacions de vehicles o caixers automàtics són exemples clàssics d’abstraccions al món real.
Quan fem servir caixers automàtics, només ens interessa realitzar operacions com la retirada d’efectiu, etc. sense haver de conèixer els detalls sobre com es realitza aquesta operació internament.
Java proporciona abstracció mitjançant classes abstractes i interfícies. Tot i que les interfícies proporcionen un 100% d'abstracció, les classes abstractes proporcionen una abstracció parcial. L'elecció entre interfícies i classes abstractes s'ha de fer en funció de l'aplicació que es vulgui desenvolupar i també de la informació que s'ha d'exposar a l'usuari.
També hem discutit els mètodes abstractes en aquest tutorial juntament amb les diferències entre classes abstractes i interfícies.
=> Consulteu TOTS els tutorials de Java aquí.
Lectura recomanada
- Interfície Java i tutoria de classes abstractes amb exemples
- Java Integer i Java BigInteger Class amb exemples
- Tutorial de classe de Java Scanner amb exemples
- Què és Java Vector | Tutorial de Java Vector Class amb exemples
- Java Enum: Tutorial d’enumeració de Java amb exemples
- Conceptes bàsics de Java: sintaxi de Java, Java Class i conceptes bàsics de Java
- Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java
- Java Iterator: apreneu a utilitzar els iteradors a Java amb exemples