Object-Oriented Programming Concepts Quiz

Chapter 12 Topics

• OOP Languages support procedural and data-oriented programming (e.g., C++) or functional programming (e.g., CLOS).
• Newer languages may not support other paradigms (e.g., Java, C#).
• Some languages are purely object-oriented (e.g., Smalltalk, Ruby).
• Functional languages may support OOP, but aren't discussed here.

Object-Oriented Programming

• Three major language features are:
  • Abstract data types (Chapter 11)
  • Inheritance
  • Polymorphism
• Inheritance is central to OOP and supporting languages.

Inheritance

• Productivity increases come from code reuse.
• ADTs (Abstract Data Types) are reusable but often require changes.
• Inheritance defines new classes in terms of existing ones, letting them inherit common parts.
• Inheritance addresses code reuse after minor changes and the definition of classes in a hierarchy.

Object-Oriented Concepts

• ADTs are called classes.
• Class instances are objects.
• A class that inherits is a derived class or subclass.
• Classes from which another class inherits are parent classes or superclasses.
• Subprograms defining operations on objects are called methods.
• Calls to methods are messages.
• An object's complete set of methods is its message protocol or message interface.
• Messages have a method name and destination object.
• A class often inherits all entities of its parent class.
• Inheritance can be complex due to access controls to encapsulated entities– a class can hide entities from subclasses or clients.
• A class can modify an inherited method by overriding it.

Object-Oriented Concepts (continued)

• Several ways classes differ from their parent: Adding variables/methods, modifying inherited method behavior, and defining private variables/methods.

Object-Oriented Concepts (continued)

• Two kinds of variables in a class: Class variables (one per class); Instance variables (one per object).
• Methods in a class include: Class methods (accept messages to the class); Instance methods (accept messages to objects).
• Disadvantages of inheritance: creates dependencies amongst classes that increase maintenance efforts.

Dynamic Binding

• A polymorphic variable can reference objects of the class and any descendants.
• Dynamic binding occurs when methods are called through polymorphic variables in a class hierarchy.
• This allows for more easily extended software systems during development and maintenance.

Dynamic Binding Concepts

• An abstract method only defines a protocol (without implementation).
• An abstract class contains at least one virtual method.
• An abstract class cannot be instantiated.

Design Issues for OOP Languages

• Topics of discussion in OOP languages: Exclusivity of objects, relationship between subclasses and subtypes, single/multiple inheritance, object allocation/deallocation, dynamic/static binding, nested classes, object initialization.

The Exclusivity of Objects

• The advantage of everything being an object is elegance and purity.
• The disadvantage of these systems is the relatively slow operations on simple objects
• Adding objects to an imperative-style typing system provides fast operations on simple objects but results in a confusing type system.

Are Subclasses Subtypes?

• The relationship between a parent class and a subclass object is an "is-a" relationship.
• If a derived class is "is-a" parent class, subclass objects should behave similarly to parent class objects.
• A derived class is a subtype if it has an "is-a" relationship with its parent.
• Subclasses can add variables/methods but must override parent methods "compatibly."
• Subclasses inherit implementation, but subtypes inherit both interface and behavior.

Single and Multiple Inheritance

• Multiple inheritance allows new classes to inherit from two or more classes.
• Disadvantages of multiple inheritance: Increased complexity, potential inefficiency, dynamic binding.
• In general, in cases where appropriate, multiple inheritance may be useful in cases where such relationships benefit it.

Allocation and Deallocation of Objects

• Objects can be allocated from the runtime stack following the ADT paradigm, from heap storage or explicitly.
• If objects are stack-based, a problem exists with subtypes (object slicing).
• Deallocation can be explicit or implicit.

Dynamic and Static Binding

• Should binding of messages to methods be dynamic?
• If none are dynamic, the advantages of dynamic binding are lost; if all are dynamic, it's inefficient.
• Design should allow the user to specify.

Nested Classes

• Define a new class that's needed only by one class.
• Can the new class be nested inside the class that needs it?
• Issues: visibility facilities of the nesting class to the nested class or vice versa.

Initialization of Objects

• Are objects initialized to values on creation?
• Implicit or explicit initialization of objects.
• Issues with parent class member initialization when creating a subclass object.

Support for OOP in Smalltalk

• Smalltalk is a pure OOP language.
• Everything is an object.
• Objects use local memory to store data.
• Computing occurs through objects sending messages to other objects.
• Uses a heap to allocate objects.
• Deallocation is implicit.
• Classes cannot be nested in other classes.

Support for OOP in Smalltalk (continued)

• A Smalltalk subclass inherits all instance variables, methods (instance and class), and parent class superclass.
• All subclasses are subtypes.
• Inheritance is implemented.
• Doesn't support multiple inheritance.
• Dynamic binding is fundamental, looking for a method in an object, its superclass, etc.
• Evaluation: Simple syntax and high power, but slower compared to compiled imperative languages.

Support for OOP in C++

• Evolved from C and SIMULA 67.
• Widely used OOP language.
• Mixed type system.
• Constructors/destructors present.
• Access controls (private, public, protected) for class entities.
• Class doesn't need to inherit from another class.

Support for OOP in C++ (continued)

• Access controls for members: Private (visible to members and friends); Public (visible to subclasses and clients); Protected (visible to class and subclasses; not clients).
• Inheritance can be "private."
• Public derivation passes public and protected members to subclasses as public/protected.
• Reexportation using the scope resolution operator permits accessing a private member in a child class.

Support for OOP in C++ (continued)

• Multiple inheritance is available.
• Dynamic binding by defining methods to be virtual.
• Pure virtual functions have no definition, and have no default behavior.
• A class with a pure virtual function is abstract.
• If objects are allocated from the stack, operations differ.
• Evaluation: extensive access controls, multiple inheritance, and dynamic binding make it a very useful language.

Support for OOP in Java

• Close relationship to C++.
• Data (except primitives) are objects.
• Primitive types have wrapper classes.
• Objects are heap-dynamic.
• Finalize method called when garbage collection reclaims storage.
• Interfaces include only method declarations.
• Methods can be final.
• All subclasses are subtypes.

Support for OOP in Java (continued)

• Dynamic binding is used unless a method is declared final.
• Methods are static or private to avoid overriding.
• Nested classes (inner, static, or local are hidden in package) are supported.
• Evaluation: OOP design decisions similar to C++ but with no procedural programming support, parentless classes, and dynamic method binding (uses interfaces to support multiple inheritance).

Support for OOP in C#

• Supports OOP mechanisms similar to Java.
• Includes both classes and structs.
• Classes similar to Java's; structs are less powerful, stack-dynamic constructs without inheritance.

Support for OOP in C# (continued)

• Syntax for defining classes similar to C++.
• Inherited methods in derived classes may be marked 'new' for replacement- otherwise, the original parent method can be invoked using "base.Draw()."
• Subclasses are subtypes if no members are private on the parent class.
• Only single inheritance is supported.

Support for OOP in C# (continued)

• Dynamic binding is possible by marking methods virtual.
• Derived class methods can override virtual parent methods (override keyword).
• Abstract classes have abstract methods.
• All C# classes are ultimately derived from a single class: Object.

Support for OOP in C# (continued)

• Nested classes resemble Java's static nested classes.
• C# nested classes cannot behave like Java's non-static nested classes.

Support for OOP in C# (continued)

• Evaluation:
• Newer C-based OO language.
• Differences between it and Java are minor.

Support for OOP in Ruby

• Everything is an object in Ruby.
• Computations occur via message passing.
• Class definitions are executable and allow secondary definitions to expand existing classes; method definitions are executable.
• All variables are type-less references.
• Access control is different for data and methods.
• Methods can be public, private, or protected.
• Access is checked at runtime.
• Getters and setters declared using shortcuts.

Support for OOP in Ruby (continued)

• Access to inherited methods can differ from parent classes.
• Subclasses aren't necessarily subtypes.
• All variables are typeless and polymorphic.
• Doesn't support abstract classes and does not support multiple inheritance.
• Access controls are weaker than in other languages.

Implementing OO Constructs

• Interesting issues include storage structures for instance variables and dynamic binding of messages to methods.

Instance Data Storage

• Class instance records (CIRs) store an object's state.
• CIRs are static (built at compile time).
• Subclass CIRs inherit parent variables.
• Accessing instance variables from CIRs is efficient because access is done as in records.

Dynamic Binding of Methods Calls

• Statically bound methods in a class aren't contained in the CIR.
• Methods dynamically bound to CIRs are connected to the code using a pointer.
• CIR storage structures are sometimes called virtual method tables (vtable).
• Method calls can be offsets from the beginning of the vtable.

Reflection

• Programming languages with reflection permit runtime access to object types and structure and ability to modify behavior.
• Types/structure of programs are called metadata.
• Examining program metadata is introspection.
• Interceding program execution is intercession.

Reflection (continued)

• Programs use reflection for software tools (e.g., class browsers).
• Visual IDEs use type information.
• Debuggers examine private fields and methods.
• Test systems use reflection to know class methods.

Reflection in Java

• Java provides limited reflection support from java.lang.Class.
• Java runtime instantiates a Class object for each program object.
• Class methods, getMethods, getDeclaredMethods/Method find public/all methods.

Reflection in C#

• .NET languages place intermediate code in assemblies along with program metadata.
• System.Type is the reflection namespace; getType() is used instead of getClass().

Downsides of Reflection

• Reflection has performance implications.
• Reflection exposes private fields and methods.
• Reflection can negate early type checking.
• Some code might not run under a security manager (making it non-portable).

Summary

• OOP involves ADTs, inheritance, and dynamic binding.
• Design issues include exclusivity of objects and subclasses.
• Smalltalk is purely object-oriented, and C++ has a mixed type system.
• Java and C# are primarily object-oriented, and Ruby is purely object-oriented.