Transcript Little Smalltalk

3C-1
Object Oriented Languages Comparison
•
•
•
•
•
•
Purity
Typing
Language semantics
Inheritance model


Single vs. Multiple inheritance
Common root
Modular mechanisms
Generics
3C-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
Purity – Cont.
•
3C-3
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
•
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.
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
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 )
3C-6
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;
Note the difference
between objects and
primitives
myClass(){
y = new Integer(3);
x = 3;
int yValue = y.intValue(); // yValue = 3
double zValue = z.doubleValue(); // runtime error!!
}
•
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?
3C-8
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)]
]
Class Hierarchy – Cont.
•
3C-10
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?
Class Hierarchy – Cont.
C++:
•
•
Multiple inheritance is allowed
No common root class for all classes
Person
Teacher
Student
TA
3C-11
3C-12
Modularity Mechanisms
•
•
Little smalltalk: no modularity is required
•
Java: modularity mechanisms
•
•
•
•
Source code can reside in one file or multiple files
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
3C-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