10
Advanced
Object-Oriented
Programming
Features
C# Programming: From Problem Analysis to Program Design
2nd Edition
C# Programming: From Problem Analysis to Program Design
1
Chapter Objectives
• Learn the major features of object-oriented
languages
• Design and develop multitier applications using
component-based development methods
• Use inheritance to extend the functionality of userdefined classes
• Create abstract classes that include abstract
methods
C# Programming: From Problem Analysis to Program Design
2
Chapter Objectives (continued)
• Become aware of partial classes
• Design and implement interfaces
• Understand why polymorphic programming is a
common goal in .NET
• Explore generics and learn how to create generic
classes and generic methods
• Work through a programming example that
illustrates the chapter’s concepts
C# Programming: From Problem Analysis to Program Design
3
Object-Oriented Language
Features
• Abstraction
– Abstract or identify the objects involved in the problem
• Encapsulation
– Packaging data and behaviors into a single unit
• Inheritance
– Reuse of code through extending program units
• Polymorphism
– Multiple implementations of the same behaviors
C# Programming: From Problem Analysis to Program Design
4
Component-Based Development
Figure 10-1 Component-based development
C# Programming: From Problem Analysis to Program Design
5
Component-Based Development
(continued)
• Multitier applications
– Data access tier for accessing data from text files
and databases
– Graphical user interface tier for user interaction
• Windows
• Web
• Components implemented through classes in C#
• Class library files with a dynamic link library
(DLL) extension
C# Programming: From Problem Analysis to Program Design
6
Inheritance
• Enables you to:
– Create a general class and then define specialized
classes that have access to the members of the general
class
• Associated with an "is a" relationship
– Specialized class “is a” form of the general class
• Classes can also have a "has a" relationship, not
associated with inheritance
– "has a" relationship associated with containment or
aggregation
C# Programming: From Problem Analysis to Program Design
7
Inheriting from the Object Class
• Every object inherits four methods as long as
reference to the System namespace included
Figure 10-2 Methods inherited from an object
C# Programming: From Problem Analysis to Program Design
8
Inheriting from Other .NET FCL
Classes
• Add functionality to programs with minimal
programming
• Extend System.Windows.Forms.Form class to
build GUIs (Button, Label, TextBox, ListBox)
Derived
class
Base
class
Figure 10-3 Derived class
C# Programming: From Problem Analysis to Program Design
9
Creating Base Classes for
Inheritance
• Can define your own classes from which other
classes can inherit
• Base class is called the super or parent class
• Data members are defined with a private access
modifier
• Constructors are defined with public access
modifiers
• Properties offer public access to data fields
C# Programming: From Problem Analysis to Program Design
10
Overriding Methods
• Replace the method defined at a higher level
• Keyword override included in derived class
– Base method includes virtual, abstract, or override keyword
• Overriding differs from overloading a method
– Overridden methods have exactly the same signature
– Overloaded methods each have a different signature
Figure 10-4 ToString( ) signature
C# Programming: From Problem Analysis to Program Design
11
Overriding Methods (continued)
• Example of polymorphism
– ToString( ) method can have many different definitions
– ToString( ) uses the virtual modifier implying any class
can override it
• Derived classes inherit from a base class
– Also called subclasses or child classes
• Protected access modifiers
– Access only to classes that derived from them
– Access to change data in the base class
C# Programming: From Problem Analysis to Program Design
12
Calling the Base Constructor
• To call the constructor for the base class, add
keyword :base between the constructor heading
for the subclass and the opening curly brace
public Student(string id, string fname, string lname,
string maj, int sId)
:base (id, lname, fname) // base constructor arguments
{ ...
• Base constructor must have a constructor with
matching signature
C# Programming: From Problem Analysis to Program Design
13
Using Members of the Base Class
• Scope
– Methods defined in subclass take precedence when
named the same name as member of a parent class
• Can call an overridden method of the base class
– Use keyword base before the method name
return base.GetSleepAmt( )
// Calls GetSleepAmt( ) in
// parent class
C# Programming: From Problem Analysis to Program Design
14
Relationship
Between the
Person and
Student
Classes
Figure 10-5 Inheritance class diagram
C# Programming: From Problem Analysis to Program Design
15
Making Stand-alone Components
• Compile class and create an assembly
– Assemblies are units configured and deployed in .NET
• Classes can be compiled and stored as a dynamic
link library (DLL) instead of into the EXE file
type
• Adds a reference to the DLL
– That referenced file with the .dll extension becomes
part of the application’s private assembly
C# Programming: From Problem Analysis to Program Design
16
Using Visual Studio to Create DLL Files
Figure 10-6 Creating a DLL component
C# Programming: From Problem Analysis to Program Design
17
Build Instead of Run to Create DLL
• Create the parent class first in order to use
IntelliSense
• Create the subclass class in same way as usual, except
Build instead of Run the project to create the DLL
Figure 10-7 Attempting to run a class library file
C# Programming: From Problem Analysis to Program Design
18
Add Reference to Base Class
One of the
first things
to do is Add
a Reference
to the Parent
DLL
Figure 10-8 Adding a reference to a DLL
C# Programming: From Problem Analysis to Program Design
19
Add Reference to Base Class
(continued)
Use
Browse
button
to
locate
DLL
Figure 10-9 Add Reference dialog box
C# Programming: From Problem Analysis to Program Design
20
Add Reference to Base Class
(continued)
Figure 10-10 Locating the Person.dll component
C# Programming: From Problem Analysis to Program Design
21
Adding a New Using Statement
• In the subclass class, if you simply type the
following, you receive an error message
public class Student : Person
Figure 10-11 Namespace reference error
C# Programming: From Problem Analysis to Program Design
22
Adding a New Using Statement
(continued)
Notice
• To avoid error, could type:
public class Student : PersonNamespace.Person
fully
qualified
name
• Better option is to add a using directive
using PersonNamespace; // Use whatever name you
// typed for the namespace for Person
• After typing program statements, build the DLL
from the Build option under the Build menu bar
C# Programming: From Problem Analysis to Program Design
23
Creating a Client Application To
Use the DLL
• DLL components can be reused with many
different applications
• Two Steps
– Add a reference to the DLL components
– Include a using statement with the namespace
• Then declare an objects of the component type(s)
• Use members of the derived, base, or referenced
classes
C# Programming: From Problem Analysis to Program Design
24
Creating a Client Application To
Use the DLL (continued)
Figure 10-12 DLLs referenced in the PresentationGUI class
C# Programming: From Problem Analysis to Program Design
25
Creating a Client Application To
Use the DLL (continued)
Figure 10-13 PresentationGUI output referencing two DLLs
C# Programming: From Problem Analysis to Program Design
26
Using ILDASM to View the
Assembly
• (ILDASM): Intermediate Language Disassembler
tool
• Assembly shows the signatures of all methods,
data fields, and properties
• One option – display the source code as a
comment in the assembly
• Can be run from the command line or from within
the Visual Studio IDE
– Must be added as an external tool in Visual Studio
C# Programming: From Problem Analysis to Program Design
27
ILDASM to View the Assembly
Data
fields
.ctors are
constructors
IL code for
the method
Properties converted
to methods
Figure 10-14 Student.dll assembly from ILDASM
C# Programming: From Problem Analysis to Program Design
28
Abstract Classes
• Used to prohibit other classes from instantiating
objects of the base class
• Still inherit characteristics from base class in
subclasses
• Base class can have data and method members
[access modifier] abstract class ClassIdentifier { } // Base class
C# Programming: From Problem Analysis to Program Design
29
Abstract Methods
• Only permitted in abstract classes
• Method has no body
– Implementation details of the method are left up to
classes derived from the base abstract class
[access modifier] abstract returnType
MethodIdentifier([parameter list]) ;
// No { } included
• Declaration for abstract method ends with
semicolon; NO method body or curly braces
C# Programming: From Problem Analysis to Program Design
30
Abstract Methods (continued)
• Every class that derives from the abstract class
must provide implementation details
– Sign a contract that details how to implement its
abstract methods
– Syntax error if you use the keyword static or virtual
when defining an abstract method
• No additional special keywords are used when a
new class is defined to inherit from the abstract
base class
C# Programming: From Problem Analysis to Program Design
31
Partial Classes
• Break class up into two or more files
– Each file uses partial class designation
• New features of C# 2.0
• Used by Visual Studio for Windows applications
– Code to initialize controls and set properties is placed in
a somewhat hidden file in a region labeled “Windows
Form Designer generated code”
– File is created following a naming convention of
“FormName.Designer.cs” or “xxx.Designer.cs”
– Second file stores programmer code
C# Programming: From Problem Analysis to Program Design
32
Interfaces
• All .NET languages only support single
inheritance
• Think of an interface as a class that is totally
abstract; all methods are abstract
– Abstract classes can have abstract and regular methods
– Implementing interface agrees to define details for all
of the interface’s methods
• Classes can implement any number of interfaces
– Only inherit from one class, abstract or nonabstract
C# Programming: From Problem Analysis to Program Design
33
Interfaces (continued)
• General form
[modifier] interface InterfaceIdentifier
{
// members - no access modifiers are used
}
• Members can be methods, properties, or events
– No implementations details are provided for any of its
members
C# Programming: From Problem Analysis to Program Design
34
Defining an Interface
• Can be defined as members of a namespace or
class or by compiling to a DLL
• Easy approach is to put the interface in a separate
project
– Use the Class Library template
• Unlike abstract classes, it is not necessary to use
the abstract keyword with methods
– Because all methods are abstract
C# Programming: From Problem Analysis to Program Design
35
Defining an Interface (continued)
Build
the
interface
DLL
using
Build
option
from
Build
menu
bar
C# Programming: From Problem Analysis to Program Design
36
Implement the Interface
• Follow the same steps as with the Person and
Student DLLs
– Add a reference to the file ending in .dll
– Type a using statement
• Heading for the class definition specifies base
class and one or more interfaces following the
colon (:)
[modifier] class ClassIdentifier : identifier [, identifier]
• Base class comes first
C# Programming: From Problem Analysis to Program Design
37
Implement the Interface:
PresentationGUI Application
Figure 10-16 PresentationGUI output using interface methods
C# Programming: From Problem Analysis to Program Design
38
.NET Framework Interfaces
• Play an important role in the .NET Framework
– Collection classes such as Array class and
HashTable class implement a number of interfaces
C# Programming: From Problem Analysis to Program Design
39
.NET Framework Interfaces
(continued)
• .NET Array class is an abstract class
– Implements several interfaces (ICloneable; IList;
ICollection; and IEnumerable)
– Includes methods for manipulating arrays, such as:
• Iterating through the elements
• Searching by adding elements to the array
• Copying, cloning, clearing, and removing elements from
the array
• Reversing elements
• Sorting
C# Programming: From Problem Analysis to Program Design
40
NET Framework Interfaces
(continued)
• HashTable is not abstract
– Implements a number of interfaces
public class Hashtable : IDictionary, ICollection, IEnumerable,
ISerializable, IDeserializationCallback, ICloneable
• Implements the IDeserializationCallback interface
• Explore the documentation for these classes and
interfaces
C# Programming: From Problem Analysis to Program Design
41
Polymorphism
• Ability for classes to provide different
implementations of methods called by the same
name
– ToString( ) method
• Dynamic binding
– Determines which method to call at run time based on
which object calls the method
C# Programming: From Problem Analysis to Program Design
42
Polymorphic Programming in
.NET
• Multiple classes can implement the same interface,
each providing different implementation details
for its abstract methods
– “Black box” concept
• Abstract classes, classes that derive from them, are
forced to include implementation details for any
abstract method
C# Programming: From Problem Analysis to Program Design
43
Generics
• Reduce the need to rewrite algorithms for each
data type
• Create generic classes, delegates, interfaces, and
methods
• Identify where data will change in the code
segment by putting a placeholder in the code for
the type parameters
C# Programming: From Problem Analysis to Program Design
44
Generic Classes
• Defined by inserting an identifier between left and
right brackets on the class definition line
• Example
public class GenericClass <T>
{
public T dataMember;
}
– //To instantiate an object, replace the T with data type
GenericClass <string> anIdentifer = new GenericClass <string>( );
C# Programming: From Problem Analysis to Program Design
45
Generic Methods
• Similar to defining a generic class
• Insert identifier between left and right brackets on the
method definition line to indicate it is a generic method
• Example
public void SwapData <T> (ref T first, ref T second)
{
T temp;
temp = first;
first = second;
second = temp;
}
//To call the method, specify the type following method name
SwapData <string> (ref firstValue, ref secondValue);
C# Programming: From Problem Analysis to Program Design
46
StudentGov
Application
Example
Figure 10-18 Problem specification for StudentGov example
C# Programming: From Problem Analysis to Program Design
47
StudentGov Application Example
(continued)
C# Programming: From Problem Analysis to Program Design
48
StudentGov Application Example
(continued)
Figure 10-19 Prototype for StudentGov example
C# Programming: From Problem Analysis to Program Design
49
StudentGov Application Example
(continued)
Figure 10-20 Class diagrams for StudentGov example
C# Programming: From Problem Analysis to Program Design
50
StudentGov
Application
Example
(continued)
Figure 10-21 References added to StudentGov example
C# Programming: From Problem Analysis to Program Design
51
Properties: StudentGov
Application
C# Programming: From Problem Analysis to Program Design
52
Properties: StudentGov
Application (continued)
C# Programming: From Problem Analysis to Program Design
53
StudentGov
Application
Example (continued)
Figure 10-22 Setting the StartUp Project
C# Programming: From Problem Analysis to Program Design
54
StudentGov Application Example
(continued)
Figure 10-23 Part of the PresentationGUI assembly
C# Programming: From Problem Analysis to Program Design
55
StudentGov Application Example
(continued)
Figure 10-24 Output from StudentGov example
C# Programming: From Problem Analysis to Program Design
56
Chapter Summary
• Major features of object-oriented languages
– Abstraction
– Encapsulation
– Inheritance
– Polymorphism
• Multitier applications using component-based
development methods
C# Programming: From Problem Analysis to Program Design
57
Chapter Summary (continued)
• Use inheritance to extend the functionality of userdefined classes
• Abstract classes
– Abstract methods
• Partial classes
• Interfaces
C# Programming: From Problem Analysis to Program Design
58
Chapter Summary (continued)
• Why polymorphic programming?
• Generics
– Generic Classes
– Generic Methods
C# Programming: From Problem Analysis to Program Design
59