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

2. 3C-2Purity 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. 3C-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. 3C-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. 3C-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. 3C-6 Type System – Cont. Examples: u What is the value of y in the following code: l double x = 2.3; l int y = x; u C++ : 2 l Implicit conversion by the compiler u Java: compilation error !! l No conversion from double to int u What about LST ? ( hint: think how to write this code in LST )

7. 3C-7 Language Semantics Little smalltalk: reference semantics Dynamic typing prevents from determining the size Java: reference semantics Exception: Primitives (value semantics) class myClass{ private int 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. 3C-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. 3C-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. 3C-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. 3C-11 Class Hierarchy – Cont. C++: Multiple inheritance is allowed No common root class for all classes Person Student Teacher TA

12. 3C-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. 3C-13Generics 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