ObjectOriented Programming Languages - PowerPoint PPT Presentation

Loading...

PPT – ObjectOriented Programming Languages PowerPoint presentation | free to view - id: 274492-ZDYwO



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

ObjectOriented Programming Languages

Description:

Usage: ctr c; c.add(1); cout c.val(); ctr* p = new ctr(); c- add ... There are no classes, only objects. New objects are created by cloning existing objects ... – PowerPoint PPT presentation

Number of Views:273
Avg rating:3.0/5.0
Slides: 36
Provided by: hsiy
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: ObjectOriented Programming Languages


1
Object-Oriented Programming Languages
  • Principles of Object-Oriented
  • Software Development
  • (Chapter 5)

2
Objective
  • To illustrate the concepts of object-oriented
    programming languages in a broader context beyond
    the familiar Java and C interpretations.

3
Outline
  • The object paradigm
  • Comparison Smalltalk, Eiffel, C, Java
  • Dimensions of language design
  • Classless languages

4
The Notion of Object
  • The notion of objects appears in many areas of
    computer science
  • Software engineering Abstract data types
  • Artificial intelligence Frames
  • Databases Semantic data models
  • Distributed systems Capability-based computing

5
Perspectives on Object-Orientation
  • Structural
  • Capability of representing arbitrarily structures
    complex objects
  • An object is a data structure in memory
  • Operational
  • The ability to operate on complex objects through
    generic operators
  • An object represents an element of a conceptual
    model
  • Behavioral
  • The specification of types and operations
  • An object is a type, used for data abstraction

6
Characteristics of Object-Oriented Languages
  • Object creation facility
  • Must be able to instantiate objects
  • Message-passing capability
  • Must be able to communicate between objects
  • Class capability
  • Must have a mechanism for defining classes
  • Inheritance features
  • Must support some form of inheritance

7
Classifications of Object-Oriented Languages
  • Hybrid extensions to existing languages
  • O-O retrofitted to existing languages C, Lisp,
    Pascal, Prolog, etc
  • Examples C, CLOS, Objective Pascal, DLP
  • Frame-based knowledge-based reasoning
  • Frame a structure consisting of slots
  • Slot a value of an attribute or a relation to
    other frames
  • Examples KRL, LOOPS

8
Classifications (continued)
  • Distributed, concurrent, actor parallel
    computing
  • Active object executes in parallel with other
    active objects
  • Examples Concurrent Smalltalk, sC, POOL-T
  • Actor languages
  • Instead of threads, parallel execution is
    realized by self-replacement
  • Actor processes a message sent to it, and creates
    a successor object in its place, thus the same
    actor potentially takes on a different identity
  • Alternative object models
  • Removes the distinction between classes and
    objects
  • Everything is an object
  • Examples Self

9
Object-Oriented Scripting Languages
  • Many scripting languages are designed to support
    object-oriented programming
  • Built-in support
  • Embedding an O-O language
  • Javascript
  • Perl, JPL (Java-Perl module)
  • Tcl/Tk, Jacl (Tcl/Java)
  • Python, JPython

10
Objects in Javascript
ltscript languageJavascriptgt function
object_display(msg)
object method return msg
' (' this.variable ')'
function myobject()
object constructor
this.variable0 this.display
object_display return this
var a new myobject()
create
object document.write(a.display("a
message")) document.write(a.display("another
message")) lt/scriptgt
11
Outline
  • The object paradigm
  • Comparison Smalltalk, Eiffel, C, Java
  • Dimensions of language design
  • Classless languages

12
Comparing Smalltalk, Eiffel, C and Java
  • Criteria
  • Class libraries
  • Availability of sufficient class library support
  • Programming environment
  • Availability of environment to support
    development
  • Language characteristics

13
Smalltalk Example
Behavior subclass Ctr instanceVariableNames
'value' Ctr methodsFor 'initialization'
initialize value 0. Ctr methodsFor
'modifications' add aValue value
value aValue. Ctr methodsFor 'inspection'
value value
14
Eiffel Example
class counter export inc val feature
count Integer create is do count 0 end
inc( n Integer ) is require n gt
0 do count count n ensure
count old count n end val
Integer is do Result count end
invariant count gt 0 end -- class counter
15
C Example
class ctr public ctr() n 0
// constructor
ctr() cout ltlt "bye"
// destructor void add( int i 1) n
n i int val( ) return n
private int n // Usage ctr c
c.add(1) cout ltlt c.val() ctr p new ctr()
c-gtadd(1) cout ltlt c-gtval()
16
Class Libraries
  • Availability of sufficient class library support
  • Smalltalk part of language definition
  • Eiffel part of language definition
  • C STL, large number of 3rd party libraries
  • Java large number of standardized APIs

17
Programming Environment
  • What constitutes good programming environment?
  • Graphical interface for novices
  • Command line interface for experts
  • Smalltalk part of language definition
  • Eiffel part of language definition
  • C large number of commercial environments
  • Java many popular IDEs (Eclipse, JBuilder,
    Visual J, JDeveloper, NetBeans)

18
Language Characteristics
  • Uniformity of data structures
  • Documentation value
  • Reliability
  • Inheritance mechanism
  • Efficiency
  • Memory management
  • Language complexity

19
Comparison Table
20
Uniformity
  • Uniformity of treatment of data types
  • Smalltalk
  • Every data type is a class
  • Eiffel
  • Elementary data types are distinct from classes
  • C
  • Elementary data types are distinct from classes
  • Java
  • Elementary data types are distinct from classes

21
Documentation Value
  • How easy is it to read a program and to write a
    correct program?
  • Smalltalk
  • A consistent style in writing programs because
    everything is a class
  • Eiffel
  • Special keywords to formally specify correctness
    of programs and specify interfaces
  • C
  • No constructs to support documentation
  • Terse style is preferred by some over the more
    verbose languages
  • Java
  • Javadoc sets a standard for documentation

22
Reliability
  • Smalltalk
  • Dynamically typed, no type checking
  • Eiffel
  • Static type checking, correctness assertions
  • C
  • Inherits unreliability perception from C
  • Static type checking within a compilation module,
    weak support across modules
  • Consistent type system
  • Java
  • Less error-prone than C due to absence of
    pointers and built-in garbage collection

23
Inheritance
  • Smalltalk
  • Single inheritance
  • Eiffel
  • Multiple inheritance
  • C
  • Multiple inheritance
  • Java
  • Single inheritance
  • Multiple interface inheritance

24
Efficiency
  • Smalltalk
  • Interpreted
  • Eiffel
  • Compiled
  • Dynamic binding for all methods
  • C
  • Compiled
  • Inline functions, flexible memory management,
    friends
  • No garbage collection
  • Java
  • Compiled to bytecode efficiency depends on JVM

25
Language Complexity
  • Smalltalk
  • Generally considered low complexity
  • Eiffel
  • Simple object-oriented constructs
  • C
  • Highly complex
  • Large language complicated overloading
  • Java
  • Designed to be less complex than C

26
Outline
  • The object paradigm
  • Comparison Smalltalk, Eiffel, C, Java
  • Dimensions of language design
  • Classless languages

27
Design of Object-Oriented Languages
  • Object-oriented languages support the following
  • Object state operations
  • Class template for object creation
  • Inheritance sharing parts of a description
  • Data abstraction state accessible by operations
  • Strong typing compile time checking
  • Object-oriented objects classes inheritance
  • Object-based objects classes

28
Orthogonal Dimensions
  • More formally, object-oriented languages can be
    defined by the following orthogonal dimensions
  • Objects modular computing agents
  • Supports construction of modular units to which a
    principle of locality applies
  • Types expression classification
  • Types are a more general abstraction than classes
  • Dynamic typing no static type checking, only
    inability to evaluate an expression leads to
    runtime error
  • Static typing compile time determination and
    checking of the types of all variables, objects
    and expressions
  • Delegation resource sharing
  • A mechanism that allows redirection of control
    dynamically
  • A more general mechanism than forwarding a method
    call
  • Examples single inheritance, multiple
    inheritance, scope inheritance
  • Abstraction interface specification
  • What is visible and what is hidden to other
    objects?
  • External behavior specified by contracts
  • External state specified by public or protected
    attributes

29
Open Systems
  • A goal of object-oriented language design is
    openness
  • A software system is said to be open if its
    behavior can be easily modified and extended
  • Reactiveness
  • A program has a (runtime) choice between
    potential actions
  • Modularity
  • A program can be safely extended (at design time)
    by adding new components

30
Reactiveness
  • A program has a (runtime) choice between
    potential actions
  • Late binding (polymorphism) provides dynamic
    selection of alternatives depending on the
    subtype
  • Guards in concurrent languages provide a choice
    for accepting or rejecting a call

31
Modularity
  • A program can be safely extended (at design time)
    by adding new components
  • Languages must provide appropriate information
    hiding mechanisms
  • Hide details of objects from outside world
  • Usual notion of encapsulation
  • Classes provide modularity by hiding details of
    the class from the outside world
  • Hide details of outside world from objects
  • Objects should not have to know that other
    objects are on the same machine or not
  • Objects should not have to know that other
    objects are active

32
Object-based Concurrency
  • Object-based concurrency objects processes
  • Approaches
  • Add processes as a primitive data type
  • Programmer has the burden of dealing with
    synchronization
  • Implement active objects
  • Objects are simultaneously active
  • Language provides constructs to support
    synchronous communications (rendezvous)
  • Active object interrupts itself to respond to
    messages
  • Potential for deadlock exists with
    self-invocation
  • Performance issues if only a few active objects
    needed
  • Need careful choice in determining which objects
    should be active
  • Use asynchronous communication through message
    buffers
  • Instead of interrupting, queue up the messages in
    a buffer
  • Real-time constraints become impossible to
    guarantee

33
Outline
  • The object paradigm
  • Comparison Smalltalk, Eiffel, C, Java
  • Dimensions of language design
  • Classless languages

34
Classless Languages
  • Classical object model
  • Objects are instances of classes
  • Object-oriented objects classes inheritance
  • Classless languages
  • There are no classes, only objects
  • New objects are created by cloning existing
    objects
  • Objects are cloned from objects called
    prototypes
  • Inheritance is approximated by delegation
  • Object chooses which object to designate as
    parent
  • Dynamic binding is implemented by searching up
    the parent list
  • Advantages
  • Conceptually easier to create objects from
    existing examples rather than defining a
    characterization of the object through a class
  • Dynamic sharing of code and information is more
    flexible than inheritance and instantiation

35
Design Issues for Prototypes
  • State
  • Object consists of slots
  • Object consists of variables and methods
  • Creation
  • Shallow cloning copy the object
  • Deep cloning copy the object and all referenced
    objects
  • Delegation
  • Implicit delegation follow the parent chain
  • Explicit delegation object is named
  • Self language slots, shallow cloning, implicit
    delegation

36
Improving Performance
  • In pure object-oriented languages, dynamic type
    checking and dynamic binding is the rule
  • Increases flexibility
  • Performance suffers
  • Solutions
  • Special-purpose hardware
  • Hybrid languages
  • Create a hybrid language with a procedural
    language
  • Dealing with unwanted interactions can be a
    complex problem
  • Static typing
  • Bounds the language flexibility
  • Dynamic compilation
  • Perform partial evaluation, lazy compilation,
    message splitting

37
Dynamic Compilation Techniques
  • Customized compilation
  • Message inlining
  • Lazy compilation
  • Message splitting

38
Meta-Level Architectures
39
The Class Concept
  • Abstract data type interface description
  • Object generator template for creation
  • Repository for sharing resources
  • Object instance of a metaclass

40
Meta Architectures
41
Postulates class-based languages
  • Everything is an object
  • Every object belongs to a class
  • Every class inherits from the class Object
  • Class variables of an object are instance
    variables of its class

42
Reflective definition of Class
43
Summary
  • The object paradigm
  • Notion of object viewpoints
  • Classification object extensions
  • Comparing Smalltalk, Eiffel, C and Java
  • Criteria libraries, environments, language
    characteristics
  • Comparison language characteristics
  • Design dimensions of object-oriented languages
  • Object-oriented
  • Orthogonal dimensions
  • Open systems
  • Prototypes
  • Prototypes cloning and delegation
  • Performance dynamic compilation
  • Meta-level architectures
  • Class
  • Meta architecture
  • Reflection

44
Summary
  • The object paradigm
  • Notion of object viewpoints
  • Classification object extensions
  • Comparing Smalltalk, Eiffel, C and Java
  • Tradeoffs between pure and hybrid languages
  • Flexibility versus performance
  • Design dimensions of object-oriented languages
  • Object-oriented objects classes inheritance
  • Orthogonal dimensions objects, types,
    delegation, abstraction
  • Open systems are systems that can be easily
    modified and extended
  • Classless languages use cloning and delegation
    instead of instantiation and inheritance
About PowerShow.com