Interface #

Dalam bahasa Ruby, konsep “interface” tidak ada dalam bentuk formal seperti di bahasa pemrograman statis seperti Java atau C#. Namun, Ruby mendukung prinsip desain yang serupa melalui penggunaan modul dan metode. Mari kita bahas bagaimana Anda dapat mencapai fungsionalitas yang mirip dengan interface di Ruby.

Konsep Interface di Ruby #

Di Ruby, interface dapat diimplementasikan menggunakan modul. Modul memungkinkan Anda untuk mendefinisikan metode yang diharapkan ada pada kelas yang mengikutinya, mirip dengan bagaimana interface bekerja di bahasa lain. Meskipun Ruby tidak memaksa implementasi metode tertentu, modul dapat digunakan untuk mendokumentasikan dan memastikan bahwa kelas mengimplementasikan metode yang diinginkan.

Menggunakan Modul Sebagai Interface #

Anda dapat mendefinisikan metode dalam modul dan kemudian “mengikutsertakan” modul ini dalam kelas yang ingin mematuhi interface tersebut. Modul tidak mengimplementasikan metode secara langsung, tetapi menyediakan “kontrak” metode yang diharapkan ada.

Contoh:

module Greeter
  def greet
    raise NotImplementedError, 'Metode greet harus diimplementasikan'
  end
end

class Person
  include Greeter

  def greet
    "Hello!"
  end
end

class Robot
  include Greeter

  def greet
    "Beep boop!"
  end
end

# Penggunaan
person = Person.new
puts person.greet  # Output: Hello!

robot = Robot.new
puts robot.greet  # Output: Beep boop!

Penjelasan:

• Greeter adalah modul yang mendefinisikan metode greet. Metode ini dideklarasikan tetapi tidak diimplementasikan, dan NotImplementedError digunakan untuk menandai bahwa kelas yang mengikutsertakan modul ini harus mengimplementasikan metode tersebut.
• Person dan Robot adalah kelas yang mengikutsertakan modul Greeter dan mengimplementasikan metode greet.

Menggunakan Abstract Modifikasi #

Jika Anda ingin mengimplementasikan cara yang lebih eksplisit untuk memaksa implementasi metode, Anda dapat menggunakan teknik yang lebih terstruktur dengan mendefinisikan metode di modul sebagai “abstrak” dan memberikan implementasi default yang mengeluarkan error jika tidak diimplementasikan oleh kelas yang mengikutsertakan modul.

Contoh:

module Animal
  def speak
    raise NotImplementedError, 'Metode speak harus diimplementasikan'
  end

  def eat
    "Makan dengan cara default."
  end
end

class Dog
  include Animal

  def speak
    "Woof!"
  end
end

class Cat
  include Animal

  def speak
    "Meow!"
  end
end

# Penggunaan
dog = Dog.new
puts dog.speak  # Output: Woof!
puts dog.eat    # Output: Makan dengan cara default.

cat = Cat.new
puts cat.speak  # Output: Meow!
puts cat.eat    # Output: Makan dengan cara default.

Penjelasan:

• Modul Animal mendefinisikan metode speak dan eat. Metode speak adalah metode abstrak yang harus diimplementasikan oleh kelas yang mengikutsertakan modul.
• Dog dan Cat adalah kelas yang mengikutsertakan modul Animal dan memberikan implementasi untuk metode speak, sedangkan metode eat menggunakan implementasi default dari modul.

Modul Sebagai Interface dalam Hierarki Kelas #

Modul juga dapat digunakan untuk mendefinisikan kontrak yang harus diikuti oleh kelas dalam hierarki kelas, yang memfasilitasi pembagian metode di antara kelas yang berbeda.

Contoh:

module Runnable
  def run
    raise NotImplementedError, 'Metode run harus diimplementasikan'
  end
end

class Vehicle
  include Runnable
end

class Car < Vehicle
  def run
    "Car is running"
  end
end

class Bike < Vehicle
  def run
    "Bike is running"
  end
end

# Penggunaan
car = Car.new
puts car.run  # Output: Car is running

bike = Bike.new
puts bike.run  # Output: Bike is running

Penjelasan:

• Vehicle adalah kelas dasar yang mengikutsertakan modul Runnable. Kelas-kelas turunan dari Vehicle (seperti Car dan Bike) harus mengimplementasikan metode run.

Konsep Polimorfisme #

Dengan menggunakan modul dan interface, Anda dapat mengimplementasikan polimorfisme, di mana objek dari berbagai kelas dapat diperlakukan secara seragam jika mereka mengimplementasikan metode yang sama.

Contoh:

def make_it_run(runnable_object)
  puts runnable_object.run
end

car = Car.new
bike = Bike.new

make_it_run(car)  # Output: Car is running
make_it_run(bike) # Output: Bike is running

Penjelasan:

• Fungsi make_it_run dapat menerima objek yang mengimplementasikan metode run, tidak peduli apakah objek tersebut adalah Car, Bike, atau kelas lain yang sesuai dengan kontrak interface.

Kesimpulan #

Meskipun Ruby tidak memiliki konsep interface formal seperti di beberapa bahasa lain, Anda dapat menggunakan modul untuk mencapai tujuan yang serupa. Modul dapat digunakan untuk mendefinisikan metode yang diharapkan ada pada kelas yang mengikutsertakannya, serta memanfaatkan teknik lain untuk memastikan bahwa kelas-kelas mengikuti kontrak yang diinginkan. Ini mendukung prinsip desain berorientasi objek seperti enkapsulasi dan polimorfisme. Jika Anda memiliki pertanyaan lebih lanjut atau memerlukan penjelasan tambahan, silakan beri tahu!