Abstraktion i Java er den proces, hvor vi kun viser væsentlige detaljer/funktionalitet til brugeren. De ikke-essentielle implementeringsdetaljer vises ikke til brugeren.
I denne artikel lærer vi om abstraktion og hvad abstrakt betyder.
Simpelt eksempel til at forstå abstraktion:
Fjernbetjening til fjernsyn er en fremragende eksempel på abstraktion . Det forenkler interaktionen med et tv ved at skjule kompleksiteten bag simple knapper og symboler, hvilket gør det nemt uden at skulle forstå de tekniske detaljer om, hvordan tv'et fungerer.
Hvad er abstraktion i Java?
I Java opnås abstraktion ved grænseflader og abstrakte klasser . Vi kan opnå 100% abstraktion ved hjælp af grænseflader.
Dataabstraktion kan også defineres som processen med kun at identificere de krævede egenskaber ved et objekt og ignorere de irrelevante detaljer. Et objekts egenskaber og adfærd adskiller det fra andre objekter af lignende type og hjælper også med at klassificere/gruppere objekterne.
Abstraktionseksempel i det virkelige liv:
Overvej et virkeligt eksempel på en mand, der kører bil. Manden ved kun, at et tryk på speederen vil øge hastigheden på en bil, eller at bruge bremser vil stoppe bilen, men han ved ikke, hvordan hastigheden faktisk stiger, når han trykker på speederen, han kender ikke til bilens indre mekanisme eller implementering af speederen, bremserne osv. i bilen. Det er hvad abstraktion er.
Java abstrakt klasser og Java abstrakt metoder
- En abstrakt klasse er en klasse, der er erklæret med et abstrakt nøgleord.
- En abstrakt metode er en metode, der erklæres uden implementering.
- En abstrakt klasse kan have eller ikke have alle abstrakte metoder. Nogle af dem kan være konkrete metoder
- Et metodedefineret abstrakt skal altid omdefineres i underklassen, hvilket gør tilsidesættende obligatorisk eller gør selve underklassen abstrakt.
- Enhver klasse, der indeholder en eller flere abstrakte metoder, skal også erklæres med et abstrakt nøgleord.
- Der kan ikke være noget objekt af en abstrakt klasse. Det vil sige, at en abstrakt klasse ikke kan instansieres direkte med ny operatør .
- En abstrakt klasse kan have parametriserede konstruktører, og standardkonstruktøren er altid til stede i en abstrakt klasse.
Algoritme til at implementere abstraktion i Java
- Bestem de klasser eller grænseflader, der vil være en del af abstraktionen.
- Opret en abstrakt klasse eller grænseflade, der definerer den almindelige adfærd og egenskaber for disse klasser.
- Definer abstrakte metoder inden for den abstrakte klasse eller grænseflade, der ikke har nogen implementeringsdetaljer.
- Implementer konkrete klasser, der udvider den abstrakte klasse eller implementerer grænsefladen.
- Tilsidesæt de abstrakte metoder i de konkrete klasser for at give deres specifikke implementeringer.
- Brug de konkrete klasser til at implementere programlogikken.
Hvornår skal man bruge abstrakte klasser og abstrakte metoder?
Der er situationer, hvor vi ønsker at definere en superklasse, der erklærer strukturen af en given abstraktion uden at give en fuldstændig implementering af hver metode. Nogle gange vil vi gerne oprette en superklasse, der kun definerer en generaliseringsform, der vil blive delt af alle dens underklasser, og overlader det til hver underklasse at udfylde detaljerne.
Overvej et klassisk formeksempel, måske brugt i et computerstøttet designsystem eller spilsimulering. Basistypen er form, og hver form har en farve, størrelse og så videre. Herfra afledes (nedarvet) specifikke former for former - cirkel, firkant, trekant og så videre - som hver især kan have yderligere egenskaber og adfærd. For eksempel kan visse former vendes. Nogle adfærd kan være anderledes, såsom når du vil beregne arealet af en figur. Typehierarkiet inkarnerer både ligheder og forskelle mellem formerne.
Abstrakt klasse i Java
Eksempel på Java-abstraktion
Eksempel 1:
Java
java anonym funktion
// 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());> > }> }> |
>
css understregningstekst
>Produktion
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>
Eksempel 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();> > }> }> |
>
>Produktion
Buddy barks Fluffy meows>
Forklaring af ovenstående Java-program:
Denne kode definerer en Animal abstrakt klasse med en abstrakt metode makeSound(). Hund- og kat-klasserne udvider Animal og implementerer makeSound()-metoden. Main()-metoden opretter forekomster af Dog and Cat og kalder makeSound()-metoden på dem.
python-programlisteDette demonstrerer abstraktionskonceptet i Java, hvor vi definerer en skabelon for en klasse (i dette tilfælde Animal), men lader implementeringen af visse metoder blive defineret af underklasser (i dette tilfælde makeSound()).
Interface
Grænseflader er en anden metode til at implementere abstraktion i Java. Den vigtigste forskel er, at vi ved at bruge grænseflader kan opnå 100% abstraktion i Java-klasser. I Java eller et hvilket som helst andet sprog inkluderer grænseflader både metoder og variabler, men mangler en metodetekst. Udover abstraktion kan grænseflader også bruges til at implementere grænseflader i Java.
Implementering: At implementere en interface vi bruger søgeordet redskaber med klasse.
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());> > }> }> |
>
java understreng
>Produktion
Area of Circle: 78.53981633974483 Area of Rectangle: 24.0>
Fordele ved abstraktion
Her er nogle fordele ved abstraktion:
- Det reducerer kompleksiteten af at se ting.
- Undgår kodeduplikering og øger genanvendeligheden.
- Hjælper med at øge sikkerheden for en applikation eller et program, da kun væsentlige detaljer gives til brugeren.
- Det forbedrer vedligeholdelsen af applikationen.
- Det forbedrer applikationens modularitet.
- Forbedringen bliver meget nem, fordi vi uden at påvirke slutbrugerne kan udføre enhver form for ændringer i vores interne system.
- Forbedrer kodegenanvendelighed og vedligeholdelse.
- Skjuler implementeringsdetaljer og afslører kun relevante oplysninger.
- Giver en klar og enkel grænseflade til brugeren.
- Øger sikkerheden ved at forhindre adgang til interne klassedetaljer.
- Understøtter modularitet, da komplekse systemer kan opdeles i mindre og mere overskuelige dele.
- Abstraktion giver en måde at skjule kompleksiteten af implementeringsdetaljer for brugeren, hvilket gør det lettere at forstå og bruge.
- Abstraktion giver mulighed for fleksibilitet i implementeringen af et program, da ændringer i de underliggende implementeringsdetaljer kan foretages uden at påvirke den brugervendte grænseflade.
- Abstraktion muliggør modularitet og adskillelse af bekymringer, hvilket gør koden mere vedligeholdelsesvenlig og lettere at fejlfinde.
Ulemper ved abstraktion i Java
Her er de største ulemper ved abstraktion i Java:
- Abstraktion kan gøre det sværere at forstå, hvordan systemet fungerer.
- Det kan føre til øget kompleksitet, især hvis det ikke bruges korrekt.
- Dette kan begrænse fleksibiliteten i implementeringen.
- Abstraktion kan tilføje unødvendig kompleksitet til koden, hvis den ikke bruges korrekt, hvilket fører til øget udviklingstid og indsats.
- Abstraktion kan gøre det sværere at fejlfinde og forstå kode, især for dem, der ikke er bekendt med abstraktionslagene og implementeringsdetaljerne.
- Overforbrug af abstraktion kan resultere i nedsat ydeevne på grund af de ekstra lag af kode og indirekte.
Læs også:
- Grænseflader i Java
- Abstrakte klasser i Java
- Forskellen mellem abstrakt klasse og interface
- abstrakt søgeord i Java
Abstraktion i Java – ofte stillede spørgsmål
Q1. Hvorfor bruger vi abstrakt?
En vigtig grund til, at vi bruger abstrakte begreber, er at forenkle kompleksitet. Forestil dig at prøve at forklare hele universet med hvert enkelt atom og stjerne! Abstrakter lader os zoome ud, få fat i hovedideerne som tyngdekraft og energi og give mening ud af det hele uden at gå tabt i detaljerne.
Her er nogle andre grunde til, at vi bruger abstrakt i Java:
1. Abstraktion : Abstrakte klasser bruges til at definere en generisk skabelon, som andre klasser kan følge. De definerer et sæt regler og retningslinjer, som deres underklasser skal følge. Ved at levere en abstrakt klasse kan vi sikre, at de klasser, der udvider den, har en konsistent struktur og adfærd. Dette gør koden mere organiseret og nemmere at vedligeholde.
2. Polymorfi : Abstrakte klasser og metoder muliggør polymorfi i Java. Polymorfi er et objekts evne til at antage mange former. Dette betyder, at en variabel af en abstrakt type kan indeholde objekter af enhver konkret underklasse af den abstrakte klasse. Dette gør koden mere fleksibel og tilpasningsdygtig til forskellige situationer.
3. Rammer og API'er: Java har adskillige rammer og API'er, der bruger abstrakte klasser. Ved at bruge abstrakte klasser kan udviklere spare tid og kræfter ved at bygge videre på eksisterende kode og fokusere på de aspekter, der er specifikke for deres applikationer.
Q2. Hvad er forskellen mellem Indkapsling og dataabstraktion?
Her er nogle vigtige forskelle i sort/hvid indkapsling og abstrering:
Indkapsling
Abstraktion
Indkapsling er dataskjul (informationsskjul) Abstraktion er detaljeret skjul (implementeringsskjul). Indkapsling grupperer data og metoder, der virker på dataene Dataabstraktion handler om at eksponere grænsefladen for brugeren og skjule detaljerne i implementeringen Indkapslede klasser er Java-klasser, der følger dataskjul og abstraktion Implementering af abstraktion sker ved hjælp af abstrakte klasser og interface Indkapsling er en procedure, der foregår på implementeringsniveau abstraktion er en proces på designniveau
Q3. Hvad er et virkeligt eksempel på dataabstraktion?
Fjernbetjening til fjernsyn er et glimrende virkeligt eksempel på abstraktion. Det forenkler interaktionen med et tv ved at skjule kompleksiteten bag simple knapper og symboler, hvilket gør det nemt uden at skulle forstå de tekniske detaljer om, hvordan tv'et fungerer.
Q4. Hvad er forskellen mellem abstrakte klasser og grænseflader i Java?
Her er nogle vigtige forskelle i s/h abstrakte klasser og grænseflader i Java:
Abstrakt klasse
shreya ghoshalGrænseflader
Abstrakte klasser understøtter abstrakte og ikke-abstrakte metoder Interface understøtter kun abstrakte metoder. Understøtter ikke Multiple Inheritance Understøtter multiple arv Abstrakte klasser kan udvides med Java-klasser og flere grænseflader Grænsefladen kan kun udvides med Java-grænsefladen. Abstrakte klassemedlemmer i Java kan være private, beskyttede osv. Grænseflader er som standard offentlige. Eksempel:
offentlig abstrakt klasse Vechicle{
public abstract void drive()
}Eksempel:
offentlig grænseflade Animal{
void tale();
}