Figure 5.6: The Class View is used to navigate the entire project.

This Class View is a specialized object browser containing the objects in your project. (You can also view your project in the object browser window if you like, but the Class View is usually more convenient for this purpose.) You can expand the various elements of your project to see every property and method of your custom objects. When you double−click a property or method in this menu, you are taken directly to the code related to that member. You can use the Class View as a menu system for your code, giving you an easy way to jump to whatever part of the code you want to view.

Overloading Constructors

Constructors enable you to send parameters when you build an object, but sometimes you don’t want to send any parameters. You can create an object in one of several ways. Classes can have more than one constructor, which makes them even more flexible. If you have more than one constructor, it is known as overloading your constructors.

Viewing the Improved Critter Class

You can make another version of the Critter class that has several constructors with different sets of parameters. Take a look at this version of the critter to see how it works. I’m showing only the constructors in this code listing because nothing else changes.

using System;

namespace CritOver

{

///<summary>

///Critter class showing overloaded constructors

///Andy Harris, 12/21/01

///</summary>

public class Critter {

108

// your basic critter //instance variables private string pName; private int pFull = 10; private int pHappy = 10; private int pAge = 0; //overloaded constructors

public Critter(string theName, int fullness, int happiness, int theAge){

name = theName; pFull = fullness; pHappy = happiness; pAge = theAge;

} // end constructor

public Critter(string theName){ name = theName;

pFull = 10; pHappy = 10; pAge = 0;

}// end constructor public Critter(){

name = ""; pFull = 10; pHappy = 10; pAge = 0;

}// end constructor

public string name ...

public string talk ...

public void age() ...

public void play() ...

public void eat() ...

} // end class

You can see that this version of the Critter class has three constructors. You can have as many constructors as you like, as long as each constructor accepts a different number and type of parameters. The number and type of values in a parameter are called a parameter signature. When you create an instance of the Critter class, the computer searches the class for a constructor with the parameter signature you specify. When you have multiple constructors with different signatures, you have overloaded constructors. Overloaded means that you have supplied more than one way to do something. You can overload any method you like, not just constructors, although constructors are the most common method to overload. Nearly every class can benefit from a variety of invocation techniques, and overloaded constructors provide this flexibility.

Trap When determining whether a parameter signature is unique, the compiler considers only the type and number of arguments, not their names. For example, new Critter("Buddy

Holly"); looks for a constructor that takes one string as an argument. If you had two constuctors in your object: public Critter(String name) {} public Critter(String description) {} The compiler would be confused as to which "Critter" you were trying to create because they look the same to the compiler.

Adding Polymorphism to Your Objects

One of the magic techniques I promised to teach you at the beginning of the chapter is polymorphism.

109

Polymorphism, in a nutshell, means that a class can do the same thing in different ways. Methods with different parameter signatures offer one form of polymorphism. Polymorphism in classes means that several classes can have the same method, but that method happens differently in each class. For example, a chainsaw, car, and motorcycle all have a start() method that starts up the engine. However, the underlying mechanics of starting a car with an electric motor activated by a key are very different from the way you kick−start a motorcycle or pull the lanyard of a chainsaw. Each object has a start() method, but the start() method is implemented differently in each type of object.

Another form of polymorphism is the ability to create things in more than one way. You can use overloaded methods and constructors to create a form of polymorphism in your classes. Imagine that you have a method that returns the square of a real number. That method could look like this:

public double getSquare(double theNumber){ return(theNumber * theNumber);

} // end getSquare

You might want another version that works on integers. You could overload the method with an integer version, as shown in the following code:

public double getSquare(int theNumber){ return (int)(theNumber * theNumber);

} // end getSquare

The version of the method that accepts an integer works the same as the one that accepts a double. Both return the same value, but they work on different types of data. You can write a program that sends an int or a double to the function without worrying about the type of input. The program works well on different types of data and automatically corrects for whatever kind of input it gets.

To take this idea to its extreme, you would need several versions of the method, one for each of the main types of data. If you look at many methods in the .NET system classes, you’ll see that they do exactly this. For example, there are 19 versions of the Console.WriteLine() method, which is why it seems as if you can send any kind of data to the WriteLine() method. The method has been so overloaded that the console object can guess how to write to the screen nearly anything you want to pass to it. Polymorphism and method overloading make your classes easier to use because a programmer using your class has choices for how to create your class. Polymorphism can also eliminate certain kinds of errors because your class can anticipate data being sent in an inappropriate format and automatically change the information to the format it needs.

Modifying the Critter Viewer in CritOver to Demonstrate Overloaded Constructors

After you add new features to a class, you improve your container class to test those new features. For the Critter Over program, I modified the CritViewer class so that it would make three versions of the critter, each with a different constructor:

using System;

namespace CritOver

{

///<summary>

///Demonstrates overloaded constructors

///</summary>

110