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?