Wat is een abstracte methode?
Een abstracte methode is een methode die geen implementatie heeft. Dat wil zeggen, het heeft alleen een declaratie, dus u kent de naam, het retourtype en de variabelen die het zal accepteren. Hier is een voorbeeld van een eenvoudige abstracte methode:
public abstract int example(int a1, int a2);
-
Java abstracte methoden hebben geen implementatie. Dat wil zeggen, ze mogen nooit worden gevolgd door accolades en een lichaam dat vertelt hoe de methode moet worden gebruikt. Het wordt gewoon afgesloten met een puntkomma.
-
Als u een abstracte methode maakt, kan die alleen in een abstracte klasse worden geplaatst. Dat wil zeggen, je kunt geen concrete klasse hebben met daarin een abstracte methode.
i. Even terzijde: als u een abstracte klasse heeft, kan deze constructors bevatten. Het hoeft echter geen abstracte methode te hebben. -
Wanneer een concrete klasse een abstracte klasse uitbreidt, moet deze ook alle abstracte methoden van de bovenliggende klasse implementeren, anders kan deze niet concreet zijn en moet deze abstract worden verklaard.
Uitbreiding van abstracte Java-klassen
Laten we zeggen dat we een programma willen schrijven over basisvormen die omtrek en oppervlakte teruggeven. We maken dus een bovenliggende abstracte klasse. Maar omdat elke vorm zijn eigen regels heeft, moet elke vorm anders worden berekend, dus schrijven we de abstracte Shape- klasse als volgt:
abstract class Shape {
String shapeName = " ";
Shape(String name) {
this.shapeName = name;
}
abstract double area();
abstract double perimeter();
}
class Quadrilateral extends Shape
{
double length, width;
Quadrilateral(double l, double w, String name)
{
super(name);
this.length = l;
this.width = w;
}
@Override
public double perimeter()
{
return ((2*length)+(2*width));
}
@Override
public double area()
{
return (length*width);
}
}
Implementing the Quadrilateral class would then look like this
class Main
{
public static void main (String[] args)
{
// creating a Quadrilateral object using Shape as reference
Shape rectangle = new Quadrilateral(3,4, "Rectangle");
System.out.println("Area of rectangle is " + rectangle.area());
System.out.println("Perimeter of rectangle is " + rectangle.perimeter());
}
}
Area of rectangle is 12.0
Perimeter of rectangle is 14.0
Abstracte Java-methoden met interfaces
Laten we snel bekijken wat een interface is en hoe deze verschilt van een abstracte klasse. In een interface zijn alle variabelen die in een interface worden gedeclareerd openbaar, statisch en definitief. Abstracte klassen daarentegen hebben alleen niet-finale variabelen. Alles in een interface is standaard openbaar. Een abstracte klasse kan privé, beschermd, openbaar, enz. hebben. Ten slotte breidt een klasse een interface niet uit, maar implementeert deze. Voorafgaand aan JDK 8 kon een interface niets anders bevatten dan abstracte methoden. Nu kan een interface standaard en statische methoden hebben. Hierdoor zijn best practices afgestapt van het gebruik van abstracte methoden als uitbreidbare sjablonen en zijn ze gericht op interfaces en de implementatie ervan. Dus als je Shape zou maken als een interface en het vervolgens zou implementeren als Vierhoek, hoe zou het eruit zien? Ten eerste zou je de Shape(String name) constructor moeten afschaffen . Het zou er zo uitzien met alleen de twee abstracte methoden:
interface Shape {
abstract double area();
abstract double perimeter();
}
So the Quadrilateral class would then look like this:
class Quadrilateral implements Shape {
double length, width;
Quadrilateral(double l, double w) {
this.length = l;
this.width = w;
}
@Override
public double perimeter() {
return ((2*length)+(2*width));
}
@Override
public double area() {
return (length*width);
}
}
class Main
{
public static void main (String[] args)
{
// creating a Quadrilateral object using Shape as reference
Shape rectangle = new Quadrilateral(3,4);
System.out.println("Area of rectangle is " + rectangle.area());
System.out.println("Perimeter of rectangle is " + rectangle.perimeter());
}
}
Area of rectangle is 12.0
Perimeter of rectangle is 14.0
Maar waarom abstracte Java-methoden gebruiken?
Er zijn veel redenen waarom abstracte methoden in Java worden gebruikt en waarom u zich er vertrouwd mee zou moeten maken. Hier zijn drie snelle redenen waarom u ze zou moeten gebruiken wanneer dat nodig is.-
Vermijd dubbel werk – Kijk terug naar onze voorbeeldcodering; stel je voor dat jij en je team klassen moesten maken voor andere vormen dan een rechthoek. Hoeveel verschillende manieren kun je bedenken om die klas te ontwerpen? Tien? Vijftien? En dat is een simpel probleem. Stel je iets veel ingewikkelders voor. Jij en je team kunnen honderd manieren bedenken. Dan zou je voor de ontmoedigende taak staan om ze samen te weven tot een samenhangend programma. Dit brengt ons bij ons volgende punt: het definiëren van de implementatie.
-
Abstracte methoden in Java maken de definitie van gebruik en implementatie mogelijk - Wanneer u een abstracte klasse of interface gebruikt, en door ontwerp abstracte methoden, definieert u hoe andere mensen met uw interface zullen omgaan. Dat laat hen weten welke variabelen ze zouden moeten gebruiken en welke retourtypen ze kunnen verwachten.
Hoewel ze deze kunnen overschrijven en concrete klassen kunnen maken die uw interface op unieke manieren implementeren, legt u nog steeds het kerngebruik voor uw code vast. Als iemand Shape wil implementeren, moet hij zowel de omtrek als het gebied overschrijven of implementeren. - Leesbaarheid en foutopsporing - Het hebben van abstracte methoden zal de leesbaarheid van uw code verbeteren. Als je een klasse schrijft die een interface implementeert, weet je waar je op moet letten. Je weet dat elke abstracte methode in de interface in de implementatie zit, en dat maakt het lezen en het opsporen van eventuele bugs gemakkelijker. Abstracte methoden zijn nog maar het begin van het leren gebruiken van polymorfisme in Java en andere objectgeoriënteerde talen. Wanneer u ze begint te begrijpen en te gebruiken, begint een geheel nieuw hoofdstuk van uw codeerreis.
GO TO FULL VERSION