136 |
Part II Understanding the C# Language |
double distance = origin.DistanceTo(bottomRight);
Console.WriteLine(“Distance is: {0}”, distance);
}
7.On the Debug menu, click Start Without Debugging.
8.Confirm that the value 1640.60537607311 is written to the console window.
9.Press Enter to close the application and return to Visual Studio 2008.
Understanding static Methods and Data
In the preceding exercise, you used the Sqrt method of the Math class; similarly, when looking at the Circle class, you read the PI field of the Math class. If you think about it, the way in which you called the Sqrt method or read the PI field was slightly odd. You invoked the method on the class itself, not on an object of type Math. It is like trying to write Point. DistanceTo rather than origin.DistanceTo in the code you added in the preceding exercise. So
what’s happening, and how does this work?
You will often find that not all methods naturally belong to an instance of a class; they are utility methods inasmuch as they provide a useful function that is independent of any specific
class instance. The Sqrt method is just such an example. If Sqrt were an instance method of Math, you’d have to create a Math object to call Sqrt on:
Math m = new Math(); double d = m.Sqrt(42.24);
This would be cumbersome. The Math object would play no part in the calculation of the square root. All the input data that Sqrt needs is provided in the parameter list, and the result is passed back to the caller by using the method’s return value. Objects are not really needed here, so forcing Sqrt into an instance straitjacket is just not a good idea. As well as the Sqrt
method and the PI field, the Math class contains many other mathematical utility methods, such as Sin, Cos, Tan, and Log.
In C#, all methods must be declared inside a class. However, if you declare a method or a field as static, you can call the method or access the field by using the name of the class. No
instance is required. This is how the Sqrt method of the real Math class is declared:
class Math
{
public static double Sqrt(double d) { ... }
...
}
When you define a static method, it does not have access to any instance fields defined for the class; it can use only fields that are marked as static. Furthermore, it can directly invoke
Chapter 7 Creating and Managing Classes and Objects |
137 |
only other methods in the class that are marked as static; nonstatic (instance) methods require you first to create an object on which to call them.
Creating a Shared Field
As mentioned in the preceding section, you can also use the static keyword when defining a field. With this feature, you can create a single field that is shared among all objects created
from a single class. (Nonstatic fields are local to each instance of an object.) In the following example, the static field NumCircles in the Circle class is incremented by the Circle constructor every time a new Circle object is created:
class Circle
{
public Circle() // default constructor
{
radius = 0; NumCircles++;
}
public Circle(int initialRadius) // overloaded constructor
{
radius = initialRadius; NumCircles++;
}
...
private int radius;
public static int NumCircles = 0;
}
All Circle objects share the same NumCircles field, so the statement NumCircles++; increments the same data every time a new instance is created. You access the NumCircles field by specifying the Circle class rather than a Circle object. For example:
Console.WriteLine(“Number of Circle objects: {0}”, Circle.NumCircles);
Tip static methods are also called class methods. However, static fields aren’t usually called class fields; they’re just called static fields (or sometimes static variables).
Creating a static Field by Using the const Keyword
By prefixing the field with the const keyword, you can declare that a field is static but that its value can never change. const is short for “constant.” A const field does not use the static
keyword in its declaration but is nevertheless static. However, for reasons that are beyond the scope of this book, you can declare a field as const only when the field is an enumeration, a numeric type such as int or double, or a string. (You learn about enumerations in Chapter
138 Part II Understanding the C# Language
9, “Creating Value Types with Enumerations and Structs.”) For example, here’s how the Math class declares PI as a const field:
class Math
{
...
public const double PI = 3.14159265358979323846;
}
static Classes
Another feature of the C# language is the ability to declare a class as static. A static class can contain only static members. (All objects that you create using the class share a single copy of these members.) The purpose of a static class is purely to act as a holder of utility methods and fields. A static class cannot contain any instance data or methods, and it does not make sense to try to create an object from a static class by
using the new operator. In fact, you can’t actually create an instance of an object using a static class by using new even if you want to. (The compiler will report an error if you try.) If you need to perform any initialization, a static class can have a default constructor as long as it is also declared as static. Any other types of constructor are illegal and
will be reported as such by the compiler.
If you were defining your own version of the Math class, one containing only static members, it could look like this:
public static class Math
{
public static double Sin(double x) {...} public static double Cos(double x) {...} public static double Sqrt(double x) {...}
...
}
Note, however, that the real Math class is not defined this way because it actually does have some instance methods.
In the final exercise in this chapter, you will add a private static field to the Point class and ini-
tialize the field to 0. You will increment this count in both constructors. Finally, you will write a public static method to return the value of this private static field. With this field, you can find out how many Point objects have been created.
Write static members, and call static methods
1. Using Visual Studio 2008, display the Point class in the Code and Text Editor window.
Chapter 7 Creating and Managing Classes and Objects |
139 |
2.Add a private static field called objectCount of type int to the end of the Point class. Initialize it to 0 as you declare it, like this:
class Point
{
...;
private static int objectCount = 0;
}
Note You can write the keywords private and static in any order. The preferred order is private first, static second.
3.Add a statement to both Point constructors to increment the objectCount field, as shown in bold type in the following code example.
Each time an object is created, its constructor is called. As long as you increment the objectCount in each constructor (including the default constructor), objectCount will hold the number of objects created so far. This strategy works only because objectCount is a shared static field. If objectCount were an instance field, each object would have its own personal objectCount field that would be set to 1.
The Point class should now look like this:
class Point
{
public Point()
{
this.x = -1; this.y = -1; objectCount++;
}
public Point(int x, int y)
{
this.x = x; this.y = y; objectCount++;
}
private int x, y;
private static int objectCount = 0;
}
Notice that you cannot prefix static fields and methods with the this keyword because they do not belong to the current instance of the class. (They do not actually belong to any instance.)
The question now is this: How can users of the Point class find out how many Point objects have been created? At the moment, the objectCount field is private and not available outside the class. A poor solution would be to make the objectCount field
140 |
Part II Understanding the C# Language |
publicly accessible. This strategy would break the encapsulation of the class; you would
then have no guarantee that its value was correct because anyone could change the value in the field. A much better idea is to provide a public static method that returns the value of the objectCount field. This is what you will do now.
4.Add a public static method to the Point class called ObjectCount that returns an int but does not take any parameters. In this method, return the value of the objectCount field, as follows in bold type:
class Point
{
...
public static int ObjectCount()
{
return objectCount;
}
...
}
5.Display the Program class in the Code and Text Editor window, and locate the Entrance method.
6.Add a statement to the Entrance method to write the value returned from the ObjectCount method of the Point class to the screen, as shown in bold type in the following code example. The Entrance method should look like this:
static void Entrance()
{
Point origin = new Point();
Point bottomRight = new Point(600, 800);
double distance = origin.distanceTo(bottomRight); Console.WriteLine(“Distance is: {0}”, distance);
Console.WriteLine(“No of Point objects: {0}”, Point.ObjectCount());
}
The ObjectCount method is called by referencing Point, the name of the class, and not the name of a Point variable (such as origin or bottomRight). Because two Point objects have been created by the time ObjectCount is called, the method should return the
value 2.
7.On the Debug menu, click Start Without Debugging.
Confirm that the value 2 is written to the console window (after the message displaying the value of the distance variable).
8.Press Enter to finish the program and return to Visual Studio 2008.
Congratulations. You have successfully created a class and used constructors to initialize the fields in a class. You have created instance and static methods, and you have called both of these types of methods. You have also implemented instance and static fields. You have seen
Chapter 7 Creating and Managing Classes and Objects |
141 |
how to make fields and methods accessible by using the public keyword and how to hide them using the private keyword.
Anonymous Classes
An anonymous class is a class that does not have a name. This sounds rather strange but is actually quite handy in some situations that you will see later in this book, especially when using query expressions. (You learn about query expressions in Chapter 20, “Querying In-Memory Data by Using Query Expressions.”) For the time being, just accept the fact that they are useful.
You create an anonymous class simply by using the new keyword and a pair of braces defining the fields and values that you want the class to contain, like this:
myAnonymousObject = new { Name = “John”, Age = 42 };
This class contains two public fields called Name (initialized to the string “John”) and Age (initialized to the integer 42). The compiler infers the types of the fields from the types of the data you specify to initialize them.
When you define an anonymous class, the compiler generates its own name for the class, but it won’t tell you what it is. Anonymous classes therefore raise a potentially interesting conundrum: If you don’t know the name of the class, how can you create an
object of the appropriate type and assign an instance of the class to it? In the code example shown earlier, what should the type of the variable myAnonymousObject be? The
answer is that you don’t know—that is the point of anonymous classes! However, this is not a problem if you declare myAnonymousObject as an implicitly typed variable by
using the var keyword, like this:
var myAnonymousObject = new { Name = “John”, Age = 42 };
Remember that the var keyword causes the compiler to create a variable of the same type as the expression used to initialize it. In this case, the type of the expression is whatever name the compiler happens to generate for the anonymous class.
You can access the fields in the object by using the familiar dot notation, like this:
Console.WriteLine(“Name: {0} Age: {1}”, myAnonymousObject.Name, myAnonymousObject. Age};
You can even create other instances of the same anonymous class but with different values:
var anotherAnonymousObject = new { Name = “Diana”, Age = 43 };