logo

TechCodeview

Abstracció a Java

Abstracció a Java és el procés en el qual només mostrem detalls/funcionalitats essencials a l'usuari. Els detalls d'implementació no essencials no es mostren a l'usuari.

En aquest article, aprendrem sobre l'abstracció i què significa abstracte.

Exemple senzill per entendre l'abstracció:

Comandament a distància de la televisió és un excel·lent exemple d'abstracció . Simplifica la interacció amb un televisor amagant la complexitat darrere de botons i símbols senzills, facilitant-ho sense necessitat d'entendre els detalls tècnics de com funciona el televisor.



Què és l'abstracció a Java?

A Java, l'abstracció s'aconsegueix mitjançant interfícies i classes abstractes . Podem aconseguir el 100% d'abstracció mitjançant interfícies.

L'abstracció de dades també es pot definir com el procés d'identificar només les característiques requerides d'un objecte ignorant els detalls irrellevants. Les propietats i comportaments d'un objecte el diferencien d'altres objectes de tipus similar i també ajuden a classificar/agrupar els objectes.

Abstracció Exemple de la vida real:

Considereu un exemple de la vida real d'un home que condueix un cotxe. L'home només sap que prémer l'accelerador augmentarà la velocitat d'un cotxe o aplicar els frens aturarà el cotxe, però no sap com en prémer l'accelerador augmenta la velocitat, no sap el mecanisme interior del cotxe. o la implantació de l'accelerador, frens, etc al cotxe. Això és el que és l'abstracció.

Classes abstractes de Java i mètodes abstractes de Java

  1. Una classe abstracta és una classe que es declara amb una paraula clau abstracta.
  2. Un mètode abstracte és un mètode que es declara sense implementació.
  3. Una classe abstracta pot tenir o no tots els mètodes abstractes. Alguns d'ells poden ser mètodes concrets
  4. Un resum definit pel mètode sempre s'ha de redefinir a la subclasse, fent així anul·lant obligatòria o fent abstracta la subclasse.
  5. Qualsevol classe que contingui un o més mètodes abstractes també s'ha de declarar amb una paraula clau abstracta.
  6. No hi pot haver cap objecte d'una classe abstracta. És a dir, una classe abstracta no es pot instanciar directament amb el nou operador .
  7. Una classe abstracta pot tenir constructors parametritzats i el constructor per defecte sempre està present en una classe abstracta.

Algorisme per implementar l'abstracció en Java

  1. Determineu les classes o interfícies que formaran part de l'abstracció.
  2. Creeu una classe o interfície abstracta que defineixi els comportaments i propietats comuns d'aquestes classes.
  3. Definiu mètodes abstractes dins de la classe o interfície abstractes que no tinguin cap detall d'implementació.
  4. Implementeu classes concretes que ampliïn la classe abstracta o implementin la interfície.
  5. Anul·leu els mètodes abstractes a les classes concretes per proporcionar les seves implementacions específiques.
  6. Utilitzeu les classes concretes per implementar la lògica del programa.

Quan utilitzar classes abstractes i mètodes abstractes?

Hi ha situacions en què volem definir una superclasse que declari l'estructura d'una abstracció donada sense proporcionar una implementació completa de cada mètode. De vegades volem crear una superclasse que només defineixi una forma de generalització que serà compartida per totes les seves subclasses, deixant que cada subclasse ompli els detalls.

Penseu en un exemple de forma clàssica, potser utilitzat en un sistema de disseny assistit per ordinador o simulació de jocs. El tipus de base és la forma i cada forma té un color, una mida, etc. D'això, se'n deriven (heretats) tipus específics de formes: cercle, quadrat, triangle, etc., cadascuna de les quals pot tenir característiques i comportaments addicionals. Per exemple, certes formes es poden girar. Alguns comportaments poden ser diferents, com ara quan voleu calcular l'àrea d'una forma. La jerarquia de tipus encarna tant les semblances com les diferències entre les formes.

Classe abstracta en Java

Exemple d'abstracció de Java

Exemple 1:

Java


linux $home



// 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());> >}> }> 

>

igualtat d'objectes en java 
>

Sortida 

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>

Exemple 2:

Java




// 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();> >}> }> 

>

>

Sortida 

Buddy barks Fluffy meows>

Explicació del programa Java anterior:

Aquest codi defineix una classe abstracta Animal amb un mètode abstracte makeSound(). Les classes Dog i Cat estenen Animal i implementen el mètode makeSound(). El mètode main() crea instàncies de Dog i Cat i crida al mètode makeSound() sobre ells.

arquitectura de xarxa

Això demostra el concepte d'abstracció a Java, on definim una plantilla per a una classe (en aquest cas Animal), però deixem que la implementació de determinats mètodes sigui definida per subclasses (en aquest cas makeSound()).

Interfície

Les interfícies són un altre mètode per implementar l'abstracció a Java. La diferència clau és que, utilitzant interfícies, podem aconseguir una abstracció del 100% a les classes Java. En Java o qualsevol altre llenguatge, les interfícies inclouen mètodes i variables, però no tenen un cos de mètode. A part de l'abstracció, les interfícies també es poden utilitzar per implementar interfícies en Java.

Implementació: Per implementar un interfície fem servir la paraula clau implements amb classe.

Java




// 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());> >}> }> 

>

derivada parcial del làtex 

>

Sortida 

Area of Circle: 78.53981633974483 Area of Rectangle: 24.0>

Avantatges de l'abstracció

Aquests són alguns dels avantatges de l'abstracció:

  1. Redueix la complexitat de veure coses.
  2. Evita la duplicació de codi i augmenta la reutilització.
  3. Ajuda a augmentar la seguretat d'una aplicació o programa, ja que només es proporcionen a l'usuari els detalls essencials.
  4. Millora el manteniment de l'aplicació.
  5. Millora la modularitat de l'aplicació.
  6. La millora serà molt fàcil perquè sense afectar els usuaris finals podrem realitzar qualsevol tipus de canvi en el nostre sistema intern.
  7. Millora la reutilització i el manteniment del codi.
  8. Amaga els detalls de la implementació i només exposa informació rellevant.
  9. Proporciona una interfície clara i senzilla per a l'usuari.
  10. Augmenta la seguretat impedint l'accés als detalls interns de la classe.
  11. Admet la modularitat, ja que els sistemes complexos es poden dividir en parts més petites i més manejables.
  12. L'abstracció proporciona una manera d'ocultar la complexitat dels detalls d'implementació per a l'usuari, facilitant-ne la comprensió i l'ús.
  13. L'abstracció permet flexibilitat en la implementació d'un programa, ja que es poden fer canvis als detalls de la implementació subjacents sense afectar la interfície orientada a l'usuari.
  14. L'abstracció permet la modularitat i la separació de les preocupacions, fent que el codi sigui més fàcil de mantenir i de depurar.

Inconvenients de l'abstracció a Java

Aquests són els principals desavantatges de l'abstracció a Java:

  1. L'abstracció pot dificultar la comprensió del funcionament del sistema.
  2. Pot augmentar la complexitat, sobretot si no s'utilitza correctament.
  3. Això pot limitar la flexibilitat de la implementació.
  4. L'abstracció pot afegir complexitat innecessària al codi si no s'utilitza adequadament, la qual cosa comporta un augment del temps i l'esforç de desenvolupament.
  5. L'abstracció pot dificultar la depuració i la comprensió del codi, especialment per a aquells que no estan familiaritzats amb les capes d'abstracció i els detalls d'implementació.
  6. L'ús excessiu de l'abstracció pot provocar una disminució del rendiment a causa de les capes addicionals de codi i indirecte.

Llegeix també:

Abstracció a Java - Preguntes freqüents

Q1. Per què fem servir abstracte?

Una raó clau per la qual fem servir conceptes abstractes és simplificar la complexitat. Imagineu-vos intentar explicar l'univers sencer amb cada àtom i estrella! Els resums ens permeten allunyar-nos, agafar les idees principals com la gravetat i l'energia i donar-li sentit a tot sense perdre'ns en els detalls.

Aquestes són algunes altres raons per les quals utilitzem abstracte a Java:

1. Abstracció : Les classes abstractes s'utilitzen per definir una plantilla genèrica per a altres classes a seguir. Defineixen un conjunt de regles i directrius que les seves subclasses han de seguir. En proporcionar una classe abstracta, ens podem assegurar que les classes que l'estenen tenen una estructura i un comportament coherents. Això fa que el codi sigui més organitzat i més fàcil de mantenir.

2. Polimorfisme : Les classes i mètodes abstractes permeten el polimorfisme a Java. El polimorfisme és la capacitat que té un objecte de prendre moltes formes. Això vol dir que una variable de tipus abstracte pot contenir objectes de qualsevol subclasse concreta d'aquesta classe abstracta. Això fa que el codi sigui més flexible i adaptable a diferents situacions.

3. Marcs i API: Java té nombrosos marcs i API que utilitzen classes abstractes. Mitjançant l'ús de classes abstractes, els desenvolupadors poden estalviar temps i esforç basant-se en el codi existent i centrant-se en els aspectes específics de les seves aplicacions.

P2. Quina és la diferència entre Encapsulació i abstracció de dades?

Aquí hi ha algunes diferències clau en l'encapsulació i l'abstració b/n:

Encapsulació

Abstracció
L'encapsulació s'amaga dades (amaga informació) L'abstracció és un ocultament detallat (amagat d'implementació).
L'encapsulació agrupa dades i mètodes que actuen sobre les dades L'abstracció de dades tracta d'exposar la interfície a l'usuari i ocultar els detalls de la implementació
Les classes encapsulades són classes Java que segueixen l'amagat i l'abstracció de dades La implementació de l'abstracció es fa mitjançant classes abstractes i interfície
L'encapsulació és un procediment que té lloc a nivell d'implementació l'abstracció és un procés a nivell de disseny

P3. Quin és un exemple real d'abstracció de dades?

Comandament a distància de la televisió és un excel·lent exemple d'abstracció de la vida real. Simplifica la interacció amb un televisor amagant la complexitat darrere de botons i símbols senzills, facilitant-ho sense necessitat d'entendre els detalls tècnics de com funciona el televisor.

P4. Quina diferència hi ha entre les classes abstractes i les interfícies a Java?

Aquí hi ha algunes diferències clau b/w Classes abstractes i interfícies a Java:

Classe abstracta

fitxers linux

Interfícies
Les classes abstractes admeten mètodes abstractes i no abstractes Els suports d'interfície només tenen mètodes abstractes.
No admet l'herència múltiple Admet l'herència múltiple
Les classes abstractes es poden ampliar amb classes Java i múltiples interfícies La interfície només es pot ampliar amb la interfície Java.
Els membres de la classe abstracta a Java poden ser privats, protegits, etc. Les interfícies són públiques per defecte.

Exemple:

Vehicle de classe abstracta pública{
unitat de buit abstracta pública ()
}

Exemple:

interfície pública animal{
void parlar();
}