Java: the core language

advertisement

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 userdefined 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

– Button

– label

Applet

• 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)

Download