Here's some black magic to do something like you want to do.  If there's 
an easier way, I'm sure
someone will post it as a follow-up to my message. :)

class Foo
    def initialize
        puts "Foo!"
    end
end

module Bar
    def self.append_features(cls)
       
        class << cls                                     # Trap the 
initialize
            proc { |x| @init = x }                       # method in an 
unbound
        end.call(cls.instance_method(:initialize))       # method object
       
        cls.class_eval do remove_method :initialize end  # Remove the old
                                                         # initialize
       
        super    # Make sure to call super
    end
   
    def initialize
        unbound = class << self.class; @init; end  # Retrieve the old method
       
        init = unbound.bind self                   # Bind it to the current
                                                   # object
        init.call                                          
        puts "Bar!"    # new stuff goes here
    end
end

class Foo
    include Bar
end

Foo.new

Ferenc Engard wrote:

>Hello,
>
>Sorry, I pushed "send" too early. That is not exactly what I want. I
>want a method which will be called when an object is instantiated, if
>the object's Class includes this Module. I.e., I do not want to write a
>'init_x_module' call into each classes' constructor, which includes this
>module, but want the system call that method. Something like multiple
>inheritance in C++.
>  
>