1. 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++

2. 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

3. white paper buzzwords (Gosling et al) Simple Object-Oriented Distributed Robust Secure Architecture neutral Portable Interpreted High Performance Multithreaded

4. 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...

5. 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

6. 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)

7. 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; }

8. 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

9. 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

10. 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(); }; }

11. 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);

12. 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

13. 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

14. 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

15. 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

16. 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)

17. 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

18. 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

19. 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

20. 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++)

21. 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);

22. 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; …};

23. 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

24. 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

25. 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

26. 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 ();

27. 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);

28. 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);

29. 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

30. A large built-in collection of classes Object –Font –Component –Container Panel Applet –Button –label Layout manager

31. 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

32. 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); }

33. 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

34. 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

35. 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 (…)...

36. 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 }

37. 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)