A. Sundararajan's Weblog

/*
 * multiline comment
 */

/**
 * javadoc comment
 */

// single line comment

/*
 * multiline comment
 */

/**
 * javadoc comment
 */

// single line comment

=begin
 Ruby doc comment
=end

# this is single line comment

if (condition) {
  // statements
}

if (condition) {
  // statements
} else if (condition) {
  // statements
} else {
  // statements
}

while (condition) {
  // statements
}

do {
  // statements
} while (condition);

for (Type t : iterable) {
  // statements
}

for (init; condition; increment) {
  // statements
}

switch (target) {
  case constant_expr:
    // statements
    [break]
  ..
  default:
    // statements
}

if (condition) {
  // statements
}

if (condition) {
  // statements
} else if (condition) {
  // statements
} else {
  // statements
}

while (condition) {
  // statements
}

while (condition) {
  // statements
}

// for-each statement uses "in" keyword 
// unlike Java
for (t in iterable) {
  // statements
}

switch (target) {
  case constant_expr:
    // statements
    [break]
  ..
  default:
    // statements
}

if condition 
  # statements
end

if condition
  # statements
elsif condition
  # statements
else
  # statements
end

while condition 
  # statements
end

unless condition
  # statements
else
  # statements
end

expression if condition
expression unless condition

# no do-while but you can use
# begin..end and put while or 
# until at the end
begin
 # statements
end until condition

begin
 # statements
end while condition

case target_expression
  when comparison 
    # statements
  when comparison
    # statements
  else
    # statements
end

// double-quoted
"hello, world"

// single-quotes are okay too
'hello, world'

// multiple line strings for
// embedded "here docs"
""" multiple
line
strings"""

// substituted strings
"String with ${expression}
interpolated"

Example:

name = 'Sundar'
// ${name} is replaced with name's value
println "Hello, ${name}"

'no interpolation'
"#{interpolation}"
%q(no interpolation)
%Q(interpolation)
%(interpolation)

<<identifier   - interpolated 
<<"identifier" - same as above
<<'identifier' - no interpolation
<<-identifier  - indent using "-"

Examples:

name = 'Sundar'
puts "Hello, #{name}"

puts(<<EOF

This is a hello world
in multiple lines

EOF
)

class Foo {
    // methods
    // fields
}

class Foo {
    // methods
    // fields
}

class Foo 
    # methods
    # fields
end

int i;
float f;
double d;
String s;

def i;
def f;
def d;
def s;

@i
@f
@d
@s

static int i;
static float f;
static double d;
static String s;

static def i;
static def f;
static def d;
static def s;
static k;

@@i
@@f
@@d
@@s

$xx 

return expression;
return;

obj.foo(param1, param2);
p.greet();

obj.foo param1, param2
"hello".substring 1, 3

nil.nil?
nil.class
nil.methods

int a[] = new int[10];
String[] s = new String[2];

a[0] = 3;
s[0] = "hello";

def a = new int[10];
def s = new String[2];

a[0] = 3;
s[0] = "hello";

// Array is a class
a = Array.new(10);
a[0] = 3;
a[1] = "hello";

int a[] = { 10, 4354, 432 }
String[] s = { "dsjfhsd", "sdfsd"}
a[0] = 3;
s[0] = "hello";

def a = [2, 3, 4354]
def s = ["hello", "world"]

a[0] = 33;

a = [3, 4, 546]
a[0] = 3;
a[1] = "hello";

Note from Guillaume Laforge: The "slashy" string syntax creates strings, in fact, it's not a regular expression per se, but it allows one to avoid to have to escape each and every character as it's the case in Java. But, this syntax doesn't really create some kind. Thanks!

[ key: value, key1: value1 ]

Examples:

v = [ 
      hello: "world", 
      Sun: "Network"
    ]

println(v["Sun"]);

{ key=> value, key1=> value1 }

Examples:

v = { 
      "hello" => "world",
      "Sun" => "Network"
    }

puts v["Sun"]

def func(arg) {
   println(arg["Sun"]);
}

// Note that we omit "[", "]"
func("Sun": "Network");

def func(arg)
   puts arg["Sun"]
end

# Note that we omit "{", "}"
func("Sun"=>"Network");

class Complex {
  double x, y;
  Complex(x, y) {
    this.x = x;
    this.y = y;
  }

  def plus(Complex c) {
    new Complex(x + c.x, y + c.y);
  }
 
  def print() {
     println("${x} +i${y}");
  }
}

c1 = new Complex(3, 2);
c2 = new Complex(1, -2);
// + calls plus method
(c1+c2).print();

class Complex 
  def initialize(x, y) 
    @real = x
    @imag = y
  end

  attr :real , true
  attr :imag , true

  def +(c) 
    Complex.new(real + c.real, imag + c.imag);
  end
 
  def print() 
     puts  "#{real} +i#{imag}";
  end
end

c1 = Complex.new(3, 2);
c2 = Complex.new(1, -2);
(c1+c2).print();

class Employee extends Person {
}

class Employee extends Person {
}

class Employee < Person
end

class X 
 def func
  puts "I'm func"
 end
end

class Y < X
 def func
  puts "I'm extended func"
  super  
 end 
end

# Nested class
class A 
  def initialize
    @y = 0
  end

  # "B" is nested in "A"
  class B 
    def initialize
      @x = 0
    end
    def f
      # ...
    end
  end
end

a = "hello"
# create a duplicate
b = a.dup

# anonymous class for "a"
class <<a
  def to_s
    "I'm special '#{self}'"
  end
  def doubleMe
    self + self
  end
end

# prints "I'm special 'hello'"
puts a.to_s

# prints "hello"
puts b.to_s

{ |param1, param2| ... }
do |param1, param2| ... end

Examples:

[3, 4, 5].each { |x| puts x }
[3, 4, 5].each do |x| 
   puts x 
end

try {
  // statements
} catch(Exception e) {
  // statements
} finally {
  // statements
}

begin
  expressions
[rescue [errorType [=> var],..]
  expressions]..
[else
  expressions]
[ensure
  expr..]
end

catch (:done) do
    # some statements
    throw :done 
end

package com.acme.foo;

import java.net.*;

module ModuleName
  # module level "functions" 
  # module level constants
  # zero or more classes
end

Example:

module Math
  PI = 3.141592654
  def Math.sin(x)
   # ..
  end
  def Math.cos(x)
   # ..
  end
end

require "name_of_file"

class Greeter {
  static greet(Person p) {
    println(p.msg);
  }
}

class Person { 
  @Property def msg;
}

p = new Person();
p.msg = "hello"
use(Greeter) {
  // with "use" we can call 
  // "greet" on "Person" object

  p.greet();
}

module Greeter
 def greet
   puts msg
 end
end

class Person
 # "include" zero or more 
 # modules to get restricted
 # (and safe!) form of multiple
 # inheritance

 include Greeter
 attr :msg, true
end

p = Person.new
p.msg = "hello"
p.greet

Class c = obj.getClass();
// assuming default constructor
Object o = c.newInstance();

klass.new
klass.new(param1, param2);

Method m = obj.getClass().getMethod(
        name, classArray);
m.invoke(thisObj, argsArray);

obj.invokeMethod(name, args);

Example:

class Person {
  def getName(name) {
     println("hello ${name}");
  }
}

p = new Person();
p.invokeMethod("getName", "Sundar");

obj.send(:name_symbol, args)

Example:

class Person 
  def greet (name)
   puts "hello, #{name}"
  end
end

p = Person.new
p.send(:greet, "Sundar")

# or alternatively

# get method object
m = p.method(:greet);

# ... and call it
m.call("Sundar");