Kelas Abstrak Java dan Metode Abstrak

Dalam tutorial ini, kita akan belajar tentang kelas dan metode abstrak Java dengan bantuan contoh. Kita juga akan belajar tentang abstraksi di Java.

Kelas Abstrak Java

Kelas abstrak di Java tidak dapat dipakai (kita tidak dapat membuat objek dari kelas abstrak). Kami menggunakan abstract kata kunci untuk mendeklarasikan kelas abstrak. Misalnya,

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

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

Kelas abstrak dapat memiliki metode reguler dan metode abstrak. Misalnya,

abstract class Language {

  // abstract method
  abstract void method1();

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

Untuk mengetahui tentang metode non-abstrak, kunjungi metode Java. Di sini, kita akan belajar tentang metode abstrak.

Metode Abstrak Java

Sebuah metode yang tidak memiliki tubuh dikenal sebagai metode abstrak. Kami menggunakan abstract yang sama kata kunci untuk membuat metode abstrak. Misalnya,

abstract void display();

Di sini, display() adalah metode abstrak. Isi display() diganti dengan ; .

Jika suatu kelas berisi metode abstrak, maka kelas tersebut harus dideklarasikan abstrak. Jika tidak, itu akan menghasilkan kesalahan. Misalnya,

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

  // abstract method
  abstract void method1();
}

Contoh:Kelas dan Metode Abstrak Java

Meskipun kelas abstrak tidak dapat dipakai, kita dapat membuat subkelas darinya. Kami kemudian dapat mengakses anggota kelas abstrak menggunakan objek subkelas. Misalnya,

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

Keluaran

This is Java programming

Pada contoh di atas, kita telah membuat kelas abstrak bernama Bahasa . Kelas berisi metode reguler display() .

Kami telah membuat kelas Utama yang mewarisi kelas abstrak. Perhatikan pernyataannya,

obj.display();

Di sini, obj adalah objek dari kelas anak Main . Kami memanggil metode kelas abstrak menggunakan objek obj .

Mengimplementasikan Metode Abstrak

Jika kelas abstrak menyertakan metode abstrak apa pun, maka semua kelas anak yang diwarisi dari superkelas abstrak harus menyediakan implementasi metode abstrak. Misalnya,

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

Keluaran

Bark bark
I can eat.

Pada contoh di atas, kita telah membuat kelas abstrak Animal . Kelas berisi metode abstrak makeSound() dan metode non-abstrak eat() .

Kami telah mewarisi subkelas Anjing dari kelas super Hewan . Di sini, subkelas Anjing menyediakan implementasi untuk metode abstrak makeSound() .

Kami kemudian menggunakan objek d1 dari Anjing kelas untuk memanggil metode makeSound() dan eat() .

Catatan :Jika Anjing kelas tidak menyediakan implementasi metode abstrak makeSound() , Anjing juga harus dinyatakan sebagai abstrak. Ini karena subkelas Anjing mewarisi makeSound() dari Hewan .

Mengakses Konstruktor Kelas Abstrak

Kelas abstrak dapat memiliki konstruktor seperti kelas reguler. Dan, kita dapat mengakses konstruktor kelas abstrak dari subkelas menggunakan super kata kunci. Misalnya,

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

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

Di sini, kami telah menggunakan super() di dalam konstruktor Anjing untuk mengakses konstruktor Hewan .

Perhatikan bahwa super harus selalu menjadi pernyataan pertama dari konstruktor subclass. Kunjungi kata kunci super Java untuk mempelajari lebih lanjut.

Abstraksi Java

Penggunaan utama dari kelas dan metode abstrak adalah untuk mencapai abstraksi di Java.

Abstraksi adalah konsep penting dari pemrograman berorientasi objek yang memungkinkan kita menyembunyikan detail yang tidak perlu dan hanya menampilkan informasi yang diperlukan.

Hal ini memungkinkan kita untuk mengelola kompleksitas dengan menghilangkan atau menyembunyikan detail dengan ide yang lebih sederhana dan tingkat yang lebih tinggi.

Contoh abstraksi praktis dapat berupa rem sepeda motor. Kita tahu apa yang dilakukan rem. Saat kita menginjak rem, sepeda motor akan berhenti. Namun, cara kerja rem disembunyikan dari kami.

Keuntungan utama menyembunyikan cara kerja rem adalah sekarang pabrikan dapat menerapkan rem secara berbeda untuk sepeda motor yang berbeda, namun apa yang dilakukan rem akan sama.

Mari kita ambil contoh yang membantu kita untuk lebih memahami abstraksi Java.

Contoh 3:Abstraksi Java

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

Keluaran :

MountainBike Brake
SportsBike Brake

Pada contoh di atas, kita telah membuat super class abstrak MotorBike . Superclass Sepeda Motor memiliki metode abstrak brake() .

brake() metode tidak dapat diimplementasikan di dalam MotorBike . Hal ini karena setiap sepeda memiliki penerapan rem yang berbeda. Jadi, semua subkelas MotorBike akan memiliki implementasi brake() . yang berbeda .

Jadi, implementasi brake() di Sepeda Motor disembunyikan.

Di sini, MountainBike membuat implementasi sendiri dari brake() dan SportsBike membuat implementasi sendiri dari brake() .

Catatan :Kita juga dapat menggunakan antarmuka untuk mencapai abstraksi di Java. Untuk mempelajari lebih lanjut, kunjungi Antarmuka Java.

Poin Penting untuk Diingat

Kami menggunakan abstract kata kunci untuk membuat kelas dan metode abstrak.
Metode abstrak tidak memiliki implementasi (badan metode).
Kelas yang berisi metode abstrak juga harus abstrak.
Kami tidak dapat membuat objek dari kelas abstrak.
Untuk mengimplementasikan fitur dari kelas abstrak, kita mewarisi subkelas darinya dan membuat objek dari subkelas tersebut.
Sebuah subkelas harus menimpa semua metode abstrak dari kelas abstrak. Namun, jika subkelas dideklarasikan abstrak, metode abstrak tidak wajib diganti.
Kita dapat mengakses atribut dan metode statis dari kelas abstrak menggunakan referensi kelas abstrak. Misalnya,
```
Animal.staticMethod();
```

super jawa Antarmuka Jawa

java