A. Sundararajan's Weblog

class Person {
  def greet(msg="hello world") {
    println(msg);
  }
}

p = new Person()
// leave argument, default taken
p.greet()

// argument to override the default
p.greet "Groovy!"

class Person 
  def greet(msg="hello world")
    puts msg
  end
end

// leave argument, default taken
Person.new.greet

// argument to override the default
Person.new.greet "JRuby!"

println 5.class
5.times { println "hello" }

puts 5.class
5.times { puts "hello" }

obj instanceof ClassName

// for exact instance check 
// excluding subtype objects
obj.getClass() == ClassName.class

obj.metaClass == known_metaClass

class Person 
end

class Employee < Person
end

e = Employee.new

# kind_of? includes subtypes
# Note: kind_of? is like Java's 
# instanceof is_a? is 
# synonym for kind_of?

# prints true for both these
puts e.kind_of?(Employee)
puts e.kind_of?(Person)

# Note: instance_of? 
# is different from Java's 
# instanceof.

# this prints false
puts e.instance_of?(Person)

# this prints true
puts e.instance_of?(Employee)

ClassName.class
java.awt.Frame.class
Person.class

Java Trap: just use ClassName for class literal of ClassName. All the built-in and user classes have a corresponding global constant with the same name as the class.

If you say, Person.class that is different -- that is similar to saying Person.class.getClass() in Java.

class Person   
end

def factory(klass)
  obj = klass.new
  puts "Created #{obj}"
  return obj
end

# To pass Person class, we
# just use Person!
factory Person

def method1
  method2
end

def method2
  method3
end

def method3
  puts caller.join("\n");
end

method1

class Person {
  def invokeMethod(String name, args) {
    println(name + " called");
  }
}

p = new Person();

// no "greet" method, "invokeMethod"
// is called.
p.greet();

class Person 
  def method_missing(name, *args)
     puts name.to_s + " called"
  end
end

p = Person.new

# no "greet" method, so "method_missing"
# will be called

p.greet

Not directly supported. But, I think you can play with use and/or MetaClasses to simulate it.

class Person {
  def greet() {
    sayHello()
  }
}

p = new Person()

class Greeter {
  static def sayHello(obj) {
    println "hello world"
  }
}

use(Greeter) {
  p.greet()
}

Note that the above works only within the use statement. What if you want to make the change global?

class Person 
  def greet
    sayHello
  end
end

# again class Person!
# could be defined anywhere.
# declare more methods.

class Person 
  def sayHello
    puts "hello world"
  end
end

Person.new.greet

class Person {
  def greet() {
    sayHello()
  }
}

p = new Person()
def pmc = ProxyMetaClass.
         getInstance(Person.class);
class MyInterceptor 
      implements Interceptor {
   def invoke

   Object beforeInvoke(Object object,
     String name, Object[] args) {
     if (name == "sayHello") {
       println "hello world"
       invoke = false
     } else {
       invoke = true
     }
   }

   boolean doInvoke() {
     return invoke
   }

   Object afterInvoke(Object obj, 
     String name, Object[] args, 
     Object res) {
     return null
   } 
}

pmc.interceptor = new MyInterceptor()
p.metaClass = pmc;
p.greet()

// Expando allows you to add properties
// dynamically. The properties may be
// Closure valued.
class Person extends Expando {
}

p = new Person()
// add a property that is a closure 
p.greet = { println "p's hello"}
// call it like a method
p.greet()

p2 = new Person()
p2.greet = { println "p2's hello" }
p2.greet()

class Person   
  def greet 
    puts "hello"
  end
end

p1 = Person.new
p2 = Person.new

# change p2's greet method
def p2.greet 
  puts "p2's hello"
end

p1.greet
p2.greet

# extend "p2" to override
# and may be even add 
# more methods
class <<p2
  def greet
    puts "p2's changed hello"
  end
  def goodbye
    puts "p2's goodbye"
  end
end

p2.greet
p2.goodbye