1 / 13

Object Oriented Languages Comparison

This article provides a comparison of object oriented languages based on purity, typing, language semantics, inheritance model, modular mechanisms, and generics. It discusses the differences between Little Smalltalk, Java, and C++ in terms of their language features and capabilities.

billywilliams
Download Presentation

Object Oriented Languages Comparison

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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

More Related