More Inheritance

Abstract ClassesInterfaces

Briana B. MorrisonCSE 1302C

Spring 2010

2CSE 1302C

Topics• Abstract classes (p217)• Polymorph• Hiding members• Interfaces

3CSE 1302C

Polymorphism• An important concept in inheritance is that an

object of a subclass 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.

4CSE 1302C

Example Hierarchy• Consider this

hierarchy• The superclass is Figure,

which defines a method called doIt()

• One of two subclasses redefines doIt()

• If I have a variable v and sayv.doIt()

which method is called?

doIt()

doIt()

5CSE 1302C

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

6CSE 1302C

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

7CSE 1302C

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

8CSE 1302C

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

9CSE 1302C

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

10CSE 1302C

Polymorphism via Inheritance

Holiday

President’s

Mine

Christmas Birthday

11CSE 1302C

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

12CSE 1302C

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 day;day = new Christmas();

Holiday

Christmas

13CSE 1302C

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.

14CSE 1302C

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.

15CSE 1302C

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

16CSE 1302C

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

17CSE 1302C

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.

18CSE 1302C

Defining an abstract class • To declare a class as abstract, include

the abstract keyword in the class header:

accessModifier abstract class ClassName { // class body }

19CSE 1302C

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

20CSE 1302C

Example Hierarchy• We can define a Figure

hierarchy.• 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.

21CSE 1302C

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.

22CSE 1302C

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.

23CSE 1302C

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.

24CSE 1302C

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.

25CSE 1302C

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

26CSE 1302C

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

27CSE 1302C

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.

28CSE 1302C

Interfaces

public interface Doable{ public void doThis(); public int doThat(); public void doThis2 (float value, char ch); public boolean doTheOther (int num);}

interface is a reserved wordNone of the methods inan interface are given

a definition (body)

A semicolon immediatelyfollows each method header

29CSE 1302C

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.

30CSE 1302C

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.

31CSE 1302C

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

32CSE 1302C

Interfacespublic class CanDo implements Doable{ public void doThis () { // whatever }

public void doThat () { // whatever }

// etc.}

implements is areserved word

Each method listedin Doable is

given a definition

33CSE 1302C

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();

34CSE 1302C

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();

35CSE 1302C

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

36CSE 1302C

The Comparable Interface• Any class can implement Comparable to provide a

mechanism for comparing objects of that typeif (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

37CSE 1302C

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

38CSE 1302C

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#

39CSE 1302C

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)

40CSE 1302C

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

41CSE 1302C

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

42CSE 1302C

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

43CSE 1302C

Program.csusing 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();

44CSE 1302C

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(); } } }}

45CSE 1302C

Animal.csusing 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"); } }}

46CSE 1302C

Dog.csusing 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"); } }}

47CSE 1302C

Cat.csusing System;using System.Collections.Generic;using System.Text;

namespace _302_inh{ abstract class Cat : Animal { public override void MakeNoise() { Console.WriteLine("Meow"); } }

48CSE 1302C

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

49CSE 1302C

Questions?