Private Methoden

Teil des Abschnitts Objektorientierte Programmierung der Ruby-Journey von Coddy. Lektion 17 von 57.

Kapselung bedeutet, dass ein Objekt verbirgt, wie es funktioniert, und eine kleine Anzahl öffentlicher Methoden anbietet. Methoden sind standardmäßig öffentlich. Jede Methode, die nach dem Wort private im Rumpf einer Klasse definiert wird, ist privat: Die eigenen Methoden des Objekts können sie aufrufen, externer Code nicht:

class Order
  def initialize(price, quantity)
    @price = price
    @quantity = quantity
  end

  def total
    subtotal + shipping
  end

  private

  def subtotal
    @price * @quantity
  end

  def shipping
    subtotal >= 50 ? 0 : 5
  end
end

order = Order.new(10, 3)
puts order.total
begin
  order.subtotal
rescue NoMethodError => e
  puts e.message
end

Ausgabe:

35
private method `subtotal' called for an instance of Order

Innerhalb der Klasse wird eine private Methode ohne Empfänger oder mit self. aufgerufen. Ein Aufruf für ein anderes Objekt, selbst eines derselben Klasse, wird abgewiesen:

class Coin
  def initialize(cents)
    @cents = cents
  end

  def describe
    "#{self.label} / #{label}"
  end

  def same_as?(other)
    other.label == label
  end

  private

  def label
    "#{@cents}c"
  end
end

a = Coin.new(5)
puts a.describe
begin
  a.same_as?(Coin.new(5))
rescue NoMethodError => e
  puts e.message
end

Ausgabe:

5c / 5c
private method `label' called for an instance of Coin

private kann auch einen Methodennamen entgegennehmen, und def gibt den Namen der Methode zurück. Daher macht private def helper eine einzelne Methode genau dort privat, wo sie definiert wird. Die Methoden davor und danach bleiben öffentlich:

class Greeter
  def greet(name)
    "#{salutation}, #{name}!"
  end

  private def salutation
    "Hello"
  end

  def wave
    "*waves*"
  end
end

g = Greeter.new
puts g.greet("Ada")
puts g.wave
p Greeter.private_instance_methods(false)

Ausgabe:

Hello, Ada!
*waves*
[:salutation]

Halte Hilfsmethoden privat. Die öffentlichen Methoden sind das Versprechen, das eine Klasse dem Rest des Programms gibt; private Methoden können später umbenannt oder entfernt werden, ohne einen Aufrufer zu beeinträchtigen:

class Invoice
  def total              # public: Aufrufende verlassen sich darauf
    net + tax
  end

  private                # kann später geändert werden

  def net
    ...
  end

  def tax
    ...
  end
end

Aufgabe

Einfach

Vervollständige die Klasse Order. Ihre einzige öffentliche Methode außer initialize ist receipt, die 3 x 12.50 = 37.50, tax 7.50, total 45.00 zurückgibt. Die privaten Methoden subtotal (Preis mal Menge), tax (20 % der Zwischensumme) und total berechnen die Zahlen.

Der bereitgestellte Code liest Bestellungen als Zeilen im Format quantity price ein und gibt jede Quittung aus. Dann versucht er, von außen tax aufzurufen, und gibt tax is private aus, wenn Ruby den Aufruf verweigert.

Dein Code gehört in order.rb. main.rb enthält den bereitgestellten Ein-/Ausgabecode und kann nicht bearbeitet werden.

Probier es selbst

require_relative 'order'

# Vorgegebener Ein-/Ausgabecode: unverändert lassen
input = []
while (line = gets)
  input << line.chomp
end
orders = input.map do |line|
  quantity, price = line.split
  Order.new(quantity.to_i, price.to_f)
end
orders.each { |o| puts o.receipt }
begin
  orders[0].tax
  puts "tax is public"
rescue NoMethodError
  puts "tax is private"
end