More Inheritance

1. More Inheritance Abstract Classes Interfaces Briana B. Morrison CSE 1302C Spring 2010

2. Topics Abstract classes (p217) Polymorph Hiding members Interfaces

3. Polymorphism An important concept in inheritance is that an object of asubclass is also an object of any of its superclasses. That concept is the basis for an important OOP feature, called polymorphism. Polymorphism simplifies the processing of various objects in the same class hierarchy because we can use the same method call for any object in the hierarchy using a superclass object reference.

4. Example Hierarchy Consider thishierarchy The superclass is Figure,which defines a method called doIt() One of two subclasses redefines doIt() If I have a variable v and say v.doIt() which method is called? doIt() doIt()

5. Binding Consider the following method invocation: obj.doIt(); At some point, this invocation is bound to the definition of the method that it invokes If this binding occurred at compile time, then that line of code would call the same method every time However, C# defers method binding until run time for virtual methods-- this is called dynamic binding or late binding Late binding provides flexibility in program design

6. Polymorphism The term polymorphism literally means "having many forms" A polymorphic reference is a variable that can refer to different types of objects at different points in time The method invoked through a polymorphic reference can change from one invocation to the next All object references in C# are potentially polymorphic

7. Polymorphism Suppose we create the following reference variable: Occupation job; C# allows this reference to point to an Occupation object, or to any object of any compatible type This compatibility can be established using inheritance or using interfaces Careful use of polymorphic references can lead to elegant, robust software designs

8. References and Inheritance Assigning a child object to a parent reference is considered to be a widening conversion, and can be performed by simple assignment Assigning an parent object to a child reference can be done also, but it is considered a narrowing conversion and must be done with a cast The widening conversion is the most useful Widening – int to double Narrowing – double to int

9. Polymorphism via Inheritance It is the type of the object being referenced, not the reference type, that determines which method is invoked (donut hole type, not variable type) Suppose the Holiday class has a method called celebrate, and the Christmas class overrides it

10. Polymorphism via Inheritance Holiday Christmas Birthday President’s Mine

11. Polymorphism via Inheritance Now consider the following invocation: day.celebrate(); If day refers to a Holiday object, Holiday day; day.celebrate(); it invokes the Holiday version of celebrate; If it refers to a Christmas object, Christmas day; day.celebrate(); it invokes the Christmas version

12. References and Inheritance An object reference can refer to an object of its class, or to an object of any class related to it by inheritance For example, if the Holiday class is used to derive a class called Christmas, then a Holiday reference could be used to point to a Christmas object Holiday Christmas Holiday day; day = new Christmas();

13. Polymorphism Requirements To use polymorphism, these conditions must be true: the classes are in the same hierarchy. all subclasses override the same method. a subclass object reference is assigned to a superclass object reference. the superclass object reference is used to call the method.

14. abstract Classes and Methods An abstract class is a class that is not completely implemented. Usually, the abstract class contains at least one abstract method. An abstract method specifies an API but does not provide an implementation. The abstract method is used as a pattern for a method the subclasses should implement.

15. Abstract Classes An abstract class often contains abstract methods with no definitions (like an interface) Unlike an interface, the abstract modifier must be applied to each abstract method Also, an abstract class typically contains non-abstract methods with full definitions A class declared as abstract does not have to contain abstract methods -- simply declaring it as abstract makes it so

16. Abstract Classes The child of an abstract class must override the abstract methods of the parent, or it too will be considered abstract An abstract method cannot be defined as const or static The use of abstract classes is an important element of software design – it allows us to establish common elements in a hierarchy that are too generic to instantiate

17. More on abstract Classes An object reference to an abstract class can be declared. We use this capability in polymorphism. An abstract class cannot be used to instantiate objects (because the class is not complete). An abstract class can be extended. subclasses can complete the implementation and objects of those subclasses can be instantiated.

18. Defining an abstract class To declare a class as abstract, include the abstract keyword in the class header: accessModifier abstract class ClassName { // class body }

19. Defining an abstract Method To declare a method as abstract, include the abstract keyword in the method header: accessModifier abstract returnType methodName( argument list ); Note: The semicolon at the end of the header indicates that the method has no code. We do not use open and closing curly braces

20. Example Hierarchy We can define a Figurehierarchy. The superclass is Figure,which is abstract. (In theUML diagram, Figure is set in italics to indicate that it is abstract. We will derive two subclasses: Circle andSquare.

21. The Figure Class public abstract class Figure { private int x; private int y; private Color color; // usual constructors, accessors, // and mutators that can be implemented // abstract methods public abstract void draw( Graphics g ); public abstract double area( ); } All classes in the hierarchy will have an (x, y) coordinate and color. Subclasses will implement the draw and area method.

22. Subclasses of abstract Classes A subclass of an abstract class can implement all, some, or none of the abstract methods. If the subclass does not implement all of the abstract methods, it must also be declared as abstract. Our Circle subclass adds a radius instance variable and implements the draw and area methods. Our Square subclass adds a length instance variable and implements the draw and area methods.

23. Restrictions for Defining abstract Classes Classes must be declared abstract if the class contains any abstract methods. abstract classes can be extended. An object reference to an abstract class can be declared. abstract classes cannot be used to instantiate objects.

24. Restrictions for Defining abstract Methods abstract methods can be declared only within an abstract class. An abstract method must consist of a method header followed by a semicolon. abstract methods cannot be called. abstract methods cannot be declared as private or static. A constructor cannot be declared abstract.

25. Multiple Inheritance C# supports single inheritance, meaning that a derived class can have only one parent class Multiple inheritance allows a class to be derived from two or more classes, inheriting the members of all parents One problem with multiple inheritance is collisions, such as the same variable name in two parents, which has to be resolved C# does not support multiple inheritance In most cases, the use of interfaces gives us aspects of multiple inheritance without the overhead

26. Interfaces A class can inherit directly from only one class, that is, a class can extend only one class. To allow a class to inherit behavior from multiple sources, C# provides the interface. An interface typically specifies behavior that a class will implement. Interface members can be any of the following: ·   classes ·   constants ·   abstract methods ·   other interfaces

27. Interface Syntax To define an interface, use the following syntax:  accessModifier interface InterfaceName { // body of interface } All interfaces are abstract; thus, they cannot be instantiated. The abstract keyword, however, can be omitted in the interface definition.

28. Interfaces interfaceis a reserved word A semicolon immediately follows each method header None of the methods in an interface are given a definition (body) public interface Doable { public void doThis(); public int doThat(); public void doThis2 (float value, char ch); public boolean doTheOther (int num); }

29. Finer Points of Interfaces An interface's fields are public, static, and const. These keywords can be specified or omitted. When you define a field in an interface, you must assign a value to the field. All methods within an interface must be abstract, so the method definition must consist of only a method header and a semicolon. The abstract keyword also can be omitted from the method definition.

30. Inheriting from an Interface To inherit from an interface, a class declares that it implements the interface in the class definition, using the following syntax:   accessModifier class ClassName : SuperclassName implements Interface1, Interface2, … The extends clause is optional. A class can implement 0, 1, or more interfaces. When a class implements an interface, the class must provide an implementation for each method in the interface.

31. Interfaces An interface cannot be instantiated Methods in an interface have public visibility by default A class formally implements an interface by: stating so in the class header providing implementations for each abstract method in the interface If a class asserts that it implements an interface, it must define all methods in the interface

32. Interfaces implementsis a reserved word Each method listed inDoableis given a definition public class CanDo implements Doable { public void doThis () { // whatever } public void doThat () { // whatever } // etc. }

33. Polymorphism via Interfaces An interface name can be used as the type of an object reference variable Speaker current; The current reference can be used to point to any object of any class that implements the Speaker interface The version of speak that the following line invokes depends on the type of object that current is referencing current.speak();

34. Polymorphism via Interfaces Suppose two classes, Philosopher and Dog, both implement the Speaker interface, providing distinct versions of the speak method In the following code, the first call to speak invokes one version and the second invokes another: Speaker guest = new Philospher(); guest.speak(); guest = new Dog(); guest.speak();

35. Interfaces The C# standard class library contains many helpful interfaces The Comparable interface contains one abstract method called compareTo, which is used to compare two objects We know about the compareTo method of the String class The String class implements Comparable, giving us the ability to put strings in lexicographic order

36. The Comparable Interface Any class can implement Comparable to provide a mechanism for comparing objects of that type if (obj1.compareTo(obj2) < 0) System.out.println ("obj1 is less than obj2"); The value returned from compareTo should be negative is obj1 is less that obj2, 0 if they are equal, and positive if obj1 is greater than obj2 When a programmer designs a class that implements the Comparable interface, it should follow this intent

37. The Comparable Interface It's up to the programmer to determine what makes one object less than another For example, you may define the compareTo method of an Employee class to order employees by name (alphabetically) or by employee number The implementation of the method can be as straightforward or as complex as needed for the situation

38. Interfaces You could write a class that implements certain methods (such as compareTo) without formally implementing the interface (Comparable) However, formally establishing the relationship between a class and an interface allows C# to deal with an object in certain ways Interfaces are a key aspect of object-oriented design in C#

39. Interface Hierarchies Inheritance can be applied to interfaces as well as classes That is, one interface can be derived from another interface The child interface inherits all abstract methods of the parent A class implementing the child interface must define all methods from both the ancestor and child interfaces Note that class hierarchies and interface hierarchies are distinct (they do not overlap)

40. Designing for Inheritance As we've discussed, taking the time to create a good software design reaps long-term benefits Inheritance issues are an important part of an object-oriented design Properly designed inheritance relationships can contribute greatly to the elegance, maintainabilty, and reuse of the software Let's summarize some of the issues regarding inheritance that relate to a good software design

41. Inheritance Design Issues Every derivation should be an is-a relationship Think about the potential future of a class hierarchy, and design classes to be reusable and flexible Find common characteristics of classes and push them as high in the class hierarchy as appropriate Override methods as appropriate to tailor or change the functionality of a child Add new variables to children, but don't redefine (shadow) inherited variables

42. Inheritance Design Issues Allow each class to manage its own data; use the super reference to invoke the parent's constructor to set up its data Even if there are no current uses for them, override general methods such as toString and equals with appropriate definitions Use abstract classes to represent general concepts that lower classes have in common Use visibility modifiers carefully to provide needed access without violating encapsulation

43. Program.cs using System; using System.Collections.Generic; using System.Text; namespace _302_inh { class Program { static void Main(string[] args) { Animal a; Dog d = new Dog(); Cat c = new Tabbie(); a = c; a.MakeNoise(); a = d; a.MakeNoise();

44. Program.cs List zoo = new List(); zoo.Add(d); zoo.Add(c); zoo.Add(new Dog()); zoo.Add(new Dog()); foreach (Animal temp in zoo) { temp.MakeNoise(); } } } }

45. Animal.cs using System; using System.Collections.Generic; using System.Text; namespace _302_inh { abstract class Animal { public abstract void MakeNoise(); public abstract void MakeNoise(int a); public int weight; public Animal() { weight = 10; } public void Sleep() { Console.WriteLine("Zzzz"); } } }

46. Dog.cs using System; using System.Collections.Generic; using System.Text; namespace _302_inh { class Dog : Animal { public override void MakeNoise() { Console.WriteLine("Bark"); } public override void MakeNoise(int a) { Console.WriteLine("Bark " + a); } public void Sniff() { Console.WriteLine("Sniff sniff"); } } }

47. Cat.cs using System; using System.Collections.Generic; using System.Text; namespace _302_inh { abstract class Cat : Animal { public override void MakeNoise() { Console.WriteLine("Meow"); } }

48. class Tabbie : Cat { public override void MakeNoise(int a) { Console.WriteLine("Purr " + a); } }

49. Questions?