A. Sundararajan's Weblog

/*
 * multiline comment
 */

/**
 * javadoc comment
 */

// single line comment

/*
 * multiline comment
 */

// single line comment

# 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
}

do {
  // statements
} while (condition);

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

// for-each statement uses 
// "in" keyword unlike Java

for ([var t in iterable) {
  // statements
}

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

if expression:
  # statements
elif expression:
  # statements
elif expression:
  # statements
else:
  # statements

* There can be zero or more 
  elif parts
* The else part is optional
* The keyword `elif' is short 
  for `else if'


while expression:
  # statements

Example:
while 1:
  print("hello")

for item in seq:
  # statements

Example:
a = ["Java", "JavaScript", "Jython"]
for x in a:
   print(x)

Example:

a = [ "Java", "JavaScript", "Jython"]
for x in a:
   print(x)
else:
   print("done")

// double-quoted
"hello, world"

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

"String with double-quotes"

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

""" A multiple
line string
literals like this
"""

function name(arg1, arg2) {
  // code here
}

function(arg1, arg2) {
  // code here
}

Examples:

function hello(name) {
   alert("hello, " + name);
}

var greet = function(name) {
   alert("hello, " + name);
}

// call unnamed function
greet("Sundar");

// or even

(function() { alert("hello "); })();

// nested function refers to local of
// enclosing function
function addWith(x) {
  return function(y) { return x + y; }
}

// returned function stored as value
var addTwo = addWith(2);

alert(addTwo(3));

def name(arg1, arg2):
   # code here

# anonymous functions
lambda arg1, arg2: expression

def hello():
  print("hello")

# unnamed lambdas
square = lambda x: x*x
square(10)
print("hello")

# nested function
from __future__ import nested_scopes

def func(x):
    def j(y):
       return x + y
    return j

addTwo = func(2)
print(addTwo(10))

class Foo {
    // methods
    // fields
}

JavaScript supports prototype-based object orientation. No direct support for classes. JavaScript supports first -class functions. Any function can serve as object constructor.

An object is an associative array - with keys being either string or integer. The values could be strings, numbers, object or even function (which then becomes a "method" of the object).

// a constructor function "Person"
// to create Person objects
function Person(name, age) {
   // this.foo introduces
   // new object fields.
   this.name = name;
   this.age = age;
}

// create a new Class with Class.create
var Person = Class.create();

// add methods to the new Class created
Person.prototype = {
   initialize: function(name) {
      this.name = name;
   },
   greet: function() {
      println("Hello from " + this.name);
   }
};	

class Name:    
    # methods here

Example:

class Person:
  print("class Person")


class Person:
  def greet(self):
    print("hello world")   

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

obj.fieldName = Expression

obj.fieldName = Expression

Example:

class Person:
  def setName(self, name):
    print("setting name as " +name);
    self.name = name

static int i;
static float f;

static double d;
static String s;

function Person(name, age) {
  this.name = name;
  this.age = age;
  // increment the "static" count field
  this.__proto__.count++;
}

// introduce a static "count" field
Person.prototype.count = 0;

// create two Person objects
p1 = new Person()
p2 = new Person()

// now check the Person count
println(Person.prototype.count);

// or equivalently - because 
// prototype is searched if a field 
// is not found in
// object!
println(p1.count);

class Person:
  # "static" field
  count = 0
  def __init__(self):
    Person.count += 1

# print static field value
print(Person.count)

# create two Person objects
p1 = Person()
p2 = Person()

# now print the count
print(Person.count)

return expression;
return;

return expression;
return;

return expression;
return;

class Employee extends Person {
}

class Name(Base1, Base2):
  # code here

int a[] = new int[10];
String[] s = new String[2];
a[0] = 3;
s[0] = "hello";

var a = new Array(10);
a[0] = 3;
a[1] = "hello";
println(a[0]);
println(a[1]);

# use lists
x = []
x.append(3)
x.append("hello")
print(x[0])
print(x[1])

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

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

print(a[2]);
print(s[0]);

a = [3, 4, 546]
a[0] = 3
a[1] = "hello"
print(a[0])
print(a[1])

arr.length
// but length can be assigned as well!
arr.length = 10
// array "index" can be strings -- 
// objects are associative arrays.
// arrays are objects with (mostly)
// "integer" property names
var arr = []
arr["Sun"] = "Network"
println(arr["Sun"])
println(arr.Sun)

var o = { key: value, key1: value1 }

Examples:

o = { 
      hello: "world", 
      Sun: "Network"
   }

println(o["Sun"]);

// field access syntax
println(o.Sun);

o = { key: value,
      key1: value1 }

Examples:

o = { 
      'hello': "world", 
      'Sun': "Network"
   }

print(o['hello'])
print(o['Sun'])

// function that accepts an object
function greet(arg) {
  println(arg.msg + 
          ", " + arg.name);
}

// caller passes object 
// literals with matching 
// "properties"
greet({ msg: "Hello", 
        name: "Sundar" })
greet({ name: "Sundar", 
        msg: "Hello" })

def greet(name, msg):
  print msg + ", " + name

greet(name="Sundar",msg="Hello");

class Complex:
  def __init__(self, x, y):
    self.real = x
    self.imag = y

  def __add__(self, other):
    return Complex(
      self.real + other.real,   
      self.imag + other.imag)

  def print(self):
    print "real = ", self.real
    print "imag = ", self.imag

c1 = Complex(2, 3)
c2 = Complex(3, 2)
c = c1 + c2
c.print()

class Person:
  def greet(self):
    print "Person's greet"

class Employee(Person):
  def greet(self):
    print "Employee's greet"
    Person.greet(self)

e = Employee()
e.greet()

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

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

try {
   // code that could throw three exceptions
} catch (e if e == "IOException") {
   // handler for IOException
} catch (e if e == "EOFException") {
   // handler for EOFException
}

try:
  # code that could throw exceptions
except IOError, (errno, strerror):
  # hadler for IOError
except ValueError:
  # handler for ValueError
except:  
  # handler for any-other Error
else:
  # code that will be executed if
  # exception was not thrown

package com.acme.foo;

import java.net.*;

// or import a specific class
import java.net.URL;

A Python module is a file containing Python definitions and statements. The file name is the module name with the suffix .py appended. Within a module, the module's name is available as the value of the global variable __name__.

# importing a module
import mymodule

# or import only specific stuff
from mymodule import func, func2