the java language

BY SA

introduced in 1995 by Sun Microsystems

imperative, object-oriented C-style syntax statically-typed (mostly) no pointers JVM (Java Virtual Machine) garbage collection exceptions

SE (standard edition) EE (enterprise edition) ME (micro edition)

Java 6(2006) Java 7(2010?)

class (data type definition) field (data member) method (function member) object / instance (piece of data)

class Moose { Rat r; Hamster h; void foo() {…} }

encapsulation (methods act as “interface” to object’s fields)

object.field object.method(args) apple.banana apple.banana.orange nadine.ed() nadine.ed().laura nadine.ed().laura.dale()

object.field object.method(args) apple.banana (apple.banana).orange nadine.ed() (nadine.ed()).laura ((nadine.ed()).laura).dale ()

type name; new type(args) Moose m; // null m = new Moose(); Moose m = new Moose();

class Moose { Rat r; Hamster h; Moose() {…} // constructor void foo() {…} }

Moose() { this.r = new Rat(); this.h = new Hamster(); }

Moose(Hamster h, Rat r) { this.r = r; this.h = h; } new Moose(new Hamster(), new Rat())

inheritance AC DE F G B DE CB A CB A

Ted Kate Milton illegal

Object Jack Samantha Brad Ted Kate LisaMilton Oliver

class Terry {…} // extends Object class John extends Ben {…}

Jack Ted Kate Milton illegal

is-a vs. has-a Think before using inheritance.

Object Jack Ted Kate Lisa Mike Hugh Olivia Uri Amber (probably) bad

Hamster h = new Hamster(); Mammal m = h; h.runOnWheel(); // OK m.runOnWheel(); // illegal

void bar(Mammal m) {…} x.bar(new Mammal()) x.bar(new Hamster())

Mammal foo() { if (…) { return new Mammal(); } else { return new Hamster(); }

(type) expression Mammal m = (Mammal) new Hamster(); // upcast

(type) expression Mammal m = new Hamster(); // implicit upcast Hamster h = (Hamster) m; // downcast Hamster h = m; // illegal

Lamp l = (Lamp) new Duck (); // illegal

Object Jack Ted Kate Lisa Mike Ted t; … t.foo(); Kate k; … k.foo(); void foo() overriding (redefining an inherited method)

Nick Diane Object void foo()

Nick Diane void foo() Object

interface Philip { void foo(); } class Diane implements Philip {…} class Nick implements Philip {…}

Philip x; if (…) { x = new Nick(); } else { x = new Diane(); } x.foo(); // legal Nick Diane Object void foo()

Philip x = new Ian(); Nick Diane Object Ian void foo()

1.Compiler checks compile time type. 2.Method invoked depends upon runtime type… 3.…except this always invokes version of own class.

void bar() { this.foo(); } Mary void foo() Leo void foo() void bar() Leo l = new Leo(); l.bar();

1.Compiler checks compile time type. 2.Method invoked depends upon runtime type… 3.…except this always invokes own class’s version… 4.…and super always invokes inherited version.

void ack() { super.foo(); } Ryan void foo() void ack() Heather void foo() Heather h = new Heather(); h.ack();

void foo() { super.foo(); … } Ryan void foo() void ack() Heather void foo()

void foo(Rat r) { r.bar(this); }

void foo(Rat r) { r.bar(super); // illegal }

primitive types byte 1-byte signed integer short 2-byte signed integer int 4-byte signed integer long 8-byte signed integer char 2-byte unsigned integer boolean true and false float single-precision floating-point double double-precision floating-point

BigInteger BigDecimal (arbitrary-precision integer) (arbitrary-precision decimal)

primitive types: variable holds a value == tests equality cast produces a new value reference types: variable holds a reference == tests identity cast appeases compiler

int i = 60; float f = 5.4; i = (int)f; f = (float)i;

int i = 5; byte b = 3; b = (byte)i; i = b; // implicit cast

static member (a member which is not a member) class Ian { static Fran f; // Ian.f static void foo() {…} // Ian.foo() … }

class Ian { static Fran f; // Ian.f static void foo() {…} // Ian.foo() … } Ian i = new Ian(); i.foo(); i.f = new Fran();

1.Compiler checks compile-time type. 2.Method invoked depends upon runtime type… 3.…except this always invokes own class’s version… 4.…and super always invokes inherited version… 5.…and static determined solely by compile-time type.

package name; package shark; package pig.tiger;

shark.Ant h = new shark.Ant();

package shark; Ant h = new Ant(); pig.tiger.Cow h = new pig.tiger.Cow();

package shark; import pig.tiger.Cow; import pig.tiger.Lemur; Lemur l = new Lemur(); Cow c = new Cow();

java.lang java.lang.Object

java.lang.String String s = “hello”; int l = s.length(); // 5 s = s.toUpperCase(); // “HELLO” “Hello, ” + “Ron”  “Hello, Ron” 5 + “ golden rings”  “5 golden rings”

public (everywhere) protected * (same package + subclasses) default (same package) private * (same class) * applicable only to members visibility

overloading (same name, different method) void foo() void foo(Mammal m, Lamp l) byte foo(int a) void foo(Lamp l, Mammal m) Sean s = new Sean(); s.foo(new Lamp(), new Mammal()); s.foo(35); Sean

overloading (same name, different method) void foo() void foo(Mammal m, Lamp l) byte foo(int a) // conflict void foo(Lamp l, Mammal m) float foo(int b) // conflict Sean s = new Sean(); s.foo(35); // ambiguous Sean

overloading (same name, different method) void foo() void foo(Mammal m, Lamp l) byte foo(int a) void foo(Lamp l, Mammal m) char foo(Lamp l, Animal m) Sean s = new Sean(); s.foo(new Lamp(), new Hamster()); Sean

overloading (same name, different method) void foo() void foo(Mammal m, Lamp l) byte foo(int a) void foo(Lamp l, Mammal m) char foo(Lamp l, Animal m) Sean

void foo(int a) (overload) void foo() (override) void foo() Jill Donald

Jill void foo(int a) (overload) char foo() (illegal) Donald void foo()

Moose(Hamster h, Rat r) { this.r = r; this.h = h; } Moose() { this.r = new Rat(); this.h = new Hamster(); } new Moose(new Hamster(), new Rat())

Moose(Hamster h, Rat r) { this.r = r; this.h = h; } Moose() { this(new Hamster(), new Rat()); }

Moose(Hamster h, Rat r) { this.r = r; this.h = h; } Moose() { // not what we want new Moose(new Hamster(), new Rat()); }

Moose(Hamster h, Rat r) { this.r = r; this.h = h; } Moose() { // sensical, but not legal Java Moose(new Hamster(), new Rat()); }

Moose(Hamster h, Rat r) { this.r = r; this.h = h; } Moose() { this(new Hamster(), new Rat()); }

Moose(Hamster h, Rat r) { super(); // invoke constructor of Moose’s parent this.r = r; this.h = h; } Moose() { this(new Hamster(), new Rat()); }

Object Jack Ted Kate new Kate()

1.Constructors invoked only via new, this(), or super(). 2.Calls to this() and super() only can be first line. 3.The first line is always this() or super(). 4.Default first line is super() with no arguments. constructor rules

// infinite recursion Moose(Hamster h, Rat r) { this(); } Moose() { this(new Hamster(), new Rat()); }

1.Constructors invoked only via new, this(), or super(). 2.The first line is always this() or super(). 3.Calls to this() and super() only go in first line. 4.Default first line is super() with no arguments. 5.A this() call cannot be recursive. 6.To return, always just use return ; constructor rules

Object Throwable Exception RuntimeException Error exceptions

Cat c; … c.meow(); // exception if c is null

Cat c; … try { c.meow(); // exception if c is null } catch (NullPointerException e) { … }

Object Throwable Exception RuntimeException* Error* *unchecked

// illegal void bar() { if (…) { throw new Leo(); // checked exception }

// OK void bar() throws Leo { if (…) { throw new Leo(); // checked exception }

// OK void bar() { try { if (…) { throw new Leo(); // checked exception } } catch (Leo e) { … }

void bar() throws FooException, AckException {…} void bar() throws Exception {…}

arrays (fixed-sized, homogenous collection) Apple ref Apple[] Apple object Fuji object

Mammal[] m; m = new Mammal[3]; m[2] = new Mammal(); m[0] = new Cat(); int i = m.length; // 3

Object Lisa Jerry Natalie Wyatt Object[] Lisa[] Jerry[] Natalie[] Wyatt[]

Cat[] c = new Cat[3]; Mammal[] m = c; Object[] o1 = c; Object o2 = c;

Mammal[] m = new Cat[4]; m[0] = new Mammal(); // exception

Mammal[] m = new Cat[4]; m[0] = new Cat(); Cat mittens = m[0]; // compile error

Mammal[] m = new Cat[4]; m[0] = new Cat(); Cat mittens = (Cat) m[0]; // OK

Object Lisa Jerry Natalie Wyatt Object[][] Lisa[][] Jerry[][] Natalie[][] Wyatt[][]

Apple[] ref Apple[][] Apple[] object Fuji[] object

Cat[][] c = new Cat[3][]; c[1] = new Cat[5]; c[1][0] = new Cat();

Cat[][] c = new Cat[3][]; c[1] = new Cat[5]; (c[1])[0] = new Cat();

Object Lisa Jerry Natalie Wyatt Object[][][] Lisa[][][] Jerry[][][] Natalie[][][] Wyatt[][][]

Apple[][] ref Apple[][][] Apple[][] object Fuji[][] object

Object Object[][][]Object[][] Object[] Object[][][][]

int int[]

int[] ref int[][] int[] object

Object char[][][]byte[][]int[]float[]

public class HelloWorld { public static void main(String[] args) { System.out.println(“Hello, world!”); } Hello, world!

inner classes generics abstract classes wrapper classes enumerations annotations assert final