Java abstracte klasse en abstracte methoden

In deze zelfstudie leren we met behulp van voorbeelden over abstracte Java-klassen en -methoden. We zullen ook leren over abstractie in Java.

Java abstracte klas

De abstracte klasse in Java kan niet worden geïnstantieerd (we kunnen geen objecten van abstracte klassen maken). We gebruiken de abstract trefwoord om een ​​abstracte klasse te declareren. Bijvoorbeeld,

// create an abstract class
abstract class Language {
  // fields and methods
}
...

// try to create an object Language
// throws an error
Language obj = new Language(); 

Een abstracte klasse kan zowel de reguliere methoden als abstracte methoden hebben. Bijvoorbeeld,

abstract class Language {

  // abstract method
  abstract void method1();

  // regular method
  void method2() {
    System.out.println("This is regular method");
  }
}

Ga naar Java-methoden om meer te weten te komen over de niet-abstracte methoden. Hier leren we over abstracte methoden.

Java abstracte methode

Een methode die geen body heeft, staat bekend als een abstracte methode. We gebruiken dezelfde abstract trefwoord om abstracte methoden te maken. Bijvoorbeeld,

abstract void display();

Hier, display() is een abstracte methode. De hoofdtekst van display() wordt vervangen door ; .

Als een klasse een abstracte methode bevat, moet de klasse abstract worden verklaard. Anders genereert het een fout. Bijvoorbeeld,

// error
// class should be abstract
class Language {

  // abstract method
  abstract void method1();
}

Voorbeeld:Java abstracte klasse en methode

Hoewel abstracte klassen niet kunnen worden geïnstantieerd, kunnen we er subklassen van maken. We hebben dan toegang tot leden van de abstracte klasse met behulp van het object van de subklasse. Bijvoorbeeld,

abstract class Language {

  // method of abstract class
  public void display() {
    System.out.println("This is Java Programming");
  }
}

class Main extends Language {

  public static void main(String[] args) {
    
    // create an object of Main
    Main obj = new Main();

    // access method of abstract class
    // using object of Main class
    obj.display();
  }
}

Uitvoer

This is Java programming

In het bovenstaande voorbeeld hebben we een abstracte klasse gemaakt met de naam Taal . De klasse bevat een reguliere methode display() .

We hebben de klasse Main gemaakt die de abstracte klasse erft. Let op de verklaring,

obj.display();

Hier, obj is het object van de onderliggende klasse Main . We roepen de methode van de abstracte klasse aan met het object obj .

Abstracte methoden implementeren

Als de abstracte klasse een abstracte methode bevat, moeten alle onderliggende klassen die zijn geërfd van de abstracte superklasse, de implementatie van de abstracte methode bieden. Bijvoorbeeld,

abstract class Animal {
  abstract void makeSound();

  public void eat() {
    System.out.println("I can eat.");
  }
}

class Dog extends Animal {

  // provide implementation of abstract method
  public void makeSound() {
    System.out.println("Bark bark");
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of Dog class
    Dog d1 = new Dog();

    d1.makeSound();
    d1.eat();
  }
}

Uitvoer

Bark bark
I can eat.

In het bovenstaande voorbeeld hebben we een abstracte klasse Animal . gemaakt . De klasse bevat een abstracte methode makeSound() en een niet-abstracte methode eat() .

We hebben een subklasse geërfd Hond uit de superklasse Animal . Hier, de subklasse Hond levert de implementatie voor de abstracte methode makeSound() .

We gebruikten toen het object d1 van de Hond class om methoden makeSound() aan te roepen en eat() .

Opmerking :Als de Hond class biedt niet de implementatie van de abstracte methode makeSound() , Hond moet ook als abstract worden gedeclareerd. Dit komt omdat de subklasse Hond erft makeSound() van Dier .

Toegang tot Constructor van abstracte klassen

Een abstracte klasse kan constructors hebben zoals de reguliere klasse. En we hebben toegang tot de constructor van een abstracte klasse van de subklasse met behulp van de super trefwoord. Bijvoorbeeld,

abstract class Animal {
   Animal() {
      ….
   }
}

class Dog extends Animal {
   Dog() {
      super();
      ...
   }
}

Hier hebben we de super() . gebruikt binnen de constructor van Hond om toegang te krijgen tot de constructor van het Animal .

Merk op dat de super moet altijd de eerste instructie van de constructor van de subklasse zijn. Ga naar Java-superzoekwoord voor meer informatie.

Java-abstractie

Het belangrijkste gebruik van abstracte klassen en methoden is om abstractie in Java te bereiken.

Abstractie is een belangrijk concept van objectgeoriënteerd programmeren waarmee we onnodige details kunnen verbergen en alleen de benodigde informatie kunnen tonen.

Hierdoor kunnen we complexiteit beheren door details weg te laten of te verbergen met een eenvoudiger idee op een hoger niveau.

Een praktisch voorbeeld van abstractie kunnen motorremmen zijn. We weten wat remmen doet. Als we op de rem trappen, stopt de motor. De werking van de rem wordt echter voor ons verborgen gehouden.

Het grote voordeel van het verbergen van de werking van de rem is dat de fabrikant nu de rem voor verschillende motorfietsen anders kan implementeren, maar wat de rem doet, zal hetzelfde zijn.

Laten we een voorbeeld nemen dat ons helpt Java-abstractie beter te begrijpen.

Voorbeeld 3:Java-abstractie

abstract class MotorBike {
  abstract void brake();
}

class SportsBike extends MotorBike {
    
  // implementation of abstract method
  public void brake() {
    System.out.println("SportsBike Brake");
  }
}

class MountainBike extends MotorBike {
    
  // implementation of abstract method
  public void brake() {
    System.out.println("MountainBike Brake");
  }
}

class Main {
  public static void main(String[] args) {
    MountainBike m1 = new MountainBike();
    m1.brake();
    SportsBike s1 = new SportsBike();
    s1.brake();
  }
}

Uitvoer :

MountainBike Brake
SportsBike Brake

In het bovenstaande voorbeeld hebben we een abstracte superklasse MotorBike . gemaakt . De superklasse MotorBike heeft een abstracte methode brake() .

De brake() methode kan niet worden geïmplementeerd binnen MotorBike . Het is omdat elke fiets een andere uitvoering van remmen heeft. Dus alle subklassen van MotorBike zou een andere implementatie hebben van brake() .

Dus de implementatie van brake() in Motorfiets wordt verborgen gehouden.

Hier, MountainBike maakt zijn eigen implementatie van brake() en SportsBike maakt zijn eigen implementatie van brake() .

Opmerking :We kunnen ook interfaces gebruiken om abstractie in Java te bereiken. Ga voor meer informatie naar Java-interface.

Belangrijkste punten om te onthouden

• We gebruiken de abstract trefwoord om abstracte klassen en methoden te maken.
• Een abstracte methode heeft geen implementatie (hoofdtekst van de methode).
• Een klasse die abstracte methoden bevat, moet ook abstract zijn.
• We kunnen geen objecten van een abstracte klasse maken.
• Om kenmerken van een abstracte klasse te implementeren, erven we er subklassen van en maken we objecten van de subklasse.
• Een subklasse moet alle abstracte methoden van een abstracte klasse overschrijven. Als de subklasse echter abstract wordt verklaard, is het niet verplicht om abstracte methoden te overschrijven.
• We hebben toegang tot de statische attributen en methoden van een abstracte klasse met behulp van de referentie van de abstracte klasse. Bijvoorbeeld

  Animal.staticMethod();