Guten Abend Liebe Ruby-Community,

ich habe mich mal etwas intensiver mit dem Objekt-System von Ruby beschäftigt und habe jetzt einen kleinen Denk fehler.

Und zwar kann ich mir nicht erklären warum folgendes nicht funktioniert.

1 2 3 4 5 6 7 8

class Foo def bar puts "hier spricht bar" end end Foo.bar

Ich weiss das es eigentlich

1 2 3 4 5 6 7 8

class Foo def self.bar puts "hier spricht bar" end end Foo.bar

heißen müsste. Ich kann mir nur nicht ganz erklären warum das so ist.

Ich hab folgende Denkweise statt "class Foo" könnte ich ja auch folgendes schreiben

Foo = Class.new

was ja so viel heißt, das Ruby im Speicher ein Objekt anlegt
und in Foo die Referenz dazu ablegt, in diesem Objekt ist dann in klass die Referenz zu
dem Speicherbereich in dem die Klasse liegt gespeichert. So hier muss jetzt irgend ein Denkfehler
sein. Denn wenn das stimmen würde müsste ich ja einfach "Foo.bar" aufrufen können da in Foo ja
die Referenz zum Objekt liegt und darüber kann doch die Klasse im Speicher gefunden werden in
dem die methoden liegen.

Desweitern habe ich nicht ganz verstanden was bei Foo.new genau gemacht wird aber eigentlich
wird doch nur ein neues Objekt erstellt in dem die Instance-Variablen liegen?

Wahrscheinlich verstehe ich das mit den Instancen nicht ganz!?

Ich stehe auf dem Schlauch! Ich hoffe ihr könnt mich ein bisschen erleuchten und mir sagen
was ich falsch mache!

Ich hoffe ihr versteht was ich da oben für wirres Zeugs hingeschrieben habe!

Gruß wirrwarr

Hi wirrwarr,

die new-Methode erstellt ein neues Exemplar (Instance) der Empfängerklasse, führt die initialize-Methode aus und gibt das neu erstellte Exemplar zurück.

In deinem Beispiel kann die Methode bar nicht aufgerufen werden, da du sie als "instance method" definiert hast. Du müsstest also zuerst ein Exemplar erzeugen und die bar-Nachricht an das Exemplar schicken:

Foo.new.bar

Wenn du eine Klassenmethode definieren möchtest, musst du entweder ein self. vor den Methodennamen schreiben (wie du es ja selbst gezeigt hast) oder du machst es folgendermaßen:

1 2 3 4 5 6 7

class Foo class << self def bar puts "Test 123" end end end

In beiden Fällen wird eine Klassenmethode angelegt, die über die Klassenkonstante erreicht werden kann:

Foo.bar

_________________
stefankloeckner.blog.de

"Deine Mauerzinnen mache ich aus Rubin und all deine Grenzen von erlesenen Steinen." - Die Bibel, Jesaja 52.54

Guten Morgen Zusammen,

erste mal vielen Danke für die Antwort!

Leider habe ich es immer noch nicht verstanden *Entschuldigung*.
Deshalb habe ich noch mal darüber nachgedacht (hoffentlich war das kein Fehler! ).

Mir würde es schon ausreichen wenn ihr mir sagt "Junge du bist auf dem völligen Holzweg" oder
"Junge im Grunde stimmt es". Eine Begründung dazu wär natrülich noch sehr freundlich .

Also, wenn ich

1 2 3 4 5 6

class Foo def bar puts "test" end end

in Ruby ausführe, dann macht Ruby folgendes, es reserviert Speicher für ein Objekt für eine Metaklasse
und für eine Klasse. Speichert dann die Referenz in der Konstanten Foo. Im Objekt-Speicher steht dann
unter klass die Referenz auf den Speicherbereich der Metaklasse, dort steht dann unter super die
Referenz auf den Speicherbereich von der Klasse Class. So und zum Schluß steht im Speicherbereich der Klasse Foo
noch die methode bar. Da nun im Objekt Foo keine Referenz zum Speicherbereich der Klasse Foo steht kann
auch nicht auf diese Methoden zugegriffen werden.

Wenn ich nun

1 2	f = Foo.new

ausführe, wird im Speicher ein Object erstellt, in dem unter klass die Referenz auf den Speicherberich der Klasse Foo
steht und somit kann über f auf die Methode bar zugegriffen werden.

Weiter wär dann,

1 2 3 4 5 6 7 8

class Foo class <<self def hallo puts "sagt freundlich Hallo!" end end end

ein Zugriff auf die Metaklasse von Foo, der die Methode hallo übergeben wird.
Da nun im Foo Objekt die Referenz auf den Speicherbereich der Metaklasse von Foo besteht wird auch
mit Foo.hallo die Methode hallo gefunden.


Vielen Dank für eure Zeit!

Gruß wirrwarr

Ich fürchte, du denkst zu kompliziert. Folgender Codeschnipsel

1 2 3 4

class Foo def bar; 42; end def self.foobar; "George Washington is dead"; end end

erstellt ein Objekt vom Typ class, welches die Methoden new und foobar (Klassenmethoden) enthält und weist dieses Objekt der Konstante Foo zu.

Wenn man die Nachricht new an das class-Objekt hinter der Konstante Foo sendet, erhält man als Rückgabewert ein Objekt, welches die Methode bar (instance method) beinhaltet.

_________________
stefankloeckner.blog.de

"Deine Mauerzinnen mache ich aus Rubin und all deine Grenzen von erlesenen Steinen." - Die Bibel, Jesaja 52.54

Wirrwar hat mit seinem letzten Post schon recht. Aber lass mal die vielen "Speicherbereiche" weg, denn wie der Rubyinterpreter das intern auflöst ist unabhängig von der Sprachbeschreibung.

Deine Klasse Foo ist eine Instanz der Klasse Class mit einer Eigenklasse Foo'. Jedes Objekt verfügt über die Methoden seiner Eigenklasse, welche wiederum ihre Instanz-Methoden von der eigentlichen Klasse des Objekts erbt.

Das heißt: Deine Klasse Foo darf alle Instanz-Methoden ausführen, welche die Eigenklasse Foo' besitzt. Und Foo' besitzt die Methoden, die du darin definiert hast, plus die Methoden die es von Class, Module und Object erbt.

Bei der Instanz von Foo ist das genauso. Sie darf alle Methoden ausführen, die in seiner Eigenklasse definiert sind. Und die Eigenklasse erbt alle Methoden von Foo und Object.

Du musst unterscheiden zwischen Klassenmethoden und Instanzmethoden. Instanzmethoden können nur auf Objekte einer Klasse angewandt werden. Die Instanzmethode muss wissen, welches Objekt du meinst, weil in der Methode auch auf dieses referenziert werden kann. Ein Objekt enthält alle Instanzvariablen, die Klasse selber nicht. Was sollte eine Instanzmethode denn machen, wenn du dort Code drin hast, der Instanzvariablen manipuliert und du nicht auf ein Objekt referenzieren kannst?

Danke für all die Antworten, so langsam komm ich dahinter!

Gruß wirrwarrr

Ich bin vor einiger Zeit auf den Thread hier gestoßen und weil mich das dann doch noch mehr interessiert hat, lese ich momentan "Metaprogramming Ruby" und kann es echt nur empfehlen, das erste Kapitel dreht sich komplett um das Objektmodel in Ruby, noch viel detaillierter als in der Pickaxe beschrieben.

_________________
@Github Blog