1. C# Programming: From Problem Analysis to Program Design1 10 Advanced Object-Oriented Programming Features C# Programming: From Problem Analysis to Program Design 2 nd Edition

2. C# Programming: From Problem Analysis to Program Design2 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

3. C# Programming: From Problem Analysis to Program Design3 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

4. C# Programming: From Problem Analysis to Program Design4 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

5. C# Programming: From Problem Analysis to Program Design5 Component-Based Development Figure 10-1 Component-based development

6. C# Programming: From Problem Analysis to Program Design6 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

7. C# Programming: From Problem Analysis to Program Design7 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

8. C# Programming: From Problem Analysis to Program Design8 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

9. C# Programming: From Problem Analysis to Program Design9 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

10. C# Programming: From Problem Analysis to Program Design10 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

11. C# Programming: From Problem Analysis to Program Design11 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

12. C# Programming: From Problem Analysis to Program Design12 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

13. C# Programming: From Problem Analysis to Program Design13 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

14. C# Programming: From Problem Analysis to Program Design14 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

15. C# Programming: From Problem Analysis to Program Design15 Relationship Between the Person and Student Classes Figure 10-5 Inheritance class diagram

16. C# Programming: From Problem Analysis to Program Design16 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

17. C# Programming: From Problem Analysis to Program Design17 Using Visual Studio to Create DLL Files Figure 10-6 Creating a DLL component

18. C# Programming: From Problem Analysis to Program Design18 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

19. C# Programming: From Problem Analysis to Program Design19 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

20. C# Programming: From Problem Analysis to Program Design20 Add Reference to Base Class ( continued ) Figure 10-9 Add Reference dialog box Use Browse button to locate DLL

21. C# Programming: From Problem Analysis to Program Design21 Add Reference to Base Class ( continued ) Figure 10-10 Locating the Person.dll component

22. C# Programming: From Problem Analysis to Program Design22 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

23. C# Programming: From Problem Analysis to Program Design23 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

24. C# Programming: From Problem Analysis to Program Design24 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

25. C# Programming: From Problem Analysis to Program Design25 Creating a Client Application To Use the DLL ( continued ) Figure 10-12 DLLs referenced in the PresentationGUI class

26. C# Programming: From Problem Analysis to Program Design26 Creating a Client Application To Use the DLL ( continued ) Figure 10-13 PresentationGUI output referencing two DLLs

27. C# Programming: From Problem Analysis to Program Design27 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

28. C# Programming: From Problem Analysis to Program Design28 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

29. C# Programming: From Problem Analysis to Program Design29 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

30. C# Programming: From Problem Analysis to Program Design30 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

31. C# Programming: From Problem Analysis to Program Design31 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

32. C# Programming: From Problem Analysis to Program Design32 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

33. C# Programming: From Problem Analysis to Program Design33 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

34. C# Programming: From Problem Analysis to Program Design34 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

35. C# Programming: From Problem Analysis to Program Design35 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

36. C# Programming: From Problem Analysis to Program Design36 Defining an Interface ( continued ) Build the interface DLL using Build option from Build menu bar

37. C# Programming: From Problem Analysis to Program Design37 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

38. C# Programming: From Problem Analysis to Program Design38 Implement the Interface: PresentationGUI Application Figure 10-16 PresentationGUI output using interface methods

39. C# Programming: From Problem Analysis to Program Design39.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

40. C# Programming: From Problem Analysis to Program Design40.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

41. C# Programming: From Problem Analysis to Program Design41 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

42. C# Programming: From Problem Analysis to Program Design42 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

43. C# Programming: From Problem Analysis to Program Design43 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

44. C# Programming: From Problem Analysis to Program Design44 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

45. C# Programming: From Problem Analysis to Program Design45 Generic Classes Defined by inserting an identifier between left and right brackets on the class definition line Example public class GenericClass { public T dataMember; } – //To instantiate an object, replace the T with data type GenericClass anIdentifer = new GenericClass ( );

46. C# Programming: From Problem Analysis to Program Design46 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 (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 (ref firstValue, ref secondValue);

47. C# Programming: From Problem Analysis to Program Design47 StudentGov Application Example Figure 10-18 Problem specification for StudentGov example

48. C# Programming: From Problem Analysis to Program Design48 StudentGov Application Example ( continued )

49. C# Programming: From Problem Analysis to Program Design49 StudentGov Application Example ( continued ) Figure 10-19 Prototype for StudentGov example

50. C# Programming: From Problem Analysis to Program Design50 StudentGov Application Example ( continued ) Figure 10-20 Class diagrams for StudentGov example

51. C# Programming: From Problem Analysis to Program Design51 StudentGov Application Example ( continued ) Figure 10-21 References added to StudentGov example

52. C# Programming: From Problem Analysis to Program Design52 Properties: StudentGov Application

53. C# Programming: From Problem Analysis to Program Design53 Properties: StudentGov Application ( continued )

54. C# Programming: From Problem Analysis to Program Design54 StudentGov Application Example ( continued ) Figure 10-22 Setting the StartUp Project

55. C# Programming: From Problem Analysis to Program Design55 StudentGov Application Example ( continued ) Figure 10-23 Part of the PresentationGUI assembly

56. C# Programming: From Problem Analysis to Program Design56 StudentGov Application Example ( continued ) Figure 10-24 Output from StudentGov example

57. C# Programming: From Problem Analysis to Program Design57 Chapter Summary Major features of object-oriented languages –Abstraction –Encapsulation –Inheritance –Polymorphism Multitier applications using component-based development methods

58. C# Programming: From Problem Analysis to Program Design58 Chapter Summary ( continued ) Use inheritance to extend the functionality of user- defined classes Abstract classes –Abstract methods Partial classes Interfaces

59. C# Programming: From Problem Analysis to Program Design59 Chapter Summary ( continued ) Why polymorphic programming? Generics –Generic Classes –Generic Methods