Java: the core language

• What it looks like:

class OnceAgain {

public static void main (String[] args){

int X = 1234;

System.out.println (“we’ve seen this before”);

}

}

• A superficial resemblance to C++

References

• Formal definition: Gosling, Joy & Steele

• White paper (early draft): Gosling

• Cornell & Horstmann : Core Java

• 10,000 other books

• Java is work in progress: no ISO standard in sight

white paper buzzwords (Gosling et al)

• Simple • Object-Oriented• Distributed • Robust• Secure• Architecture neutral

• Portable • Interpreted• High Performance• Multithreaded

Core language

• Imperative, procedural language

• Object-oriented: inheritance is central

• Garbage-collected

• conventional control structures

• Exceptions and event-handling

• concurrency can’t really be simple will al that...

The type model: primitive types and classes

• Conventional primitive types with value semantics: int, short, long, byte, float, double, char, boolean

• int Value = 123;

• char BigA = ‘A’;

• Language defines size of numeric types (eg int is 4 bytes)

• char is Unicode (16 bits)

• char badkspace = \u0008;

• Some implicit conversions on numeric operations

Classes

• The basic abstraction mechanism

• A long lineage:– Simula (algol derivative with concurrency)– Smalltalk (fully dynamic, class is everything)– Eiffel (hybrid)– C++ (Hybrid, multiple inheritance)– CLOS (dynamic, multiple inheritance)

Class encapsulates data and code

Public class counter {

counter (int init) { value = init;}

counter () { value = 0;};

public int val () { return value;};

public void incr () { value = value + 1;);

private int value;

}

Contrast with Ada

• A package contains both type declarations and subprogram declarations (like a class)

• Related types can appear in the same package (unlike a class)

• A package is not a type (unlike a class)

• Class unifies (or confuses) the notion of package and type

OO terminology

• An object is an instance of a class• A method defines a message that the object can

receive• A message is received by a particular object at

run-time• Within a method, the current object is called this

– if X is local data, a reference to X is equivalent to this.X

Using a class

class TestCounter {

counter c1 = new counter ();

counter c2 = c1; // an alias of c1

c1.incr(); // call with implicit parameter c1)

if (c1.val() > 0) c2.incr(); };

}

Is everything an object?

• Only in Smalltalk (even classes!) • Often necessary to define data and methods

without any explicit object to which they belong

public class Math {

public static double sqrt (double X);

public static final double PI = 3.14159265;

}

can then write X = Math.sqrt (Y * Math.PI);

Classes are not enough

• Need other tools for large program structuring• Packages: group of classes, with privileged

visibility • Mimics directory structure of OS

– package MyGraphics; // locus for current class

– import java.io.*; // get access to all classes therein

– public class Polygons { … } // in MyGraphics

• Interfaces: abstract classes

Predefined packages

• A large built-in programming environment– java.lang: Object, String, Math…– java.awt: graphical interface– java.awt.event : interaction with devices– java.applet: the web– java.io: stream and file manipulation– java.util: data and time– java.net: communications

Java is a high-level language

• User does not concern itself with the size of objects. Storage management is controlled by the system

• Garbage collection must be safe: user cannot manipulate addresses directly, language cannot have pointers.

• No need for destructors or free commands• Garbage collection is unpredictable: unsuitable for

real-time applications

Can you program without pointers?

• Pointers are implicit: objects and array have reference semantics

class List {

int value;

List next;

}

primitive types have value semantics

Value/Reference semantics

int x, y;

x = y; // value copy

y = y + 1; // x is unaffected

counter c1, c2;

c2 = c2; // value sharing: denote same object

c2.incr(); // c1 is modified as well

int table1 [], table2 [];

table1 = table2; // reference semantics also

Equality works like assignment (value /reference)

Value/reference choices

• Ada : reference requires explicit access types. Arrays have value semantics

• C++ : structs have value semantics

• SETL : all types have value semantics

• pure LISP : functional with no side-effects, no assignment, value semantics with implicit sharing for efficiency

Arrays and Strings

• Impractical to make them classes: standard semantics across languages, need efficient implementation

int table []; // variable definition

table = new int(100); // object allocation

• Indexing from zero. Index always checked against bounds

Multidimensional arrays and aggregates

• Multidimensional arrays are arrays of arrays

int[][] matrix =

({ 2,4,6}, {3, 6, 9}, 1, 2, 3}};

matrix [2][2] = 0;

matrix [3][3] = 100; // will raise exception

Strings

• Could be arrays (unification or confusion?)• Instead, special syntax• Many special-purpose operations

String message = “ what’s new?”;

message = message.substring (0, 6) + “up doc?”;

Note: only operator overloading in Java, no user-defined overloading (reaction to C++)

Strings are constants

• Need separate class for mutable strings:

• class StringBuffer: public int length (); // also strings and arrays

public int capacity ()

public synchronized char charAt (int index)

public synchronized void setCharAt (int index, char ch);

Inheritance

• Programming by extension and specialization:• A class refines an existing class by adding data

members and methods, and redefining methods• What is not redefined is inherited

class Point { int x = 0; int y = 0; …};

class Pixel extends Point { int R,G,B; …};

Polymorphism

• A variable of a given class can denote an

• instance of any descendant of the class:

class Root…

class Better extends Root …

class Best extends Better…

Root thing = new Root ();

.. Thing = new Best (..); // ok

Dynamic Dispatching

• If class Root has method Mangle, then all its descendants either inherit or redefine Mangle.

• Thing.Mangle(..); // what gets executed?

• Objects carry run-time identification. The class denoted by the current value of the object determines the method to be called

The power of polymorphism

• The functionality of a system can be extended by adding class extensions. The code that manipulate existing classes does not need to be modified.

• Object-oriented programming = inheritance + polymorphism + dynamic dispatching

The mother of all classes

• Every class is the extension of another.

• The root of the class hierarchy is Object

• Object has no visible data, and several generally useful methods:

boolean equals (Object O);

String ToString ();

Mixing classes and primitive types

• We want to write a “generic” matrix that can have integer or real components.

• Can write Object[][] matrix;• but can’t put numeric values in matrix because ints

are not objects.• Solution: wrapper classes

matrix [0][0] = new Integer (5);

Wrapper classes

• Integer, Float, Double, Boolean• Constructors, conversion operations, etc.• No overloading:

Integer I1, I2, I3;• can’t write:• I1 = I2 + I3;• instead

I1 = new Integer (I2.value + I3.value);

Class Object and generic programming

Object thing;

• thing can denote an instance of any class: compiler cannot check legality of any usage, all checks are at run-time.

Object [] bag;• no way to define a homogeneous bag.• The absence of templates/generics is the largest

deficiency in the language

A large built-in collection of classes

• Object– Font– Component

– Container

• Panel

• Applet

– Button

– label

• Layout manager

Superclasses and subclasses

Class Root {..};

Class Better extends Root {…};

Root thing1 = new Root ();

Object anything = new Better ();

anything = thing1; // ok

thing1 = anything; // illegal

thing1 = (Root)anything; // run-time check

Interfaces

• A package spec with no body• An abstract class that can have multiple

implementations• A substitute for genericity

public interface Comparable {

public boolean LessThan (Comparable C);

public boolean Equals (Comparable C);

}

Implementing an interface

• Any class that has operations with the right signature can be said to implement the interface:

class Point implements Comparable {

int X, Y;

public boolean LessThan (Comparable C) {

return X < (Point (C).X;

}

A class can implement multiple interfaces

Event-Driven programming

• Events happen asynchronously (mouse click, button push)

• Events are objects:– AWTevent

• ActionEvent

• ComponentEvent– ContainerEvent, PaintEvent, WindowEvent…..

• Events have a source

• Events can be handled by designated components

Event-Handling

• Delegation-based: source object notifies a registered listener

• listener must implement the appropriate interface:

Interface MouseListener {

public void MouseClicked (MouseEvent e)

public void MouseEntered (…)

public void MouseReleased (…)

...

A listener

class Ringer extends Frame implements ActionListener {

private Button ring;

public Ringer () { // constructor

ring = new Button (“press here”);

ring.addActionListener (this);

}

public void ActionPerformed (ActionEvent e) {

// play something

}

white paper buzzwords (Gosling et al)

• Simple (no chance)

• Object-Oriented (definitely)

• Distributed (yes)

• Robust (more than C/C++)

• Secure (ditto, generic programming less safe)

• Architecture neutral (the advantage of the JVM)

• Portable (if standard is developed and followed)

• Interpreted (performance penalty)

• High Performance (hope for now)

• Multithreaded (less than Ada)