Download
slide1 n.
Skip this Video
Loading SlideShow in 5 Seconds..
Advanced Object-Oriented Programming Features PowerPoint Presentation
Download Presentation
Advanced Object-Oriented Programming Features

Advanced Object-Oriented Programming Features

269 Views Download Presentation
Download Presentation

Advanced Object-Oriented Programming Features

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. 10 Advanced 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) • Design and implement interfaces • Explore generics and learn how to create generic classes and generic methods 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 • Class A has instances of Class B 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 returnbase.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 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

  20. 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

  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 publicclass Student : Person Figure 10-11 Namespace reference error C# Programming: From Problem Analysis to Program Design

  23. Adding a New Using Statement (continued) Notice fully qualified name • To avoid error, could type: publicclass 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 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. 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 .ctors are constructors IL code for the method Data fields 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] abstractclass 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. 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

  32. 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

  33. 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

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

  35. 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

  36. .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

  37. .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

  38. NET Framework Interfaces (continued) • HashTable is not abstract • Implements a number of interfaces publicclass Hashtable : IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback, ICloneable • Implements the IDeserializationCallback interface C# Programming: From Problem Analysis to Program Design

  39. 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

  40. 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

  41. 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

  42. Generic Classes • Defined by inserting an identifier between left and right brackets on the class definition line • Example publicclass 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

  43. 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 publicvoid 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> (reffirstValue, refsecondValue); C# Programming: From Problem Analysis to Program Design

  44. 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

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

  46. Chapter Summary (continued) • Why polymorphic programming? • Generics • Generic Classes • Generic Methods C# Programming: From Problem Analysis to Program Design