C. Varela 1

Object-Oriented Programming Reflection (VRH 7.3.5)

Relationship to other models/Java (VRH 7.5,7.7)

Carlos Varela

RPI

Partly adapted with permission from:

D. Hollinger, J.J. Johns, RPI

Partly adapted with permission from:

Seif Haridi, KTH and Peter Van Roy, UCL

C. Varela 2

Overview• What is object-oriented programming?• Inheritance• Polymorphism• Static and dynamic binding• Multiple Inheritance• Crash Course in Java• Types and Classes• Method Overloading; Multimethods• Reflection

– Run-Time Reflection– Compile-Time Reflection

• Relationship to Other Programming Models– Higher-Order Programming and Object-Oriented Programming

• Active Objects

C. Varela 3

What is Java?

• A programming language.– As defined by Gosling, Joy, and Steele in the Java Language Specification

• A platform– A virtual machine (JVM) definition.

– Runtime environments in diverse hardware.

• A class library– Standard APIs for GUI, data storage, processing, I/O, and networking.

C. Varela 4

Why Java?• Java has substantial differences with C++

– error handling (compiler support for exception handling checks)– no pointers (garbage collection)– threads are part of the language– dynamic class loading and secure sandbox execution for remote code– source code and bytecode-level portability

C. Varela 5

Java notes for C++ programmers

• (Almost) everything is an object.– Every object inherits from java.lang.Object– Primitive data types are similar: boolean is not an int.

• No code outside of class definitions– No global variables

• Single class inheritance– an additional kind of inheritance: multiple interface inheritance

• All classes are defined in .java files– one top level public class per file

C. Varela 6

First Program

public class HelloWorld {

public static void main(String args[]) {

System.out.println("Hello World");

}

}

C. Varela 7

Compiling and Running

HelloWorld.java javac HelloWorld.java

java HelloWorld HelloWorld.class

compile

run

bytecode

source code

C. Varela 8

Java bytecode and interpreter

• Java bytecode is an intermediate representation of the program (stored in .class file)

• The Java interpreter starts up a new “Virtual Machine”.

• The VM starts executing the user’s class by running its main() method.

C. Varela 9

PATH and CLASSPATH

• PATH and CLASSPATH are environment variables that tell your operating system where to find programs.

• The java_home/bin directory should be in your $PATH

• If you are using any classes outside the java or javax packages, their locations must be included in your $CLASSPATH

C. Varela 10

The Language

• Data types

• Operators

• Control Structures

• Classes and Objects

• Packages

C. Varela 11

Java Primitive Data Types

• Primitive Data Types:– boolean true or false– char unicode (16 bits)– byte signed 8 bit integer– short signed 16 bit integer– int signed 32 bit integer– long signed 64 bit integer– float,double IEEE 754 floating point

C. Varela 12

Other Data Types

• Reference types (composite)– objects– arrays

• strings are supported by a built-in class named String (java.lang.String)

• string literals are supported by the language (as a special case).

C. Varela 13

Type Conversions• Conversion between integer types and floating point types.

– this includes char

• No automatic conversion from or to the type boolean.

• You can force conversions with a cast – same syntax as C/C++.

int i = (int) 1.345;

C. Varela 14

Operators

• Assignment: =, +=, -=, *=, …

• Numeric: +, -, *, /, %, ++, --, …

• Relational: ==. !=, <, >, <=, >=, …

• Boolean: &&, ||, !

• Bitwise: &, |, ^, ~, <<, >>, …

Just like C/C++!

C. Varela 15

Control Structures

Conditional statements:

if, if else, switch

Loop statements:

while, for, do

C. Varela 16

Exceptions

• Terminology:– throw an exception: signal that some condition (possibly an error)

has occurred.

– catch an exception: deal with the error.

• In Java, exception handling is necessary (forced by the compiler)!

C. Varela 17

Try/Catch/Finallytry {

// code that can throw an exception} catch (ExceptionType1 e1) { // code to handle the exception} catch (ExceptionType2 e2) { // code to handle the exception} catch (Exception e) { // code to handle other exceptions} finally { // code to run after try or any catch}

C. Varela 18

Exception Handling

• Exceptions take care of handling errors– instead of returning an error, some method calls will throw an

exception.

• Can be dealt with at any point in the method invocation stack.

• Forces the programmer to be aware of what errors can occur and to deal with them.

C. Varela 19

Concurrent Programming• Java is multi-threaded.• Two ways to create new threads:

– Extend java.lang.Thread• Overwrite “run()” method.

– Implement Runnable interface• Include a “run()” method in your class.

• Starting a thread– new MyThread().start();– new Thread(runnable).start();

C. Varela 20

The synchronized Statement

• To ensure only one thread can run a block of code, use synchronized:

synchronized ( object ) {

// critical code here

}

• Every object contains an internal lock for synchronization.

C. Varela 21

synchronized as a modifier

• You can also declare a method as synchronized:

synchronized int blah(String x) { // blah blah blah}

equivalent to: int blah(String x) { synchronized (this) { // blah blah blah }}

C. Varela 22

Classes and Objects

• All Java statements appear within methods, and all methods are defined within classes.

• Instead of a “standard library”, Java provides a set of packages with classes supported in all Java implementations.

C. Varela 23

Defining a Class

• One top level public class per .java file.– typically end up with many .java files for a single program.

– One (at least) has a static public main() method.

• Class name must match the file name!– compiler/interpreter use class names to figure out what file name

is.

• Package hierarchy should match directory structure.

C. Varela 24

Sample Class (from Java in a Nutshell)

public class Point {public double x,y;public Point(double x, double y) {

this.x = x; this.y=y;}public double distanceFromOrigin(){

return Math.sqrt(x*x+y*y);}

}

C. Varela 25

Objects and new

You can declare a variable that can hold an object:Point p;

but this doesn’t create the object!

You have to use new:Point p = new Point(3.1,2.4);

C. Varela 26

Using objects

• Just like C++: – object.method()– object.field

• BUT, never like this (no pointers!)– object->method()– object->field

C. Varela 27

Strings are special

• You can initialize Strings like this:

String blah = "I am a literal ";

• Or this ( + String operator):

String foo = "I love " + "RPI";

C. Varela 28

Arrays

• Arrays are supported as a second kind of reference type (objects are the other reference type).

• Although the way the language supports arrays is different than with C++, much of the syntax is compatible.– however, creating an array requires new

C. Varela 29

Array Examples

int x[] = new int[1000];

byte[] buff = new byte[256];

float[][] vals = new float[10][10];

C. Varela 30

Notes on Arrays

• index starts at 0.

• arrays can’t shrink or grow.– e.g., use Vector instead.

• each element is initialized.

• array bounds checking (no overflow!)– ArrayIndexOutOfBoundsException

• Arrays have a .length

C. Varela 31

Array Example Code

int[] values;

int total=0;

for (int i=0;i<values.length;i++) {

total += values[i];

}

C. Varela 32

Array Literals

• You can use array literals like C/C++:

int[] foo = {1,2,3,4,5};

String[] names = {“Joe”, “Sam”};

C. Varela 33

Reference Types

• Objects and Arrays are reference types

• Primitive types are stored as values.

• Reference type variables are stored as references (pointers that are not first-class).

• There are significant differences!

C. Varela 34

Primitive vs. Reference Types

int x=3;

int y=x;

Point p = new Point(2.3,4.2);

Point t = p;

Point p = new Point(2.3,4.2);

Point t = new Point(2.3,4.2);

There are two copies of the value 3 in memory

There is only one Point object in memory!

C. Varela 35

Passing arguments to methods

• Primitive types are passed by value: the method gets a copy of the value. Changes won’t show up in the caller.

• Reference types: the method gets a copy of the reference, so the method accesses the same object– However, the object reference is passed by value. Changing the

reference does not change the outside object!

C. Varela 36

Example

int sum(int x, int y) {x=x+y;return x;

}

void increment(int[] a) {for (int i=0;i<a.length;i++) {

a[i]++;}

}

C. Varela 37

Comparing Reference Types

• Comparison using == means:– “are the references the same?”

– (do they refer to the same object?)

• Sometimes you just want to know if two objects/arrays are identical copies.– use the .equals() method

• you need to write this for your own classes!

C. Varela 38

Packages

• You can organize a bunch of classes and interfaces into a package.– defines a namespace that contains all the classes.

• You need to use some java packages in your programs, e.g.– java.lang java.io, java.util

C. Varela 39

Importing classes and packages

• Instead of #include, you use import

• You don’t have to import anything, but then you need to know the complete name (not just the class, the package).– if you import java.io.File you can use File objects.

– If not – you need to use java.io.File inside the program.

• You need not import java.lang (imported by default).

C. Varela 40

Compiling

• Multiple Public classes:– need a file for each class.

– Telling the compiler to compile the class with main().

• automatically finds and compiles needed classes.

C. Varela 41

Access Control

• Public – everyone has access

• Private – no one outside this class has access

• Protected – subclasses have access

• Default – package-access

C. Varela 42

Final Modifier

• final class – cannot be subclassed

• final method – cannot be overriden

• final field – cannot have its value changed. Static final fields are compile time constants.

• final variable – cannot have its value changed

C. Varela 43

Static Modifier

• static method – a class method that can only be accessed through the class name, and does not have an implicit this reference.

• static field – A field that can only be accessed through the class name. There is only 1 field no matter how many instances of the class there are.

C. Varela 44

Classes vs Types

• Every object o has a class c.

• Is c the type of the object?

• Suppose d < c (d is a subclass of c) then an object o2 of class d can be used anywhere an object of class c is used (called subclass polymorphism).

• Therefore, an object o is of type c if and only if o’s class d is either:– = c, or

– < c

C. Varela 45

instanceof operator

• Dynamically checks for an object’s type.o instanceof t

• tests whether the value of o has type t (whether the class of o is assignment compatible with reference type t).

C. Varela 46

Interfaces

• A Java interface lists a number of method signatures for methods that need to be implemented by any class that “implements” the interface.

• E.g.:

public interface Figure {

public double getArea() {}

}

C. Varela 47

Interfaces

• A Java class that implements an interface must provide an implementation for all the methods in the interface.

• E.g.:

public class Point implements Figure {

...

public double getArea() { return 0.0 }

}

C. Varela 48

Multiple Interface Inheritance

• A Java class may implement more than one interface

• E.g.:

public class Circle implements Figure, Fillable {

...

public double getArea() {

return Math.PI * radius * radius;

}

public void fill(Color c) {…}

}

C. Varela 49

Using Interfaces as Types

• The Java language allows the usage of interfaces as types for polymorphism. E.g., it knows that any object of a class that implements the Figure interface will have a getArea() method:

public double totalArea(Figure[] figures) {

// sum everything updouble total=0.0;for (int i=0;i<figures.length;i++) { total += figures[i].getArea();}

return total;

}

}

C. Varela 50

Method Overloading

• In a statically typed language, a method can be overloaded by taking arguments of different types.

• E.g.:

• The return type cannot be overloaded.

• The types can be related, e.g:

public int m(Circle c){ return 1;}public int m(String s){ return 2;}

public int m(Object o){ return 1;}public int m(String s){ return 2;}

C. Varela 51

Method Dispatching and Multimethods

• Which method gets dispatched can be decided at compile-time based on declared argument types information (Java), or at run-time with multi-methods (Smalltalk, SALSA).

public int m(Object o){ return 1;}public int m(String s){ return 2;}

Object o = new Object();String s = new String(“hi”);Object os = new String(“foo”);m(o); // returns 1m(s); // returns 2m(os); // Static dispatch // returns 1; (Java) // Dynamic dispatch // returns 2. (SALSA)

C. Varela 52

Variance and Contravariance

• Assuming that class AA extends class A.

Method declaration Co-variance

Contra-variance

public int m(Object o){ return 1;

}A AA

public int m(String s){ return 2; }

AA A

C. Varela 53

Reflection

• A system is reflective if it can inspect part of its execution state while it is running.

• Introspection only reads internal state, without modifying it (also called reification)

• Reflection enables modifying execution state, and thereby changing system semantics (e.g. Lisp)

C. Varela 54

Meta Object Protocols

• Reflection applied to Object-Oriented systems• The description of how an object system works at a basic level is

called a Meta Object Protocol.• The ability to change meta-object protocol is a powerful way to

modify an object system• For example, examine (or change) inheritance hierarchy while running• Examine (or change) how inheritance works

– How method lookup is done in the class hierarchy– How methods are called

• Applications in debugging, customizing, separation of concerns (aspects)

• Invented in the context of Common Lisp Object System (CLOS).

C. Varela 55

Reflection (Introspection) in Java

• If permitted by security policy, the Java Reflection API can be used to:– Construct new class instances and arrays

– Access and modify fields (attributes) of objects and classes

– Invoke methods on objects and classes

– Access and modify elements of arrays

C. Varela 56

Reflection (Introspection) in Java

• The Java Reflection API consists of:– The class java.lang.Class– The interface java.lang.reflect.Member– The class java.lang.reflect.Field– The class java.lang.reflect.Method– The class java.lang.reflect.Constructor– The class java.lang.reflect.Array– The class java.lang.reflect.Modifier– The class java.lang.reflect.InvocationTargetException

C. Varela 57

Reflection Applications (Java)

• Applications getting run-time information about objects, use:– getField[s]– getMethod[s]– getConstructor[s]

• Applications getting compile-time information about objects (at the level provided by .class files), use:– getDeclaredField[s]– getDeclaredMethod[s]– getDeclaredConstructor[s]

C. Varela 58

Compile-Time Reflection in OpenJava

• The OpenJava Reflection API consists of:– The class openjava.mop.OJClass– The interface openjava.mop.OJMember– The class openjava.mop.OJField– The class openjava.mop.OJMethod– The class openjava.mop.OJConstructor

C. Varela 59

OpenJava translation mechanism

1. Analyzes source program to generate a class metaobject for each class

2. Invokes the member methods of class metaobjects to perform macro expansion

3. Generates the regular Java source reflecting the modifications made by the class metaobjects

4. Executes the regular Java compiler to generate corresponding byte code.

C. Varela 60

Compile-Time Reflection Applications

• Macros– E.g., verbose methods for debugging

– Implementing design patterns (e.g., Observer)

• Aspect-Oriented Programming– “Weaving” different aspects into compilable/executable programs

– e.g., encrypting/decrypting data before remote transmission

• Syntactic/semantic extensions to the language– Adding multiple inheritance

– Adding mixins

– Adding multi-methods

C. Varela 61

HOP vs.OOP

• We show how to get some of the flexibility of higher order programming in OOP

proc {NewSort Order ?SortRoutine} proc {SortRoutine InL ?OutL}

... {Order X Y Z} endend

class SortRoutineClass attr ord meth init(Order) ord Order end meth sort(InL ?OutL) ... {@ord order(X Y Z)} endend

C. Varela 62

HOP vs.OOP

• We show how to get some of the flexibility of higher order programming in OOP

X ... YP = proc{$} Some Statement with free X Y end

.... {P}

class Proc attr x y meth init(X Y) x X y Y end meth apply Some statement with @x and @Y endend

X ... YP = {New Proc init(X Y)}

.... {P apply}

C. Varela 63

HOP vs.OOP

• We show how to get some of the flexibility of higher order programming in OOP

• A lot of the higher order functionality can be coded

proc {Map Xs P Ys} .... {P X Y} Ys = Y|Yr {Map Xr P Yr}

meth map(Xs O Ys) .... {O apply(X Y)} Ys = Y|Yr map(Xr O Yr)

C. Varela 64

Exercises

• What is the difference between compile-time reflection and run-time reflection?

• Read VRH Section 7.8, Multi-methods papers.

• Review material for Partial Exam.