Bij objectgeoriënteerd programmeren wordt abstractie gedefinieerd als het verbergen van onnodige details (implementatie) voor de gebruiker en het focussen op essentiële details (functionaliteit). Het verhoogt de efficiëntie en vermindert daarmee de complexiteit.

In Java kan abstractie worden bereikt met behulp van abstracte klassen en methoden. In deze tutorial leren we over abstracte methoden en het gebruik ervan in Java.

Abstracte klasse

Een klasse wordt abstract verklaard met behulp van de abstract trefwoord. Het kan nul of meer abstracte en niet-abstracte methoden hebben. We moeten de abstracte klasse uitbreiden en de methoden ervan implementeren. Het kan niet worden geïnstantieerd.

hoe je een map hernoemt in Linux

Syntaxis voor abstracte klasse:

 abstract class class_name { //abstract or non-abstract methods } 

Opmerking: een abstracte klasse kan al dan niet abstracte methoden bevatten.

Abstracte methode

Een methode die is gedeclareerd met behulp van de abstract trefwoord binnen een abstracte klasse en geen definitie heeft (implementatie), wordt een abstracte methode genoemd.

Als we alleen de methodedeclaratie in een superklasse nodig hebben, kan dit worden bereikt door de methoden als abstracts te declareren.

De abstracte methode wordt ook wel subklasseverantwoordelijkheid genoemd, omdat deze niet in de superklasse wordt geïmplementeerd. Daarom moet een subklasse deze overschrijven om de methodedefinitie te kunnen leveren.

Syntaxis voor abstracte methode:

 abstract return_type method_name( [ argument-list ] ); 

Hier heeft de abstracte methode geen methodelichaam. Het kan nul of meer argumenten bevatten.

Punten om te onthouden

De volgende punten zijn de belangrijke regels voor de abstracte methode in Java:

• Een abstracte methode heeft geen hoofdtekst (implementatie), ze hebben alleen een handtekening van de methode (declaratie). De klasse die de abstracte klasse uitbreidt, implementeert de abstracte methoden.
• Als een niet-abstracte (concrete) klasse een abstracte klasse uitbreidt, moet de klasse alle abstracte methoden van die abstracte klasse implementeren. Als dit niet het geval is, moet de concrete klasse ook als abstract worden verklaard.
• Omdat de abstracte methoden alleen de handtekening hebben, moet deze aan het einde een puntkomma (;) hebben.
• Hieronder volgen verschillende illegale combinaties van andere modificatoren voor methoden met betrekking tot abstract modificator:
  • laatste
  • abstract inheems
  • samenvatting gesynchroniseerd
  • abstracte statisch
  • abstract privé
  • abstracte striktfp
• Als een klasse een abstracte methode bevat, moet deze abstract zijn en omgekeerd is dit niet waar.

Voorbeeld van abstracte methode in Java

Voorbeeld 1:

In het volgende voorbeeld zullen we leren hoe abstractie wordt bereikt met behulp van abstracte klassen en abstracte methoden.

SamenvattingMethodeEx1.java

tekenreeks subtekenreeks java

 // abstract class abstract class Multiply { // abstract methods // sub class must implement these methods public abstract int MultiplyTwo (int n1, int n2); public abstract int MultiplyThree (int n1, int n2, int n3); // regular method with body public void show() { System.out.println ('Method of abstract class Multiply'); } } // Regular class extends abstract class class AbstractMethodEx1 extends Multiply { // if the abstract methods are not implemented, compiler will give an error public int MultiplyTwo (int num1, int num2) { return num1 * num2; } public int MultiplyThree (int num1, int num2, int num3) { return num1 * num2 * num3; } // main method public static void main (String args[]) { Multiply obj = new AbstractMethodEx1(); System.out.println ('Multiplication of 2 numbers: ' + obj.MultiplyTwo (10, 50)); System.out.println ('Multiplication of 3 numbers: ' + obj.MultiplyThree (5, 8, 10)); obj.show(); } } 

Uitgang:

Voorbeeld 2:

Standaard zijn alle methoden van een interface openbaar en abstract. Een interface kan geen concrete methoden bevatten, dat wil zeggen reguliere methoden met body.

SamenvattingMethodeEx2.java

 // interface interface SquareCube { // abstract methods public abstract int squareNum (int n); // it not necessary to add public and abstract keywords // as the methods in interface are public abstract by default int cubeNum (int n); // regular methods are not allowed in an interface // if we uncomment this method, compiler will give an error /*public void disp() { System.out.println ('I will give error if u uncomment me'); } */ } public class AbstractMethodEx2 implements SquareCube { // defining the abstract methods of interface public int squareNum (int num) { return num * num; } public int cubeNum (int num) { return num * num * num; } // main method public static void main(String args[]){ SquareCube obj = new AbstractMethodEx2(); System.out.println('Square of number is: ' + obj.squareNum (7) ); System.out.println('Cube of number is: ' + obj.cubeNum (7)); } } 

Uitgang:

Op deze manier hebben we geleerd over de abstracte methode en de implementatie ervan in Java.

vind mijn iPhone Android