124 Part II Understanding the C# Language

objects that share these common behaviors and attributes. As long as everyone agrees on what a word means, this system works well; you can express complex but precise ideas in a concise form. Without classification, it’s hard to imagine how people could think or communicate at all.

Given that classification is so deeply ingrained in the way we think and communicate, it makes sense to try to write programs by classifying the different concepts inherent in a problem and its solution and then modeling these classes in a programming language. This is exactly what you can do with modern object-oriented programming languages, such as Microsoft Visual C#.

The Purpose of Encapsulation

Encapsulation is an important principle when defining classes. The idea is that a program that uses a class should not have to worry how that class actually works internally; the program simply creates an instance of a class and calls the methods of that class. As long as those

methods do what they say they will do, the program does not care how they are implemented. For example, when you call the Console.WriteLine method, you don’t want to be bothered with all the intricate details of how the Console class physically arranges for data to be writ-

ten to the screen. A class might need to maintain all sorts of internal state information to perform its various methods. This additional state information and activity is hidden from the program that is using the class. Therefore, encapsulation is sometimes referred to as information hiding. Encapsulation actually has two purposes:

To combine methods and data inside a class; in other words, to support classification

To control the accessibility of the methods and data; in other words, to control the use of the class

Defining and Using a Class

In C#, you use the class keyword to define a new class. The data and methods of the class occur in the body of the class between a pair of braces. Here is a C# class called Circle that con-

tains one method (to calculate the circle’s area) and one piece of data (the circle’s radius):

class Circle

{

double Area()

{

return Math.PI * radius * radius;

}

int radius;

}

Note The Math class contains methods for performing mathematical calculations and fields containing mathematical constants. The Math.PI field contains the value 3.14159265358979323846, which is an approximation of the value of pi.

The body of a class contains ordinary methods (such as Area) and fields (such as radius)— remember that variables in a class are called fields. You’ve already seen how to declare variables in Chapter 2, “Working with Variables, Operators, and Expressions,” and how to write methods in Chapter 3, “Writing Methods and Applying Scope”; in fact, there’s almost no new syntax here.

Using the Circle class is similar to using other types that you have already met; you create a variable specifying Circle as its type, and then you initialize the variable with some valid data.

Here is an example:

Note the use of the new keyword. Previously, when you initialized a variable such as an int or a float, you simply assigned it a value:

int i; i = 42;

You cannot do the same with variables of class types. One reason is that C# just doesn’t provide the syntax for assigning literal class values to variables. (What is the Circle equivalent

of 42?) Another reason concerns the way in which memory for variables of class types is allocated and managed by the runtime—this is discussed further in Chapter 8, “Understanding Values and References.” For now, just accept that the new keyword creates a new instance of a class (more commonly called an object).

You can, however, directly assign an instance of a class to another variable of the same type, like this:

Circle c;

c = new Circle(); Circle d;

d = c;

However, this is not as straightforward as it first appears, for reasons that I cover in Chapter 8.

Important Don’t get confused between the terms class and object. A class is the definition of a type. An object is an instance of that type, created when the program runs.

Controlling Accessibility

Surprisingly, the Circle class is currently of no practical use. When you encapsulate your meth-

ods and data inside a class, the class forms a boundary to the outside world. Fields (such as radius) and methods (such as Area) defined in the class can be seen by other methods inside

the class but not by the outside world—they are private to the class. So, although you can create a Circle object in a program, you cannot access its radius field or call its Area method,

which is why the class is not of much use—yet! However, you can modify the definition of a field or method with the public and private keywords to control whether it is accessible from

the outside:

A method or field is said to be private if it is accessible only from the inside of the class. To declare that a method or field is private, you write the keyword private before its declaration. This is actually the default, but it is good practice to state explicitly that fields and methods are private to avoid any confusion.

A method or field is said to be public if it is accessible from both the inside and the outside of the class. To declare that a method or field is public, you write the keyword public before its declaration.

Here is the Circle class again. This time Area is declared as a public method and radius is declared as a private field:

class Circle

{

public double Area()

{

return Math.PI * radius * radius;

}

private int radius;

}

Note C++ programmers should note that there is no colon after the public and private keywords. You must repeat the keyword for every field and method declaration.

Note that radius is declared as a private field; it is not accessible from outside the class. However, radius is accessible from inside the Circle class. This is why the Area method can access the radius field; Area is inside the Circle class, so the body of Area has access to radius.

This means that the class is still of limited value because there is no way of initializing the radius field. To fix this, you can use a constructor.

Tip The fields in a class are automatically initialized to 0, false, or null depending on their type. However, it is still good practice to provide an explicit means of initializing fields.