Learning Object Oriented Programming with Delphi - Free Online Course
In this chapter we look at situations where it is not necessary to change the core characteristics of an object at run time, but rather optionally to be able to add behaviour to the object’s existing behaviour.
Learning Object Oriented Programming with Delphi - TOC
Free online Borland Delphi OOP Course: Chapter Overview. Chapters make extensive use of graded, worked examples to give students hands-on experience in the implementation of OO code.
Factory Patterns - Delphi OOP Part 13 - Chapter 26
This chapter explores the Factory patterns, which, instead of changing an object’s behaviour, provide ways of creating different objects to suit run time requirements.
Bidirectional links, Callbacks and Linking Classes - OOP Part 12
Nearly all the communication between objects covered so far has been unidirectional, from an initiator to a recipient. This leaves the recipient with no possibility of using its own initiative to solicit any information it may need from the initiator, a problem we address in this chapter.
Patterns for Varying Class Behavior - Delphi OOP Part 11 - Chapter 24
This chapter of the free online Delphi OOP Course discusses techniques that make variations in a method’s behaviour possible at run time, even after compilation, either through the use of inheritance structures or through delegation.
The Adapter and Facade Patterns - Delphi OOP Part 10 - Chapter 23
Chapter summary: Using delegation (in the form of composition or association) in implementing patterns; Using the Adapter pattern; Object and class Adapters; Using the Facade pattern; Fabricating an intermediate class between other classes.
The Adapter Pattern - Delphi OOP Part 10 - Chapter 22
Delegation is an important OO principle and is used in a variety of patterns such as the Adapter, the Facade and the Strategy patterns. In this part we look at the Adapter and Facade patterns.
Association and Composition - Delphi OOP Part 9 - Chapter 21
Delphi OOP Part 9 Summary: Reviewing the different conditions for inheritance, for association and for composition. Implementing association and composition. Shallow and deep copies. Association and composition in terms of cooperation, encapsulation, ownership and propagation. PDF and Source Code download.
Association and Composition - Delphi OOP Part 9 - Chapter 20
Implementing association and composition in Borland Delphi Object Oriented Programming.
Association and Composition - Delphi OOP Part 9 - Chapter 19
When we need only a few aspects of a class, inheritance may be inappropriate for reuse since it exposes not only the aspects we need but also all those that we do not need and that should remain hidden. In these cases it is often worth considering the alternative of delegation, through either association or composition.
Indirection - Delphi OOP Part 8 - Chapter 18
In this chapter, we’ll take a slightly more sophisticated approach and use delegation instead of chaining and then look at the benefits it offers to see how it measures up against these various criteria, namely code reuse, shared responsibilities and minimal coupling.
Indirection - Delphi OOP Part 8 - Chapter 17
An important part of object orientation is the concept that a group of objects cooperate with one another to perform a particular task. To support this cooperative venture there needs to be a communication structure between the objects involved. This is called chaining (or explicit delegation).
Using and Abusing Inheritance - Delphi OOP Part 7 - Chapter 16
As we have seen preceding chapter, inheritance is very powerful and can provide significant benefits in programming. However, there are times when it is misused, leading to problems that could possibly be avoided. This section considers some of these misuses.
Using and Abusing Inheritance - Delphi OOP Part 7 - Chapter 15
Over the last few chapters we have been looking at inheritance, both subclassing andsubtyping. Programmers often do not distinguish between these two forms since they are implemented in similar ways and are often used in combination. However subclassing (class or implementation inheritance) can easily be overused and subtyping (interface inheritance)can easily be underused. Because of this we lose potential benefits of OO and develop systems that are more rigid and error prone.
Introducing Type Inheritance - Delphi OOP Part 6 - Chapter 14
Being abstract means that it does not have an implementation and so does not exist in the superclass. Each subclass then provides its own implementation. Learn how and when to implement abstract methods in Delphi applications.
Introducing Type Inheritance - Delphi OOP Part 6 - Chapter 13
Polymorphism is the combination of substitution and dynamic binding. In step 1 of this example we’ll look at what happens if we use neither substitution nor dynamic binding. In step 2 we’ll use substitution with static binding.
Introducing Type Inheritance - Delphi OOP Part 6 - Chapter 12
In this chapter we look briefly at substitution again, but in the context of programmer-generated classes. We then incorporate dynamic binding to extend substitution to the concept of polymorphism. This leads naturally to an exploration of abstract classes. The concepts of substitution, polymorphism and abstract classes are closely tied to the concept of subtyping and all three of these are important aspects of many OO patterns.
The Sender Parameter and Substitution - Delphi OOP Part 5 - Chapter 11
An important consequence of an inheritances hierarchy is the concept of substitution, where an instance of a subclass object can substitute for a variable declared as any of its supertypes. In this brief chapter we introduce the concept of substitution by investigating the Sender Delphi parameter that is part of the parameter list of every event handler.
Accessing an Object and its Data - Delphi OOP Part 4 / Chapter 10
So far in this part of the free online Delphi OOP Lessons we have looked at ways of accessing objects’ data. In this example we look at accessing the objects themselves. This chapter provides an example that shows how to create a series of Client objects, add a reference to each object to a list, in this case a TListBox component, and display the contents of each object by dereferencing the matching item in the list. The PDF the Full Source Code and Homework Solutions can be downloaded.
Accessing an Object and its Data - Delphi OOP Part 4 / Chapter 9
A consequence of providing encapsulation is that we must write access methods to provide a public interface to the data fields. Delphi also allows us to use properties for this public interface. Learn how to create properties, how to use them and what to use them for.
Accessing an Object and its Data - Delphi OOP Part 4 / Chapter 8
This chapter (of the free Delphi OOP tutorial) continues the theme of chapter 3, which introduced a programmer defined class and object and contrasted this to the RAD definitions earlier in this module. In this chapter we look at creating and freeing an object and explore the concept of a constructor and a destructor. We’ll look at Get and Set access methods and at defining properties.
Programmer Defined Classes and Objects - Delphi OOP Part 3 / Chapter 7
One way to make a computer program more robust and more amenable to change is to build it in layers. One might have a user interface layer that takes care of the interaction between the user and the program, an application layer that implements the operations required by the application, and a persistence layer that takes care of permanent storage of the data. Learn how to create 'The Three Layer' model in Delphi. This chapter discusses inheritance: deriving a new class from an existing one.
Programmer Defined Classes and Objects - Delphi OOP Part 3 / Chapter 6
One way to make a computer program more robust and more amenable to change is to build it in layers. One might have a user interface layer that takes care of the interaction between the user and the program, an application layer that implements the operations required by the application, and a persistence layer that takes care of permanent storage of the data. Learn how to create "The Three Layer" model in Delphi.
Introduction to Class Inheritance (Delphi OOP Tutorial) Chapter 5
Understanding Delphi's Visual Class Library and concepts like Class, SuperClass, SubClass, Inheritance, Polymorpism. What is TObject, what are Controls what are Components?
Introduction to Class Inheritance (Delphi OOP Tutorial)
In Chapters 1, 2 and 3 we talked about three perspectives on objects: objects as independent entities, objects as derived entities and objects as interacting entities. In this chapter we will take a first look at objects as derived entities by using one of Delphi’s RAD facilities called Visual Form Inheritance (VFI).
Learning Object Oriented Programming with Delphi: Chapter 3
Main points in this chapter: Understanding RAD generated code: classes and objects; Generating visual objects through program code as a precursor to non-visual objects; Inheritance, association and composition. Chapter 3 of the free online tutorial also brings homework problems with code solutions.
Learning Object Oriented Programming with Delphi: Chapter 2
Among the various RAD facilities that Delphi offers is a visual builder for graphical user interfaces (GUIs). This greatly simplifies the building of a user interface and allows the programmer to concentrate on programming. Adding a second form to a project, programmatically creating and freeing a form, and more...
Learning Object Oriented Programming with Delphi - Chapter 1
Use Delphi to learn (or teach) object orientation. Delphi’s roots lie in Pascal, and so it has a sound, structured foundation. It is also strongly object oriented and provides many OO characteristics such as class inheritance, static binding and dynamic binding, and reference semantics.