1. Object Oriented Languages Comparison • Purity • Typing • Language semantics • Inheritance model • Single vs. Multiple inheritance • Common root • Modular mechanisms • Generics

2. Purity • Little smalltalk: Pure object oriented • All predefined types are classes • Exception: Integer • x <- 4 • y<- 2+2 • a<- List new; add: 1 • b<- List new; add: 1 • What is the result of the following : ( hint: == for reference equality, = for value equality ) • x == y • x = y • a == b • a = b • All user defined types are classes • All operations are messages to objects • No global functions

3. Purity – Cont. • Java: Almost pure object oriented • Not all predefined types are classes • Primitive types: int, long, float, double, boolean… • Primitives have wrapper classes they can be boxed in:m_employees.put(new Integer(employee.getNumber()), employee); • All user defined types are classes • Not all operations are messages to objects • basic arithmetic are built-in operators • flow control blocks ( if, … ) • No global functions

4. Purity – Cont. • C++: Not pure object oriented • Not all predefined types are classes • Primitive types: int, long, float, double, bool… • No built-in wrapper classes • Not all user defined types are classes • typedef • union • Not all operations are messages to objects • Global functions are allowed The reason: C compatibility.

5. Type System • Little smalltalk: • Dynamic typing – type rules are enforced at runtime • Variables have no associated types • Values of different types may be assigned to a single variable • Strong typing • The relation between a value and its type can’t be changed • Java: • Static typing – compile-time type checking • Strong typing • C++: • Static typing • Weak typing • Implicit type conversion by the compiler • Relation between a value and its type can be broken

6. Type System – Cont. Examples: • What is the value of y in the following code: • double x = 2.3; • int y = x; • C++ : 2 • Implicit conversion by the compiler • Java: compilation error !! • No conversion from double to int • What about LST ? ( hint: think how to write this code in LST )

7. Language Semantics • Little smalltalk: reference semantics • Dynamic typing prevents from determining the size • Java: reference semantics • Exception: Primitives (value semantics) class myClass{ privateint x; private Integer y; private Double z; myClass(){ y = new Integer(3); x = 3; int yValue = y.intValue(); // yValue = 3 double zValue = z.doubleValue(); // runtime error!! } Note the difference between objects and primitives

8. Language Semantics – Cont. • C++: Value semantics by default (C compatibility) • Reference semantics on reference types int a = 5; int b = 6; int& iRef = a; iRef = b; What is the value of iRef? What is the value of a?

9. Class Hierarchy Little smalltalk: • Single inheritance of both interface and implementation • class hierarchy with one common root class What does the following class do? Class mystery Object l Methods mystery new l <- List new. | DoIt : aClass l add: aClass. (aClass superClass notNil) ifTrue: [self DoIt :(aClass superClass)] ]

10. Class Hierarchy – Cont. • Java inheritance mechanisms: • Single inheritance of combination of implementation and subtype (using extends keyword) • Multiple subtype (interface) inheritance (using implements keyword). • class hierarchy with one common root class class Employee2 extends Employee, implements Serializable, Comparable{ …} What methods are inherited? What methods must be implemented?

11. Class Hierarchy – Cont. C++: • Multiple inheritance is allowed • No common root class for all classes Person Teacher Student TA

12. Modularity Mechanisms • Little smalltalk: no modularity is required • Source code can reside in one file or multiple files • Java: modularity mechanisms • One top-level class per source file • It is possible to define inner classes within the top-level class • Name of class must match the file name • Packages – a mechanism for organizing classes into namespaces. • The package is determined by the directory where the • source file is located • => Subdirectories create nested packages • C++ • Classes can be organized in name spaces • Nesting of namespaces is obtained by defining a namespace within a namespace • A class can spawn multiple files • A file can contain multiple classes

13. Generics • Generics - ability to have type parameters on a type • AKA parametric polymorphism • Little smalltalk: no special genericity support • Dynamically typed languages support generic programming inherently. • Java: Generics were introduce in JDK 1.5 • Allows creating generic data structures and algorithms • C++ Templates: • A very powerful, Turing complete mechanism