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 Klassenrumpf definiert wird, ist privat: Die eigenen Methoden des Objekts können sie aufrufen, Code außerhalb des Objekts 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. Der Aufruf für ein anderes Objekt, selbst wenn es zur gleichen Klasse gehört, wird verweigert:

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 übernehmen, und def gibt den Namen der Methode zurück. Daher macht private def helper eine einzelne Methode genau dort, wo sie definiert wird, privat. Die Methoden darüber und darum herum 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 gegenüber dem restlichen Programm abgibt; private Methoden können später umbenannt oder entfernt werden, ohne Aufrufer zu beeinträchtigen:

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

  private                # später frei änderbar

  def net
    ...
  end

  def tax
    ...
  end
end

Aufgabe

Einfach

Vervollständige die Klasse Order. Ihre einzige öffentliche Methode neben 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 für jede Bestellung einen Beleg aus. Anschließend versucht er, tax von außerhalb aufzurufen, und gibt tax is private aus, wenn Ruby dies ablehnt.

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

Probier es selbst

require_relative 'order'

# Gelieferter Ein-/Ausgabecode: belasse ihn wie er ist
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