C# Programming: From Problem Analysis to Program Design 1 10 Advanced Object-Oriented Programming Features C# Programming: From Problem Analysis to Program Design 2 nd Edition
C# Programming: From Problem Analysis to Program Design 1
10Advanced Object-Oriented Programming Features
C# Programming: From Problem Analysis to Program Design 2nd Edition
C# Programming: From Problem Analysis to Program Design 2
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 user-defined classes
• Create abstract classes that include abstract methods
C# Programming: From Problem Analysis to Program Design 3
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 4
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 5
Component-Based Development
Figure 10-1 Component-based development
C# Programming: From Problem Analysis to Program Design 6
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 7
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 8
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 9
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)
Base class
Derived class
Figure 10-3 Derived class
C# Programming: From Problem Analysis to Program Design 10
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 11
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 12
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 13
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 14
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 15
Relationship Between the Person and
Student Classes
Figure 10-5 Inheritance class diagram
C# Programming: From Problem Analysis to Program Design 16
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 17
Using Visual Studio to Create DLL Files
Figure 10-6 Creating a DLL component
C# Programming: From Problem Analysis to Program Design 18
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 19
Add Reference to Base Class
Figure 10-8 Adding a reference to a DLL
One of the first things
to do is Add a Reference to the Parent
DLL
C# Programming: From Problem Analysis to Program Design 20
Add Reference to Base Class (continued)
Figure 10-9 Add Reference dialog box
Use Browse button
to locate DLL
C# Programming: From Problem Analysis to Program Design 21
Add Reference to Base Class (continued)
Figure 10-10 Locating the Person.dll component
C# Programming: From Problem Analysis to Program Design 22
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 23
Adding a New Using Statement (continued)
• To avoid error, could type:
public class Student : PersonNamespace.Person
• 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
Notice fully
qualified name
C# Programming: From Problem Analysis to Program Design 24
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 25
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 26
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 27
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 28
ILDASM to View the Assembly
Figure 10-14 Student.dll assembly from ILDASM
Data fields
.ctors are constructors
Properties converted to methods
IL code for the method
C# Programming: From Problem Analysis to Program Design 29
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 30
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 31
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 32
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 33
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 34
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 35
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 36
Defining an Interface (continued)
Build the
interface DLL using Build option from Build menu bar
C# Programming: From Problem Analysis to Program Design 37
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 38
Implement the Interface: PresentationGUI Application
Figure 10-16 PresentationGUI output using interface methods
C# Programming: From Problem Analysis to Program Design 39
.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 40
.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 41
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 42
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 43
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 44
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 45
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 46
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 47
StudentGov Application
Example
Figure 10-18 Problem specification for StudentGov example
C# Programming: From Problem Analysis to Program Design 48
StudentGov Application Example (continued)
C# Programming: From Problem Analysis to Program Design 49
StudentGov Application Example (continued)
Figure 10-19 Prototype for StudentGov example
C# Programming: From Problem Analysis to Program Design 50
StudentGov Application Example (continued)
Figure 10-20 Class diagrams for StudentGov example
C# Programming: From Problem Analysis to Program Design 51
StudentGov Application
Example (continued)
Figure 10-21 References added to StudentGov example
C# Programming: From Problem Analysis to Program Design 52
Properties: StudentGov Application
C# Programming: From Problem Analysis to Program Design 53
Properties: StudentGov Application (continued)
C# Programming: From Problem Analysis to Program Design 54
StudentGov Application
Example (continued)
Figure 10-22 Setting the StartUp Project
C# Programming: From Problem Analysis to Program Design 55
StudentGov Application Example (continued)
Figure 10-23 Part of the PresentationGUI assembly
C# Programming: From Problem Analysis to Program Design 56
StudentGov Application Example (continued)
Figure 10-24 Output from StudentGov example
C# Programming: From Problem Analysis to Program Design 57
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 58
Chapter Summary (continued)
• Use inheritance to extend the functionality of user-defined classes
• Abstract classes
– Abstract methods
• Partial classes
• Interfaces
C# Programming: From Problem Analysis to Program Design 59
Chapter Summary (continued)
• Why polymorphic programming?• Generics
– Generic Classes
– Generic Methods