Who is this book for?

To-Do:

• Talk about the intended audience (first-term programming students)
• What are LOGs
• Instructor’s Guide (a future book)

The ABCs of Programming with Objects

An “Objects-First” Introduction to Programming

Learning how to program is a journey into thinking about things and how to manipulate them. For a long time, most instructors and teachers who’ve taken up the challenge of teaching programming have done so with a focus on the manipulations and less concern with the things the program represents. This procedural mindset has been the way many of us (myself included) learned programming in the first place. The problem with this mindset, however, is that “real” programs haven’t been written that way for decades now.

Object-Oriented Programming (OOP) has been around for a long time, but it can be hard to adjust one’s approach from a procedural mindset to become comfortable with OOP. This book aims at offering a way to teach programming starting with OOP, rather than tacking it on at the end. Through simple examples, and a focus on the things first, this book will guide the student (and the teacher) through numerous examples that introduce all the concepts needed to get started in programming with Objects.

The essence of this OOP-First approach are seen in what I call the “ABCs of Classes and Objects”. From these first three topics I move to the “traditional” concerns of programming, all the while placing them within their most natural context: Objects.

Topic A

This topic is the first of a three-part introduction to object-oriented programming. The focus of this first part is to introduce classes and methods. This topic does not go beyond the use of static methods in a class.

Introduction

The purpose of this topic is to introduce the class as the central piece of modern computer programs. A computer program is “a set of instructions for manipulating information.” Notice the two key elements of a computer program: Instructions and Information. A class is a kind of template that groups together data (information) and instructions for manipulating that data.

Manipulating information is done through something called “methods”. A method is basically a set of instructions that has an overall name (method name). Methods cannot exist on their own; methods must exist in a “context”, and the context for all methods is the class. Methods are where programmers tell a computer “what to do.”

Every computer program has one important method that is the entry point or starting point for running the program: main. The main method must be publicly available in order for the operating system to be able to run the program.

Topic B

The focus of this second part is to show how classes act as templates for creating objects. This topic limits itself to showing a) how to create (instantiate) objects using classes and b) how classes can be used to describe what an object “looks like”.

Introduction

The purpose of this topic is to show how classes don’t just “contain” methods: Classes act as templates for defining complex types of information (objects). In fact, a class can almost be thought of as a “mini-program”, because a class brings together the two key elements of every program: Instructions and Information. With classes, we can create objects that do what we want them to.

The class is the basic building block for creating objects. As a template, a class describes
a) What an object “looks like” (that is, what information is inside the object), and
b) How an object “works” (that is, what instructions an object can perform on data).

This topic focuses on the first part – describing what an object “looks like” – by introducing fields and exploring the idea of object state.

Topic C

The focus of this third part is to show the concepts of encapsulation and information hiding as well as good object design by creating private fields and introducing public getters/setters and constructors.

Introduction

The purpose of this topic is to highlight how a major responsibility of every class is to “protect” the data within the class. This is done by designing classes that only use private fields and that “expose” access to the values of those fields through getter and setter methods. Getters and setters provide a way for the programmer to control access to fields in an object and to ensure that the fields are “used correctly”.

(Note: Later topics will address how to write code that tests the values coming through the setters’ parameters to ensure that only “acceptable” values are allowed into an object’s fields.)

This topic also covers the important role of constructors in ensuring that objects have a “stable state” at the moment that they are created. In other words, constructors are responsible to ensure that all of the fields in an object are filled with “meaningful” values. A constructor also forces other code to supply required information when creating (instantiating) an object based on that class. Constructors are the “first line of defense” for ensuring that objects are created properly.

Thinking In OOP

What is a Computer Program

Introduction

What is a computer program? A computer program is basically a set of instructions for manipulating information. To be of any value, the information used by a computer program must have a way to get into the program (input) and get out of the program (output). That may sound too simplistic, but ultimately it is entirely accurate; even the most sophisticated computer program can do nothing more than process information (albeit, in a very fast and efficient way), and no matter how cool the program looks, if there is no way to put information into it and get information out of it then it’s not of much use to anyone.

The most familiar kind of input and output (or I/O) in a computer program comes from the user. Textual information is entered (input) from the user via the keyboard and displayed (output) to the user via the monitor. Other means of user I/O can include computer mice, microphones, speakers, printers, fax machines, Braille readers, touch screens, stylus, etc.

Besides handling user I/O, computer programs can also do file or database I/O. Computer files and databases allow information to be persistent. Information is said to be persistent when it can be stored outside of the computer program and later retrieved for further processing. The combination of a) user I/O, b) fast and accurate processing, and c) persistent information storage is what makes computer programs so useful.

Variables, Values and Data Types

”… manipulating information.”

At the heart of all computer programs is the idea of information or data. This is especially true in Object-Oriented Programming languages. With information being such a critical component of computer programs, it’s important to understand what we mean by information.

It’s All About Information

Since computer programs are all about handling information, it is important to understand something about the different kinds of information programs deal with. Essentially, most information falls into one of the following categories:

• Numeric information (e.g.: a person’s age or the price of a vehicle)
• Textual information (e.g.: the title of a book)
• Conceptual information (e.g.: truth - whether a statement is considered true or false)

These different kinds of information can be said to be primitive. They represent the most basic kind of data that today’s computer programs have to deal with. These three kinds of information can be further subdivided into fundamental data types:

Any meaningful handling of information requires the understanding of three related (but distinct) concepts: variables, values, and data types.

In order for a computer program to manipulate information, it needs a way to hold or refer to information. This is the concept of a variable. A variable is a name or identifier used to refer to a single piece of information. It acts like a container that allows a program to refer to a piece of information indirectly, without being dependent on the exact content of that information. One analogy is that a variable is like a cup: a cup can be used to hold different kinds of liquids (water, juice, or even motor oil). The cup is independent of the liquid (the cup can even be empty), but it provides an effective way of working with a liquid (for example, measuring the amount of water used in a recipe).

Besides the idea of a variable that can hold information, there is the concept of a value. Unlike a variable (which is only used to refer to a piece of information), a value is the specific information contained in a variable. Returning to the previous analogy of a cup, a value is like the specific liquid inside the cup (variable). What does a particular cup hold? Is it water or motor oil? The cup is not what’s really important; what’s important is what is in the cup (especially if you are making a recipe!).

The final concept is one that has already been alluded to: the idea of a data type. A data type refers to the kind of information that a variable can hold. For example, the kind of material that a cup is designed to hold is a liquid. The description “liquid” is a description of the type of content that the cup can hold. A plate, on the other hand, is designed to hold a different kind of material - something that is solid (such as a steak or chicken cordon bleu). More specifically, the “data type” that a plate is intended to hold is “food” and steak would qualify as a type of food while motor oil would not. Notice that the concept of data type (e.g.: “food”) can be applied to both the variable (plate) and the value (steak).

This brings up an important consideration: The data type of a variable should be appropriate for the kind of information the variable is intended to hold. There is a close relationship between variables, values and data types, even though those three ideas refer to different things. Cups are used to hold liquids; plates are used to hold food; and a balloon is used to hold a gas. It would be entirely inappropriate (if not impossible) to use a balloon to hold a piece of cake! Using these analogies, the concepts of variable, value and data type can be clearly distinguished:

Returning to the way these concepts are used in a computer program, the following table gives some examples of variables and values for the data types fundamental to most high-level programming languages.

Rules About Variables, Values and Data Types

It has been stated that while variables, values and data types are distinct concepts, they are closely related. This close association between these concepts allows us to work with and manipulate information. Before we can begin working with these concepts in a simple program, however, we need to establish some basic rules about how to work with variables, values and data types.

The first rule has already been alluded to in the previous section: The data type of a value must match the data type of the variable that stores the value. This rule is closely related to a second rule: A variable and its data type must be declared before the variable can be used. Whenever a variable name is first identified in a computer program, the data type of the variable must be declared. Stating, or declaring, what the data type of a variable is will allow a computer program to know two things:

• How much computer memory must be set aside for the variable’s value.
• How to interpret a value stored in a variable.

A variable cannot be used until it is declared, and once a variable’s data type has been identified it can only hold values that match that data type. For example, if a variable called Status has been declared as a character, then it can only hold a character value (such as ‘T’ or ‘5’). Any attempt to store a value of a different type (such as “Temporary”) in Status would produce an error in the computer program.

A third rule that is related to the second is that once a variable’s data type has been declared, its data type cannot be changed.¹ This is because a variable’s data type tells the computer how to interpret the variable’s value (e.g.: is it a character or a number?), and any attempt to change the data type would result in a misinterpretation of the previously stored value.

Another rule is that each primitive variable in a computer program can only hold a single value at any given moment in time. The reason for this rule is so that the computer knows what value to supply when a variable is used in the program. In fact, when a primitive variable’s data type is declared, the computer sets aside enough memory to store only one value - no more! If a new value is stored in the variable, then any previously stored value is lost. This also gives an advantage to the programmer - it is easier to plan for and test a computer program if you can predict what value will be stored in the variable. Since a variable can only hold one value at a time, it is not unusual for a computer program to use many variables.

Notice that this last rule applies to variables with primitive data types. Often, computer programs allow the creation of more complex data types, such as classes and arrays. The rule of a variable storing only one value changes slightly for these complex types. In the case of classes, one variable whose type is based on a class can only store one object (even though the object might be complex and hold many values). Likewise, a variable that refers to an array can only refer to one array (even though arrays can hold many values). These complex data types will be discussed in a later lesson.

Lastly, in order for a computer program to distinguish one variable from another, each variable (in a given scope) must have a distinct name. If two variables were given identical names, then the computer would not be able to tell which variable to use in a given calculation. By giving each variable a different name, it is easier for both the computer and the programmer to keep track of which ones to use.

Notice, however, the qualification to this rule: in a given scope. In general, scope refers to the context in which a variable is used. If two variables are used in two different contexts, then it is permissible to use the same variable name because the computer uses the different contexts to tell them apart (similar to how two people can have the same first name but be distinguished from each other if they have different last names). An obvious (and trivial) example of this is if a variable called Age is used in two different computer programs, then the computer can tell which variable to use because it knows which program it is currently running. Usually, the term scope is used to refer to distinctly different contexts within the same computer program. The idea of scope will be discussed in more detail later. To begin with, most of the programs will be fairly simple and will only have one scope, so it is fair to simplify this rule as each variable must have a distinct name.

In summary, the basic rules for variables, values and data types are:

• Any value stored in a variable must be of the same data type as the variable.
• Variables must be declared before they can be used.
• A variable’s data type can only be declared once.
• Each primitive variable can only hold one value at a given time.
• Each variable must have a distinct name.

Programming Languages and Coding Instructions

”… a set of instructions …”

What Programmers Write

Programmers write code in plain-text files known as source files. The language that a programmer use to write code is called a programming language. Just as with human languages, there are many different programming languages. Some examples of modern programming languages are C# (the language used in this book), Java, Visual Basic .Net, SQL, and JavaScript. In addition, many other programming languages have been developed over the years such as Python, Lisp, Fortran, Cobol, Haskell, C, C++, and many more.

Each programming language defines their own words (called keywords), punctuation and grammar rules (or syntax). And like human languages, programming languages typically promote certain “world-views” or perspectives on how code should be written. Some languages emphasize the steps involved in manipulating information (a Procedural perspective). Others put the emphasis on the information itself (as in most Object-Oriented programming languages).

In all cases, programming languages allow us to write instructions that manipulate *data. Through variables, a computer program has the ability to manipulate the values stored in those variables. This manipulation of stored information is accomplished by giving the computer specific instructions on what manipulations to perform.

What Computers “See”

Programming languages allow programmers to give instructions to a computer in a form that is more familiar to and easier to use by the programmer. Today’s programming languages are known as high-level languages because they incorporate simple words with familiar meanings in English, such as if, else, while, do, and return. Low-level languages, such as Assembler, use more cryptic commands and are much closer to machine language, thereby making them harder for programmers to work with.

The exact form that the instructions will take depends on the programming language that is used. These instructions are then examined by a special program (a compiler, an assembler, or an interpreter) and translated into machine language. Machine language consists of a series of ones (1) and zeros (0) which act as on and off switches in the computer’s memory. These on and off switches change other information that is stored in memory, resulting in the manipulation of information.

The on and off switches in computer memory represent the flow of electricity through the computer. Millions and billions of these switches (also known as “gates” - no relation to Bill) are arranged on tiny computer chips in highly sophisticated patterns to allow for the organized flow of electricity. It is this organized flow of ones and zeros that allow us to use these machines for fast and efficient information processing.

Doing the Math

High-level programming languages (such as C++, C#, and Visual Basic) make it relatively easy to manipulate the values of variables. Assignment statements tell the computer to store specific values into specific variables. Assignment statements are often used with expressions, which are combinations of variables, values, and/or operators (such as Arithmetic operators). It is through expressions and assignment statements that the bulk of a computer’s work is done.

Expressions allow new values to be computed based on existing values. For example, if a variable called Cost has the value $5.95 and another variable called Markup has a value of 2.0, then a mathematical expression such as Cost * Markup can be used to create a new value - $11.90 (the Cost multiplied by the Markup value). Using this expression in an assignment statement, this resulting value of the expression can then be stored in another variable:

Price = Cost * Markup

All numeric information can be used with the common arithmetic operators of addition, subtraction, multiplication, and division. When combined to create complex expressions, the commonly accepted rules of mathematics are used to determine which operations should be used first (multiplication and division before addition and subtraction). The order of operations can be modified by using parentheses, as in regular mathematics.

Some arithmetic operations, such as calculating the remainder of a division operation, are only applicable to certain types of numeric information. Some languages supply a special symbol to represent these operations while other languages require the use of special library functions to perform the math. Complex arithmetic operations, such as calculating the sine of an angle, are typically done using library functions. Library functions are simply specialized routines or sets of instructions that can be called upon to do the required calculations.

The following chart summarizes key arithmetic operations and their corresponding symbols as used in the more common high-level programming languages. The chart also shows some of the more complex operations and the names of the library functions used to calculate them (for specific details on using functions, see the documentation for the corresponding language).

The only “arithmetic” operation that is typically applied to string data types is addition. The addition of two strings is usually interpreted as the concatenation (joining together) of the two string values into a single string value.

Besides performing assignment statements and expressions, programming languages have instructions that allow the program to control which instructions to perform and which ones to skip over. These control statements allow for performing mutually exclusive instructions (this or that) and for performing certain instructions repeatedly. High level languages also incorporate mechanisms to identify sets of instructions as particular groups or functions as well as ways to call these program-defined functions whenever they are needed.

Summary

Information comes in various forms and programmers can create both simple and complex sets of instructions to manipulate that information. Successful computer programs combine the best techniques for user I/O, information processing, and persistent storage in order to meet the needs of individuals and businesses. Grasping the basic concepts of computer programs - variables, values, data types, I/O, assignments and expressions, and control statements - is fundamental to the efficient and effective development of computer software.

The C# Language

C# (pronounced ‘See-sharp’) is a programming language developed by Microsoft and rooted in the earlier languages of C and C++. It is an Object-Oriented programming language that has evolved quite a bit over time, with each released version adding new features and capabilities to the language. At present, C# is in version 6.0 and version 7.0 is under development. Like every programming language, however, it must allow us to hold information and provide sets of instructions to manipulate that information.

Data (information) is held inside of variables. The following keywords represent the commonly used built-in data types for the general categories of primitive information.

Instructions are always placed inside of methods. In fact, a method can be defined as a named set of instructions. Methods can never exist all on their own; they have to be placed inside of some kind of context (or scope), and they are typically placed inside of classes. Classes, themselves, are one of the main means by which we can declare complex data types (which, in turn, can be used to declare objects designed to hold and process sets of data).

Where are variables placed in our program? Variables can appear inside of classes (where they are sometimes called member variables) and inside of methods (where they are called local variables). As we will learn later, the location of the variable defines its scope, and that scope will determine when and where the variable can be used.

If you are beginning to imagine a lego-like structure to the C# programming language, then you are on the right track! We can code classes that hold variables and methods. The classes themselves are new data types which can be used for for creating complex variables (objects). This characteristic of providing keywords for primitive data types along with a means to combine them into more complex data types is called type extensibility. You can think of it in this way: primitive data types are like chemical elements in the periodic table, while complex data types (which we design ourselves) are like molecules made by combining elements. While this analogy has its limits in describing the nature of C#, it does provide a good starting point in understanding how the language is designed.

The Main Method

Speaking of starting points, it’s important to note that every computer program needs a place to start. When we run a computer program, we are telling the operating system (OS) to start running the instructions in the program. That’s why every program needs a starting place - a place (method) where the computer can begin executing the program’s instructions. For C# (like many other languages), that entry point is traditionally called the Main() method.

Let’s look at an example. The following code is a complete program that performs a simple task - displaying the text “Hello World” in a console window.

1 public class MyFirstProgram
2 {
3     public static void Main(string[] args)
4     {
5         System.Console.WriteLine("Hello World");
6     }
7 }

The name of the class is MyFirstProgram and it contains only one method - Main - which is the starting point of the program. That method contains a single instruction telling the computer to display the text “Hello World” to the user.

Notice that besides the name of the class and the Main method, there are various keywords (in blue) and punctuation (such as curly braces { }, parentheses ( ), square brackets [ ], semicolons ; and “dot operators” .). All of these pieces have to be arranged according to the specific rules of the programming language. We call these rules the grammar and the arrangement of our code using the rules the syntax. You can learn more about some of the subtle distinctions between these two terms by searching online, but for now you can think of these words as being almost the same thing.

Syntax is the study of sentences and their structure, and the constructions within sentences. Syntax tells us what goes where in a sentence. Grammar is the general term referring to the set of rules in a given language including syntax , morphology, while syntax studies sentence structures. Apr 3, 2013 - by Googlebot

Order is important

The order in which we place our instructions within a method is important. All of the instructions are processed sequentially - one after the other. Look at this simple example:

1 public class PriceCalculation
2 {
3     public static void Main(string[] args)
4     {
5         double price = 12.95, total;
6         total = price * 10;
7         System.Console.WriteLine("The total price is " + total);
8     }
9 }

In the main method are three lines of code (lines 5-7) which run sequentially. If I change the order of these instructions, then the program won’t run correctly. In fact, changing the order might even violate part of the C# grammer, creating what’s called a syntax error, and the computer won’t be able to run the program at all!

Understanding the Grammar of a programming language is fundamental to knowing how that language works. Without that knowledge, our attempts to write code will quickly be filled with frustration. The next chapter examines the grammar of C#.

Summary

We’ve covered a lot of ground so far, and all of it is fundamental to writing computer programs in C#. To recap, you should now know that

• Instructions are always placed inside methods (in fact, a method can be defined as a “set of instructions”).
• Methods always appear inside of classes or similar structures.
• C# provides keywords for primitive data types. We use these keywords to declare variables which hold values.
• C# is an extensible language - allowing one to define new complex data types with their own information (variables) and instructions (methods) for processing that information.

A Simplified C# Grammar

A language grammar is a set of small rules that can be combined to produce a syntax.

The many small rules in the C# programming language is its grammar. These rules specify the accepted way to write C# code. Individually, each rule in itself is not enough to produce complete working code. Instead, the rules are like building blocks, offering various ways to assemble or construct your code.

Take, for example, some of the grammar around variable declarations and program statements. A simplified grammar for declaring a variable in C# would look like this:

* dataType variableName*

We would have to supply both a data type and a variable name to declare a variable. Thus, if we wanted to store a whole number to represent a count, we could use the int keyword and write the following:

int count

By itself, this variable declaration is not enough to produce a complete instruction in C#. We have to combine the variable declaration grammar with the grammar for a program statement in order to make a single instruction telling the computer to create the variable. In general, a program statement must be a statement that ends with a semicolon (;). In other words, the program statement grammar requires the semicolon as “punctuation”, much in the same way that English sentences must end in a period. Thus, our completed syntax for creating a variable would be

int count;

The formal grammar for C# is actually quite large and complex. In fact, the grammars for most programming languages are so complex that they require another “language” to describe the grammar. An early and fairly standard language or means to express grammars is the Bakus-Naur Form, or BNF.

For our purposes, we will present a much more simplified grammar. The following sections express the bulk of the C# grammar used in this introduction to programming fundamentals in C#.

Common Grammar Elements

Most of the grammar rules in C# are quite short, defining the order of keywords, identifiers and symbols. In the following grammars, the use of square brackets ([]) indicate an optional part of the syntax for the grammar rule; those square brackets are not actual symbols in the final syntax of the grammar. With each of the rules is a very brief explanation. Later chapters will go into more depth and provide examples of how to use these grammars.

Program Statements and Statement blocks

Individual instructions are known as Program Statements. The instructions can be short and simple, or they can be long an complex. In either case, the program statement must end in a semicolon (;). These individual instructions run sequentially, one after the other, so the order of individual instructions is important.

Besides individual instructions, we can group individual statements into Statement Blocks. A statement block is a set of zero or more program statements that are enclosed in a set of curly braces ({ }). Statement blocks are frequently used with Flow Control Statements (such as the if and for statements).

Variable Declarations

Before a variable can be used, it must be declared. Declaring a variable tells the compiler to

• set aside room in memory to store information,
• treat that data as a specific data type, and
• refer to that information by the variable name

The grammar for declaring variables is as follows.

1 dataType variableName [= expression] [, ...]

A Variable Declaration defines a new variable where

dataType is any built-in or programmer-defined data type.

variableName is

an optional initial value may be assigned, as denoted by [= expression], where expression is any valid C# expression whose final data type matches the variable’s data type. When a variable is declared and initialized at the same time, it is called a Variable Initialization.

additional variable names (with or without initial values) can be declared using a comma-separated list. All variables are of the same data type as the first variable in the list.

Assignment Operation

1 variableName assignmentOperator expression

Assignment Operations are operations where a value is assigned or stored in a variable.

variableName is the name of the variable that will receive/store the value.

assignmentOperator is one of the following:
= Equals
+= Plus-Equals
-= Minus-Equals
*= Multiply-Equals
/= Divide-Equals
%= Modulus-Equals

expression is any valid C# expression whose final data type matches the variable’s data type.

An assignment operation is made into an assignment statement by adding a semicolon to the end of the operation. For example,
total = price * quantity;

Expressions

An Expression is any combination of literal values, variable names, operators (such as the arithmetic operators), and/or method calls (where the method returns a value). When an expression is processed by the computer, a single value is produced. This value can then be used in whatever operation the expressions occurs. For example, the value might be passed into a method as part of a method call, or it might be placed in a variable as part of an assignment statement.

Namespace Declaration and Using Statements

1 namespace Name
2 {
3     // Classes, enumerations, or other programmer-defined data types
4 }

A Namespace Declaration groups programmer-defined data types where

The Name of the namespace can be one or more dot-separated names. For example, the following are all valid names for namespaces.
System
System.Collections
MyGame
MyGame.GameRules

Namespaces are used to group classes and other programmer-defined data types into a single named group. The reason for grouping programmer-defined data types into namespaces is to prevent what are called “naming collisions”. A naming collision is where two or more classes or other programmer-defined data types are given the same name. In other words, you cannot have two classes named Circle in the same namespace. However, if you place those two classes in different namespaces, then that is acceptable because the compiler will then be able to distinguish between the two classes based on the namespace they belong to.

Whenever a class or other data type is placed in a namespace, that namespace becomes part of the fully-qualified name of the data type. For example, if a class named Circle is placed in a namespace called Geometry.Shapes, then the fully qualified name of the class is Geometry.Shapes.Circle.

Namespaces allow us to isolate our classes and other data types into groups. All of the classes/data types in a given namespace can automatically reference each other. To reference or use data types in other namespaces, we must either use their fully-qualified names or include them through the Using Statement.

1 using NamespaceName;

The using statement allows access to all the data types in referenced namespace. Using statements are typically placed at the beginning of a file. The NamespaceName is simply the complete name of the namespace that contains the classes or data types that we want to access.

Classes and Class Members

As an object-oriented language, classes play a very prominent part of the code we write in C#. It is within classes, for example, that we place variables (also called fields) and methods (which are “named sets of instructions”). One of the first things that classes give us developers is a context or scope for the code that we write. Classes are also building blocks, acting as blueprints for new and complex data types that we as programmers can create as we develop richer and more complex computer programs. Classes permeate all the code that we write in C# and are so fundamental that you can’t even write a “Hello World” program without them.

Class Definition

1 [accessModifier] class ClassName
2 {
3   // FieldDeclarations
4   // PropertyDeclarations
5   // Constructors
6   // MethodDeclarations
7 }

A Class Definition describes a new data type where

[accessModifier] is either public{format: csharp} or internal{format:csharp}. If no access modifier is provided, then the default modifier is internal{format:csharp}.

ClassName is the programmer-supplied name for the class (in TitleCase format)

FieldDeclarations, PropertyDeclarations, Constructors and MethodDeclarations are all optional and can appear in any order.
See the related grammars below to see how they are defined.

Field Declarations

1 [accessModifier] [static] dataType _FieldName [= constantExpression];

A Field Declaration identifies a static or instance member variable of the class where

[accessModifier] is either public{format: csharp}, private{format: csharp}, protected{format: csharp}, or internal{format:csharp}. If no access modifier is provided, then the default modifier is private{format:csharp}.

[static]{format:csharp} is an optional keyword. If present, the field is shared among all instances of the class. If absent (which is the common case) then the field is an instance member and one is created every time an object based on the class is created.

dataType is any built-in data type or the name of a programmer-defined data type.

_FieldName is a the name you give to the member variable. By convention, private fields are given an underscore as a prefix to the name.

constantExpression is an optional expression that generates data whose value can be determined at compile time. Being a constant expression does not mean that the field is a constant, only that the initial value stored in the field is a constant and can be known at compile time before the program runs.

Property Declarations

Properties are a kind of cross between methods and fields. On one hand, they are used in the same way that fields are. When you want to assign (or set) a value to a property, you place the property on the left side of the assignment operator. When you want to use (or get) the properties value, you simply reference the property name just as you would a field name.

Internally, however, the get and set operations are like the bodies of a method, where you can place instructions to retrieve or change the data in the class or object.

Explicitly Implemented Property

Explicitly implemented properties are properties where the programmer supplies the getter and setter implementations. The bodies of the getter and setter may reference a field (known as a backing store) that holds the actual information. In these cases, the property is working to provide a controlled access to the underlying field’s data.

In other situations, a property may merely have a getter where the body of the getter derives or calculates a value to return from some other source, such as a calculation.

 1 [accessModifier] [static] dataType PropertyName
 2 {
 3     get
 4     {
 5         // Body of getter
 6     }
 7     set
 8     {
 9         // Body of setter
10     }
11 }

A Property Declaration identifies a static or instance member of the class where

[accessModifier] is either public{format: csharp}, private{format: csharp}, protected{format: csharp}, or internal{format:csharp}. If no access modifier is provided, then the default modifier is private{format:csharp}.

[static]{format:csharp} is an optional keyword. If present, the Property is shared among all instances of the class. If absent (which is the common case) then the Property is an instance member.

dataType is any built-in data type or the name of a programmer-defined data type.

PropertyName is a the name you give to the member property.

Body of getter is a set of instructions that must ultimately return a value of the same data type as the property.

Body of the setter is a set of instructions that can process incoming data that is in the value{format:csharp} keyword. A typical implementation will store that data into the property’s backing store.

Autoimplemented Property

Autoimplemented properties are properties where the compiler takes care of the getter and setter implementations and also supplies a hidden field as the backing store for the property. The default get implementation is to retrieve the value from the backing store while the default set implementation is to place a value into the backing store.

1 [accessModifier] [static] dataType PropertyName { get; set; }

A Property Declaration identifies a static or instance member of the class where

[accessModifier] is either public{format: csharp}, private{format: csharp}, protected{format: csharp}, or internal{format:csharp}. If no access modifier is provided, then the default modifier is private{format:csharp}.

[static]{format:csharp} is an optional keyword. If present, the Property is shared among all instances of the class. If absent (which is the common case) then the Property is an instance member.

dataType is any built-in data type or the name of a programmer-defined data type.

PropertyName is a the name you give to the member property.

Method Declarations

1 [accessModifier] [static] returnType MethodName(ParameterList)
2 {
3     // body of method
4 }

A Method Declaration defines a named set of instructions.

[accessModifier] is either public{format: csharp}, private{format: csharp}, protected{format: csharp}, or internal{format:csharp}. If no access modifier is provided, then the default modifier is private{format:csharp}.

[static]{format:csharp} is an optional keyword. If present, the method is shared among all instances of the class. If absent (which is the common case) then the method is an instance member.

returnType is any built-in data type or the name of a programmer-defined data type. The return type signifies the kind of information that the method will return. If the method does not return any information, then the keyword void is used as the return type.

MethodName is a the name you give to the method.

ParameterList is a comma-separated list of individual variable declarations.

Constructors

1 [accessModifier] ClassName(ParameterList)
2 {
3     // body of constructor
4 }

A Constructor is a set of instructions used when instantiating (creating) an object.

[accessModifier] is either public{format: csharp}, private{format: csharp}, protected{format: csharp}, or internal{format:csharp}. If no access modifier is provided, then the default modifier is private{format:csharp}.

ClassName - All constructors use the name of the class to which they belong as the name of the constructor.

ParameterList is a comma-separated list of individual variable declarations.

Classes never return any information - they are simply blocks of instructions used to set up the initial state of the object.

Flow-Control Statements

• If-Else
• Case
• For and Foreach
• While and Do-While

Interlude 1 - Console Input/Output

TODO:

• Output
• Input
• Converting user input

The ABCs of Classes and Objects

A Tutorial and Walkthrough of coding Classes and Objects

The purpose of this tutorial is to give the student an opportunity to write code and to explore the fundamentals of Classes and Objects. Specifically, this tutorial demonstrates fields, properties, constructors, and methods in class declarations along with object instantiation and the use of the member access operator.

About Classes and Objects

A computer program is a set of instructions for manipulating information.

Information is central to the whole purpose of computer programs, and is the “thing” that has value in the eyes of the end-user. Information is often complex, being made up of many smaller pieces of related information. For example, the information could be the details of a bank account, the marks earned by a student, or information about a company or an employee. A key aspect of all of these is that the details of the information (First and Last name, for example) are bundled together and treated as a single unit - a composition of related information. In programming, those bundled sets of detailed information are known as objects.

Objects embody more than just information, however. A person can do things with objects. For example, if you imagine a Bank Account as an object, it can be made up of a bunch of information, such as Account Number, Balance and Overdraft Limit. Now imagine the things you can do with a bank account: you can Deposit or Withdraw money. These actions are tightly related to bank accounts, largely because they directly affect the information in the bank account. These actions are carried out as a set of instructions - known as methods - which are carried out in a prescribed way through a set of one or more program statements.

Two objects can have the same set of characteristics, but different information. For example, consider two Bank Account objects where one account has a balance of $4,500.00 and another has a balance of $125.00. The actual information is different, but the characteristics (what Bank Accounts “look like”) remain the same. The things you can do with the two bank accounts also remain the same: you can Deposit and Withdraw money. In programs, the characteristics of an object are defined in something called a Class. A class defines

• What an object “looks like” (information)
• How an object “behaves” (instructions to manipulate information)

For a computer program to be able to work with objects, it must first know the class definition of that object. Coding a class definition is like telling the computer about a new data type that you are defining. The name of the class is the name of the new data type. Once the data type is defined, then it can be used to create objects. A class definition (or “class” for short) acts as a blueprint for creating objects; from the blueprint, the computer is told what the object “looks like” and how it “behaves”. Every object is said to be an “instance” of a class, in the same way that a physical car would be an instance of the car’s blueprint. The term instantiation basically means “to instantiate”, and it refers to the act of creating objects in code. An object is said to be “based on” a class when that class is the data type from which an object has been instantiated (just as a physical car would be “based on” the car’s blueprint).

So, objects and classes are closely related, but not exactly the same. The relationship between objects and classes is pretty much the same as the relationship between ordinary values and data types.

Coding the Class Definition

A class definition can contain four parts: Fields, Properties, Constructors, and Methods. Fields and properties work together to describe what an object based on the class “looks like” (the object’s information). Constructors and Methods describe how the object “behaves” (what instructions an object performs to manipulate information).

• Fields
  
  • Fields are variables that are shared by/accessible to all the other members of a class (properties, constructors, and methods).
  • Fields are almost always declared as private (meaning that they are not directly accessible from outside the class).
  • Although not commonly done, a field can be assigned an initial default value when it is declared.
• Properties
  
  • Properties are used like ordinary fields or variables, but work internally as methods.
  • Properties can have a Get method and/or a Set method.
    
    • The Get method is used when attempting to retrieve a value from the property.
    • The Set method is used when attempting to store a value in the property.
  • Properties often (but not always) have a corresponding field that is used to hold or store the property’s value in the “background”; the field associated with a property is often referred to as the “backing store”.
  • Properties that do not have a corresponding backing store will only have a Get method that calculates a value based on other values; there is no Set method because there is no single field in which to store a value for the property.
  • Properties are usually declared as public (meaning that they can be accessed directly from outside the class).
• Constructors
  
  • Constructors are called automatically whenever an object is created. Objects are created by the new keyword, whose general syntax is as follows:
    new ClassName(ArgList)
  • ArgList (or Argument List) is a comma-separated list of values that are sent to the constructor. The decision of which constructor can be called depends on the arguments (values) sent in when the new keyword is used; the compiler looks for a constructor with a parameter list that matches the argument list.
  • Constructors have one purpose: to make sure that the fields in the object have meaningful values. This usually means that a constructor will need some parameters to get those values from the code that creates the object.
  • Usually, constructors are made public.
  • A class can define more than one constructor. If no constructor is defined for a class, then a “default constructor” is used, which simply sets all the fields to their default values.
• Methods
  
  • A method is a set of instructions that are typically focused on manipulating or working with the fields and properties of an object.
  • Methods are identified by a name (called the Method Name) and a parameter list; together the method name and parameter list make up what is called the Method Signature.
  • If a method has a return type of void, then it is known as a Subroutine; subroutines do not return any information to the code that called it.
  • If a method has any return type except void, then it is called a Function; functions can only return one item, and must do so using a return statement.

A Tutorial - OOP First in Three Parts

Practice makes better!

This three-part tutorial establishes the foundations of the key grammars around classes and objects. The first two work on a BankAccount and Bank class while the last part demonstrates the same concepts around the idea of rental cars and rental companies.

Part 1

This tutorial will walk you through the steps to create a class and an object based on the following design. This first program will demonstrate a BankAccount class and the transfer of money from one bank account to another.

1. Open up Visual Studio and create a new C# Console Application project. In that project, create a folder called “Tutorial”.

2. Right-click on the Tutorial folder, and create a class called “BankAccount”. Edit the BankAccount class so that it has the following code.

 1 namespace ObjectABCs.Tutorial
 2 {
 3     public class BankAccount
 4     {
 5         #region Fields (always private)
 6         private int _AccountNumber;
 7         private double _Balance;
 8         #endregion
 9 
10         #region Properties
11         public int AccountNumber
12         {
13             get { return _AccountNumber; }
14             private set { _AccountNumber = value; }
15         }
16 
17         public double Balance
18         {
19             get { return _Balance; }
20             set { _Balance = value; }
21         }
22         #endregion
23 
24         public BankAccount(int accountNumber, double balance)
25         {
26             AccountNumber = accountNumber;
27             Balance = balance;
28         }
29 
30         public void Deposit(double amount)
31         {
32             Balance = Balance + amount;
33         }
34 
35         public void Withdraw(double amount)
36         {
37             Balance = Balance - amount;
38         }
39     }
40 }

3. Create another class inside the Tutorial folder, and name it “Bank”. Edit the class so that it has the following code.

 1 namespace ObjectABCs.Tutorial
 2 {
 3     public class Bank
 4     {
 5         public static void Transfer(BankAccount fromAccount, BankAccount toAccou\
 6 nt, double amount)
 7         {
 8             fromAccount.Withdraw(amount);
 9             toAccount.Deposit(amount);
10         }
11     }
12 }

4. Create a driver class named “DemoDriver” and place it in the Tutorial folder. Edit the driver so that it has the following code.

 1 using System;
 2 
 3 namespace ObjectABCs.Tutorial
 4 {
 5     public class DemoDriver
 6     {
 7         public static void Start()
 8         {
 9             BankAccount myAccount = new BankAccount(123546, 250.00);
10             BankAccount storeAccount = new BankAccount(987654, 5473.28);
11 
12             DisplayAccount(myAccount, "My Account");
13             DisplayAccount(storeAccount, "Store Account");
14 
15             Console.WriteLine("I am purchasing an item for $12.95");
16             Bank.Transfer(myAccount, storeAccount, 12.95);
17             DisplayAccount(myAccount, "My Account");
18             DisplayAccount(storeAccount, "Store Account");
19             Console.WriteLine("Purchase complete");
20         } // end of Start() method
21 
22         private static void DisplayAccount(BankAccount account, string message)
23         {
24             Console.WriteLine(message);
25             Console.WriteLine("-- Account Info --");
26             Console.WriteLine("Acct. #: " + account.AccountNumber);
27             Console.WriteLine("Balance: $ " + account.Balance);
28             Console.WriteLine("-- ------------ --");
29             Console.WriteLine();
30         } // end of DisplayAccount() method
31     }
32 }

5. Open the Program.cs file and edit the Main() method to call the demo driver class.

 1 using ObjectABCs.Tutorial;
 2 
 3 namespace ObjectABCs
 4 {
 5     class Program
 6     {
 7         static void Main(string[] args)
 8         {
 9             DemoDriver.Start();
10         }
11     }
12 }

When you run the program, you should see the result as shown in the following screen-shot.

Part 2

A big aspect of developing computer programs is the work of modifying existing code that you or others have written. In this part of the tutorial, we’ll revisit the BankAccount and DemoDriver classes to add and take advantage of a new method on the BankAccount class: ToString().

1. Open the BankAccount class and modify it by adding the following ToString() method in the body of the class.

1     public override string ToString()
2     {
3         string accountInfo = "Balance (for account # "
4                             + AccountNumber.ToString()
5                             + "): "
6                             + string.Format("{0:C}", Balance);
7 
8         return accountInfo;
9     }

2. Open the DemoDriver class and modify the DisplayAccount() method to look like the following code.

1     private static void DisplayAccount(BankAccount account, string message)
2     {
3         Console.WriteLine(message);
4         Console.WriteLine("-- Account Info --");
5         Console.WriteLine(account);
6         Console.WriteLine("-- ------------ --");
7         Console.WriteLine();
8     } // end of DisplayAccount() method

Part 3

Many times, properties act to provide transparent access to fields. (All of the examples so far have used Properties in this simplest way.) In C# version 3.0, a new syntax was introduced called auto-implemented properties which reduces the amount of code required to get the same effect as these transparent properties.

Auto-implemented properties do not have a field as a “backing store” and do not have bodies for the get and set methods. For example, the following code demonstrates an auto-implemented property.

1   public string ClientName { get; private set; }

This property has the exact same effect as the following, longer approach of using a property with a field in the background.

1   private string _ClientName;
2   public string ClientName
3   {
4       get { return _ClientName; }
5       private set { _ClientName = value; }
6   }

In this part of the tutorial, you will create classes that use auto-implemented properties, as well as regular properties.

1. Open up Visual Studio and create a new C# Console Application project. In that project, create a folder called “Tutorial”.

2. Create a new class in the Tutorial folder called RentalCar. Edit the class so that it matches the following code.

 1 using System; // needed for DateTime
 2 namespace ObjectABCs.Tutorial
 3 {
 4     public class RentalCar
 5     {
 6         public string VIN { get; private set; }
 7         public string ClientName { get; private set; }
 8         public DateTime DateTaken { get; private set; }
 9         public int DaysRental { get; set; }
10         public DateTime DateDue
11         {
12             get
13             {
14                 return DateTaken.AddDays(DaysRental);
15             }
16         }
17 
18         public RentalCar(string clientName, DateTime dateTaken, int days)
19         {
20             ClientName = clientName;
21             DateTaken = dateTaken;
22             DaysRental = days;
23             // figure out the remaining values
24             VIN = GetPretendVIN();
25         }
26 
27         private static string _PretendVIN = "1ABC234DE567";
28         private static int _Counter = 10;
29         private static string GetPretendVIN()
30         {
31             string tempVIN = _PretendVIN + _Counter.ToString();
32             _Counter = _Counter + 1;
33             return tempVIN;
34         }
35 
36         public override string ToString()
37         {
38             return VIN;
39         }
40     }
41 }

3. Create another class named RentalCompany. Edit the code to match the following.

 1 using System; // needed for DateTime
 2 namespace ObjectABCs.Tutorial
 3 {
 4     public class RentalCompany
 5     {
 6         public int CarCount { get; private set; }
 7 
 8         public RentalCompany(int carCount)
 9         {
10             CarCount = carCount;
11         }
12 
13         public RentalCar BookRental(string name, int days)
14         {
15             RentalCar car;
16             car = new RentalCar(name, DateTime.Today, days);
17             CarCount = CarCount - 1;
18             return car;
19         }
20 
21         public override string ToString()
22         {
23             return CarCount.ToString() + " cars available to rent.";
24         }
25     }
26 }

4. Create a final class named DemoRentals. This will be the driver to use RentalCompany and RentalCar objects. Edit DemoRentals to match the following.

 1 using System;
 2 
 3 namespace ObjectABCs.Tutorial
 4 {
 5     public class DemoRentals
 6     {
 7         public static void Start()
 8         {
 9             string name;
10             int daysToRent;
11 
12             name = PromptName();
13             daysToRent = PromptRentalTime();
14 
15             RentalCar rental;
16             RentalCompany budget = new RentalCompany(5);
17 
18             rental = budget.BookRental(name, daysToRent);
19 
20             DisplayRentalInfo(rental);
21         }
22 
23         private static string PromptName()
24         {
25             Console.Write("Enter name of person renting vehicle: ");
26             string name = Console.ReadLine();
27             return name;
28         }
29 
30         private static int PromptRentalTime()
31         {
32             Console.Write("Enter number of days to rent: ");
33             string daysAsText = Console.ReadLine();
34             int days = Convert.ToInt32(daysAsText);
35             return days;
36         }
37 
38         private static void DisplayRentalInfo(RentalCar rental)
39         {
40             Console.WriteLine("Rental Info");
41             Console.WriteLine("-----------");
42             Console.WriteLine(rental);
43             Console.WriteLine("Customer: " + rental.ClientName);
44             Console.WriteLine("Due Date: " + rental.DateDue.ToShortDateString());
45             Console.WriteLine();
46         }
47     }
48 }

5. Lastly, modify the Main method in Program.cs to call the DemoRentals.Start() method.

 1 using ObjectABCs.Tutorial;
 2 
 3 namespace ObjectABCs
 4 {
 5     class Program
 6     {
 7         static void Main(string[] args)
 8         {
 9             DemoRentals.Start();
10         }
11     }
12 }

6. Run the program. You should get results similar to the following screenshot.

OOP As A Foundation

Topic A - Starting Classes

Overview

This topic introduces some of the basic syntax and grammar surrounding Object-Oriented Programming in C#. The following C# keywords are introduced.

• public
• class
• static
• string
• void
• return
• namespace

This topic will also introduce the following grammars, syntax and language constructs:

• Simple class declaration syntax (no members)
• Simple class declaration syntax (with static methods)
• Method overloading
• Method declaration syntax (class methods, with the static keyword)
• Parameter declaration (variable declaration) syntax
• Class (static) method call syntax (with and without arguments)
• main function (entry point of program)
• Console output
• Simple string concatenation
• C# as a case-sensitive language
• Single-line, multi-line and XML comments

LOGs

At the end of this topic, you should be able to …

OOP Basics

• Define the term “class” as used in OOP
• Explain the purpose of classes in computer programs
• Describe the primary keywords used in declaring a class
• Define the term “method” and give an example
• Create simple classes with methods only
• Explain what is meant by “overloading”
• Describe the syntax of a method declaration (aka, method implementation)
• Explain how classes with identical names can be distinguished from each other

General Programming Concepts and Terms

• Define the term “keyword” as it applies to programming languages
• Define the term “identifier” as it applies to programming languages
• Define the term “program statement” and identify how the computer recognizes a program statement
• Define the term “syntax” as it applies to programming languages
• Identify the entry point for every computer program
• Perform simple output to the console using System.Console
• Identify the basic structure of a simple C# program
• Explain what is meant by a “driver”
• Explain what is meant by a “case-sensitive” programming language
• Explain what is meant by a “strongly-typed” programming language
• Explain what “string concatenation” is and how it works
• Define and distinguish the terms “argument” and “parameter”
• Use single-line, multi-line and XML comments as a means of documenting code
• List the four pieces of information to include in comments at the top of every source file

Intro to IDEs

• Define the term “IDE” as it relates to software development tools
• Define the terms “project” and “solution”
• Identify the various parts of the IDE (Integrated Development Environment) used in this course
• Create a new project in the IDE for this course
• Create new source files in the IDE for this course
• Add existing files to a project

Code Samples

The following examples are used to illustrate this topic.

1. Nothingness - This class represents the absolute minimum code required to code a class. Even though it’s not a very “useful” class, it does provide and introduction to the ideas of classes, keywords and identifiers.
2. HelloWorld - This adaptation of the classic “Hello World” program illustrates static methods. This example includes and introduces the concept of a “driver”.
3. Comments - This class is not really “functional”, but is intended to illustrate the basic types of comments allowed in the programming language.

Nothingness

This class represents the absolute minimum code required to code a class. Even though it’s not a very “useful” class, it does provide and introduction to the ideas of classes, keywords and identifiers.

1 namespace Topic.A.Examples
2 {
3     public class Nothingness
4     {
5 
6     }
7 }

HelloWorld

This adaptation of the classic “Hello World” program illustrates static methods. This example includes and introduces the concept of a “driver”.

 1 namespace Topic.A.Examples
 2 {
 3     public class Salutation // Define a class called "Salutation"
 4     {
 5         public static string Greeting()
 6         {
 7             return "Hello World!";
 8         } // end of Greeting()
 9 
10         public static string Greeting(string name)
11         {
12             return "Hello " + name;
13         } // end of Greeting(string)
14 
15         public static string Farewell()
16         {
17             return "So long!";
18         } // end of Farewell()
19     } // end of Salutation class
20 }

 1 namespace Topic.A.Examples
 2 {
 3     public class HelloWorld_Driver
 4     {
 5         public static void Main(string[] args)
 6         {
 7             System.Console.WriteLine(Salutation.Greeting());
 8             System.Console.WriteLine(Salutation.Greeting("Bob"));
 9             System.Console.WriteLine(); // print a blank line
10             System.Console.WriteLine(Salutation.Farewell());
11         }
12     }
13 }

Comments

This class is not really “functional”, but is intended to illustrate the basic types of comments allowed in the programming language.

 1 /*
 2  * File:    Comments.cs
 3  * Author:  Dan Gilleland
 4  * Date:    2010
 5  * Purpose: To illustrate multi-line, single-line, and XML comments.
 6  *          This is a multi-line comment.
 7  */
 8 namespace Topic.A.Examples
 9 {
10     /// <summary>
11     /// Comments illustrates multi-line, single-line, and XML comments.
12     /// </summary>
13     /// <remarks>
14     /// This class is a stand-alone class used to illustrate comments.
15     /// This particular XML comment is "attached" to the class as
16     /// a whole, while other XML comments are for fields or methods
17     /// in the class (a few methods and fields have been included for
18     /// illustration purposes).
19     /// [Author: Dan Gilleland]
20     /// </remarks>
21     public class Comments
22     {
23         /// <summary>
24         /// This is a method of <see cref="Comments"/>
25         /// </summary>
26         /// <returns>This method returns a string.</returns>
27         public static string SimpleMethod()
28         {
29             return "Hello World!"; // "Hello World!" is a literal string value
30         } // end of SimpleMethod()
31 
32         /// <summary>
33         /// This is a one-sentence description of the method.
34         /// </summary>
35         /// <param name="name">This is where I describe the purpose of this para\
36 meter</param>
37         /// <returns>Here I describe what information is returned from this meth\
38 od.</returns>
39         /// <remarks>
40         /// This method has a single parameter.
41         /// </remarks>
42         public static int MethodWithParameter(string name)
43         {
44             return name.Length; // This is a single-line comment (must be end of\
45  physical line)
46         } // end of MethodWithParameter(string)
47     } // end of Comments class
48 }

Practice Exercises

• OuterSpace – This class is the simplest possible class (and, coincidentally, one of the most useless).
• AnsweringMachine – The AnsweringMachine class provides a method to give an answer to an incoming phone call.
  Driver – This class is the driver for the AnsweringMachine class.
• Salutation – This is the Salutation class that was previously demonstrated.
  HelloWorld_Driver – This class is the driver for the Salutation class.

OuterSpace

This class is the simplest possible class (and, coincidentally, one of the most useless).

Problem Statement:

Create a class called OuterSpace. This class has no members at all (it is empty, like outer space). Add a multi-line comment at the beginning that should include your full name as the author of the class. Also make an XML comment for the class as a whole.

AnsweringMachine

The AnsweringMachine class provides a method to give an answer to an incoming phone call.

Problem Statement:

Create the AnsweringMachine class so that it can provide a default answer for an incoming phone call as well as a customizable answer. The methods should be named answer and they should return a String. There should be two methods in total, and both of them should be declared as static. The actual content of the default message can be whatever you choose, while the customizable method will receive a single String argument that has the name of the person receiving the message. Also create a driver that demonstrates the AnsweringMachine in a Console environment.

Use the following details to guide your solution.

Method Detail

• public static string Answer()
  Provides a standard default message for the answering machine.

  Returns:
  A String that instructs the caller to leave a message.

• public static string Answer(string name)
  Provides a customizable message for the answering machine.

  To use this method, supply a person’s name, and this name will be incorporated into the message that is returned. For example,
  System.Console.WriteLine(AnsweringMachine.Answer("Bob");

  Parameters:
  name - A String that is the name of the person being called.
  Returns:
  A String that instructs the caller to leave a message for the person with the supplied name.

Salutation and HelloWorld_Driver

In each of the single-line comments above a line of code, enter a phrase or sentence in English that describes what is done in that line of code.

Salutation

 1 // Instructions: Enter comments in each blank to describe the following code
 2 // _____________________________________________________
 3 namespace Topic.A.Exercises
 4 {
 5 
 6     // _____________________________________________________________________
 7     public class Salutation
 8     {
 9         // _________________________________________________________________
10         public static string Greeting()
11         {
12             // _____________________________________________________________
13             return "Hello World!";
14         } // end of Greeting()
15 
16         // _________________________________________________________________
17         public static string Greeting(string name)
18         {
19             // _____________________________________________________________
20             return "Hello " + name;
21         } // end of Greeting(string)
22 
23         // _________________________________________________________________
24         public static string Farewell()
25         {
26             // _____________________________________________________________
27             return "So long!";
28         } // end of Farewell()
29     } // end of Salutation class
30 }

HelloWorld_Driver

 1 // Instructions: Enter comments in each blank to describe the following code
 2 // _____________________________________________________
 3 namespace Topic.A.Exercises
 4 {
 5     // _____________________________________________________
 6     public class HelloWorld_Driver
 7     {
 8         // __________________________________________________________________
 9         public static void main(string[] args)
10         {
11             // ______________________________________________________________
12             System.Console.WriteLine(Salutation.Greeting());
13             // ______________________________________________________________
14             System.Console.WriteLine(Salutation.Greeting("Bob"));
15             // ______________________________________________________________
16             System.Console.WriteLine(); // print a blank line
17             // ______________________________________________________________
18             System.Console.WriteLine(Salutation.Farewell());
19         }
20     }
21 }

Topic B – Starting Classes

Overview

This topic introduces some of the basic syntax and grammar surrounding Object-Oriented Programming in Java. The following keywords are introduced. (Note that additional keywords from previous topics may also be present.)

• new
• char
• int
• double

This topic will also introduce the following grammars, syntax and language constructs. (Note that additional concepts from previous topics may also be present.)

• Method declaration syntax (instance methods)
• Object instantiation
• Instance method call syntax (with and without arguments)
• Class Field declaration syntax (member variables)
• Assignment statement syntax
• Accessing public fields in objects (storing & retrieving values)

Note that this package introduces the distinction between static and non-static methods. Static methods, also known as “class methods”, are identified by the keyword static and must be qualified by the class name; for example, in the following method call Salutation is the name of the class and Greeting is a static method of that class.
Salutation.Greeting()

Non-static methods, also known as “instance methods”, are identified by the absence of the static keyword and must be called by using an instance of the class (that is, an object). An example of calling an instance method would be
app.Greeting()
where the app is an instance of the Salutation class.

LOGs

At the end of this topic, you should be able to …

OOP Basics

• Define the term “object” as used in OOP
• Describe the syntax of static and non-static method declarations
• Compare and contrast the syntax for method declarations (implementations) vs. method calls (for both static and non-static methods)
• Define the term “field” as used in OOP and give an example
• Compare and contrast instance and class members, for both methods and fields
• Identify the “member access operator” and explain it’s purpose
• Create (instantiate) objects
• Distinguish between classes and objects in OOP
• Explain what is meant by the phrase “type extensibility” and how classes represent “complex” data types in OOP

General Programming Concepts and Terms

• List the three categories of simple information
• Define the term “intrinsic data type”
• Explain what an assignment statement is and how it works
• Compare and contrast the three categories of simple information with the complex types of information which classes represent
• Explain the advantages of using classes and objects instead of only using intrinsic data types

Code Samples

The following examples are used to illustrate this topic.

1. Salutation - This adaptation of the classic “Hello World” program illustrates instance methods. This example includes and introduces the concept of a “driver” and the idea of creating (instantiating) an object based on a class.
2. Person - This simple class illustrates and introduces the idea of fields (member variables) of a class. This example includes and introduces the idea of a driver. The driver also illustrates how a single class can be used to instantiate multiple, distinct objects.
3. Account - This simple class also illustrates fields. This example includes a driver.
4. Comments - This class continues the illustration of the kinds of comments allowed in the programming language. This class builds on the previous example by showing comments for fields as well as methods.
5. Student - This class introduces a slightly more complex class by offering more fields. This example includes two drivers. By using two drivers, this illustrates that separate “programs” can share/use the same class definition.
6. The first driver is a simple “test driver” to ensure that the class is “working”. This introduces the student to the idea that it is necessary to “test” or prove that the code we are creating is valid.
7. The second driver illustrates how the a single class can act as the basis for creating many distinct objects.
8. Employee + Company - These are other classes similar to the Person and Student classes. These classes, however, “share” a driver, illustrating the fact that any given “program” typically uses more than one class. In addition, this driver introduces the ToString() and Parse() methods of the DateTime class.

Salutation & Driver

This adaptation of the classic “Hello World” program illustrates instance methods. This example includes and introduces the concept of a “driver” and the idea of creating (instantiating) an object based on a class.

 1 /*
 2  * Purpose: To illustrate 
 3  *          - Keywords: public, class, return
 4  *          - Grammar: method declaration, parameter declaration, single line co\
 5 mments
 6  *          - Other:
 7  *              - string data type
 8  *              - method overloading
 9  *              - Instance members
10  */
11 namespace Topic.B.Examples
12 {
13     public class Salutation
14     {
15         public string Greeting()
16         {
17             return "Hello World!";
18         }
19 
20         public string Greeting(string name)
21         {
22             return "Hello " + name;
23         }
24     }
25 }

 1 /*
 2  * Purpose: To illustrate 
 3  *          - Keywords: public, class, static, void, new
 4  *          - Grammar: variable (object) declaration, object instantiation, meth\
 5 od declaration, method call, multi-line comments
 6  *          - Other:
 7  *              - main - the entry level of every program
 8  *              - console output (println)
 9  *              - Instance vs. Class methods
10  *              - instance method call
11  *              - instance method call with argument
12  *              - (optional) array declaration - string[]
13  */
14 namespace Topic.B.Examples
15 {
16 
17     public class HelloWorld_Driver
18     {
19         public static void Main(string[] args)
20         {
21             Salutation app = new Salutation();
22 
23             System.Console.WriteLine(app.Greeting());
24             System.Console.WriteLine(app.Greeting("Bob"));
25         }
26     }
27 }

Person

This simple class illustrates and introduces the idea of fields (member variables) of a class. This example includes and introduces the idea of a driver. The driver also illustrates how a single class can be used to instantiate multiple, distinct objects.

• Data Attributes of the Person class:
• FirstName : String
• LastName : String
• Age : Integer

 1 namespace Topic.B.Examples
 2 {
 3     public class Person
 4     {
 5         /// <summary>This is the first name of the person</summary>
 6         public string FirstName;
 7         /// <summary>This is the last name of the person</summary>
 8         public string LastName;
 9         /// <summary>This is the person's age</summary>
10         public int Age;
11     }
12 }

 1 namespace Topic.B.Examples
 2 {
 3     public class DemoPerson
 4     {
 5         public static void Main(string[] args)
 6         {
 7             Person someGuy;
 8             someGuy = new Person();
 9             someGuy.FirstName = "Harry";
10             someGuy.LastName = "Burns";
11             someGuy.Age = 25;
12 
13             Person someGirl;
14             someGirl = new Person();
15             someGirl.FirstName = "Sally";
16             someGirl.LastName = "Albright";
17             someGirl.Age = 25;
18 
19             string fullName;
20 
21             fullName = someGuy.FirstName + " " + someGuy.LastName;
22             System.Console.WriteLine("Hi. My name is " + fullName);
23 
24             fullName = someGirl.FirstName + " " + someGirl.LastName;
25             System.Console.WriteLine("Hi" + someGuy.FirstName +
26                                ". My name is " + fullName);
27         }
28     }
29 }

Account

This simple class also illustrates fields. This example includes a driver.
* Data Attributes of the Account class:
  * AccountNumber : Integer
  * Balance : Real
  * OverdraftLimit : Double

1 namespace Topic.B.Examples
2 {
3     public class Account
4     {
5         public int AccountNumber;
6         public double Balance;
7         public double OverdraftLimit;
8     }
9 }

 1 namespace Topic.B.Examples
 2 {
 3     public class DemoAccountDriver
 4     {
 5         public static void Main(string[] args)
 6         {
 7             Account myAccount; // declares a reference variable to an Account ob\
 8 ject
 9             myAccount = new Account(); // creates the Account object.
10 
11             myAccount.Balance = 500000.00;
12             myAccount.OverdraftLimit = 1000000.00;
13             myAccount.AccountNumber = 123456;
14         }
15     }
16 }

Comments

This class continues the illustration of the kinds of comments allowed in the programming language. This class builds on the previous example by showing comments for fields as well as methods.

 1 /*
 2  * File:    Comments.cs
 3  * Author:  Dan Gilleland
 4  * Date:    2010
 5  * Purpose: To illustrate multi-line, single-line, and XML comments.
 6  *          This is a multi-line comment.
 7  */
 8 namespace Topic.B.Examples
 9 {
10     /// <summary>
11     /// Comments illustrates multi-line, single-line, and XML comments.
12     /// </summary>
13     /// <remarks>
14     /// This class is a stand-alone class used to illustrate comments.
15     /// This particular XML comment is "attached" to the class as
16     /// a whole, while other XML comments are for fields or methods
17     /// in the class (a few methods and fields have been included for
18     /// illustration purposes).
19     /// </remarks>
20     public class Comments
21     {
22         /// <summary>
23         /// Here is a simple integer variable that is pre-set to the value 5.
24         /// </summary>
25         /// <remarks>
26         /// This is an instance member (non-static) of the class.
27         /// </remarks>
28         private int _five = 5;
29 
30         /// <summary>
31         /// Here is a whole number that is pre-set to the value 0.
32         /// </summary>
33         /// <remarks>
34         /// This field is a static member of the class.
35         /// </remarks>
36         private static int _instanceCounter = 0;
37 
38         /// <summary>
39         /// Here is a real number that is pre-set to the value 3.14159.
40         /// </summary>
41         /// <remarks>
42         /// This field is a constant member of the class.
43         /// </remarks>
44         private const  double _PI = 3.14159;
45 
46         /* ****************** Methods ******************** */
47         /// <summary>
48         /// This is a method of <see cref="Comments"/>
49         /// </summary>
50         /// <returns>This method returns a string.</returns>
51         public static string SimpleMethod()
52         {
53             return "Hello World!";
54         } // end of SimpleMethod()
55 
56         /// <summary>
57         /// This is a one-sentence description of the method.
58         /// </summary>
59         /// <param name="name">This is where I describe the purpose of this para\
60 meter</param>
61         /// <returns>Here I describe what information is returned from this meth\
62 od.</returns>
63         /// <remarks>
64         /// This method has a single parameter.
65         /// </remarks>
66         public static int MethodWithParameter(string name)
67         {
68             return name.Length;
69         } // end of MethodWithParameter(string)
70     } // end of Comments class
71 }

Student

The Student class introduces a slightly more complex example by offering more fields.

• Data Attributes of the Student class:
• Name : String
• Gender : Character
• StudentId : Integer
• Program : String
• GradePointAverage : Double
• FullTime : Boolean

This example also includes two drivers. By using two drivers, this illustrates that separate “programs” can share/use the same class definition.
The first driver is a simple “test driver” to ensure that the class is “working”. This introduces the student to the idea that it is necessary to “test” or prove that the code we are creating is valid.

The second driver illustrates how the a single class can act as the basis for creating many distinct objects.

 1 /**
 2  * Purpose: To illustrate 
 3  *          Highlights:
 4  *          - Keywords: char, int, double
 5  *          - Grammar: variable declaration (fields)
 6  *          - Other:
 7  *              - Instance members
 8  */
 9 namespace Topic.B.Examples
10 {
11     public class Student
12     {
13         public string Name;                 // The full name of the student
14         public char Gender;                 // Gender can be 'M' or 'F'
15         public int StudentId;               // The school-provided student ID
16         public string Program;              // The course program; e.g.: "CST"
17         public double GradePointAverage;    // GPA is from 1.0 to 9.0
18         public bool FullTime;               // If the student is enrolled full-t\
19 ime
20     }
21 }

 1 /**
 2  * Purpose: To illustrate 
 3  *          Highlights:
 4  *          - Keywords: public, class, static, void, new
 5  *          - Grammar: 
 6  */
 7 namespace Topic.B.Examples
 8 {
 9     public class DemoStudentDriver
10     {
11         public static void Main(string[] args)
12         {
13             Student bob, mary, joe, susan, frank;
14             bob = new Student();
15             mary = new Student();
16             joe = new Student();
17             susan = new Student();
18             frank = new Student();
19 
20             bob.Name = "Bob McNalley";
21             bob.Gender = 'M';
22             bob.Program = "CST";
23             bob.StudentId = 200765789;
24             bob.GradePointAverage = 6.76;
25 
26             mary.Name = "Mary McTavishski";
27             mary.Gender = 'F';
28             mary.Program = "CST";
29             mary.StudentId = 200765790;
30             mary.GradePointAverage = 5.76;
31 
32             joe.Name = "Joe Jetson";
33             joe.Gender = 'M';
34             joe.Program = "CST";
35             joe.StudentId = 200765792;
36             joe.GradePointAverage = 4.66;
37 
38             susan.Name = "Susan Orlando";
39             susan.Gender = 'F';
40             susan.Program = "CST";
41             susan.StudentId = 200765795;
42             susan.GradePointAverage = 8.54;
43 
44             frank.Name = "Frank Smith";
45             frank.Gender = 'M';
46             frank.Program = "CST";
47             frank.StudentId = 200765797;
48             frank.GradePointAverage = 8.52;
49 
50             displayStudentInformation(bob);
51         }
52 
53         public static void displayStudentInformation(Student someStudent)
54         {
55             System.Console.WriteLine(someStudent.Name);
56             System.Console.WriteLine(someStudent.Gender);
57             System.Console.WriteLine(someStudent.Program);
58             System.Console.WriteLine(someStudent.StudentId);
59             System.Console.WriteLine(someStudent.GradePointAverage);
60         }
61     }
62 }

Employee & Company

The Employee and Company classes are similar to the Person and Student classes.

• Data Attributes of the Employee class:
• FirstName : String
• LastName : String
• SocialInsuranceNumber : Integer
• YearlySalary : Real
• EmploymentStartDate : Date
• Gender : Character

 1 using System;
 2 namespace Topic.B.Examples
 3 {
 4     public class Employee
 5     {
 6         public string FirstName;
 7         public string LastName;
 8         public int SocialInsuranceNumber;
 9         public double YearlySalary;
10         public DateTime EmploymentStartDate;
11         public char Gender;
12     }
13 }

• Data Attributes of the Company class:
• Name : String
• City : String
• IsIncorporated : Boolean
• BusinessStartDate : Date
• NumberOfEmployees : Integer
• GrossIncomeToDate : Real

 1 using System;
 2 namespace Topic.B.Examples
 3 {
 4     public class Company
 5     {
 6         public string Name;
 7         public string City;
 8         public bool IsIncorporated;
 9         public DateTime BusinessStartDate;
10         public int NumberOfEmployess;
11         public double GrossIncomeToDate;
12     }
13 }

In the following driver, the Employee and Company classes are both being used, illustrating the fact that any given “program” typically uses more than one class. In addition, this driver introduces the overloaded ToString() method in the DateTime class to improve the output of displaying dates and the Parse() method to convert a string representation of a date to an actual DateTime instance.

 1 using System;
 2 namespace Topic.B.Examples
 3 {
 4     public class DemoCompanyAndEmployee
 5     {
 6         public static void Main(string[] args)
 7         {
 8             Company Acme = new Company();
 9             Employee Salesman = new Employee();
10             Employee Shipper = new Employee();
11 
12             // Set the company's information
13             Acme.Name = "Acme International";
14             Acme.City = "Edmonton";
15             Acme.BusinessStartDate = new DateTime(); // new Date() defaults to t\
16 he current date
17             Acme.IsIncorporated = false;
18             Acme.NumberOfEmployess = 2;
19             Acme.GrossIncomeToDate = 2152368.52; // $ 2 million, plus change
20 
21             // Set the salesman's information
22             Salesman.FirstName = "Wiley";
23             Salesman.LastName = "Coyote";
24             Salesman.Gender = 'M';
25             Salesman.SocialInsuranceNumber = 123456789;
26             Salesman.EmploymentStartDate = DateTime.Today;
27             Salesman.YearlySalary = 45250.00;
28 
29             // Set the shipper's information
30             Shipper.FirstName = "Road";
31             Shipper.LastName = "Runner";
32             Shipper.Gender = 'F';
33             Shipper.SocialInsuranceNumber = 7777777;
34             Shipper.EmploymentStartDate = DateTime.Parse("June 1, 2008");
35             Shipper.YearlySalary = 54520.00;
36 
37 
38             // Show the information
39             System.Console.WriteLine("The information for the company:");
40             System.Console.WriteLine(Acme.Name);
41             System.Console.WriteLine(Acme.City);
42             System.Console.WriteLine(Acme.BusinessStartDate);
43             System.Console.WriteLine(Acme.IsIncorporated);
44             System.Console.WriteLine(Acme.NumberOfEmployess);
45             System.Console.WriteLine(Acme.GrossIncomeToDate);
46 
47             System.Console.WriteLine("The employee information: Salesman");
48             System.Console.WriteLine(Salesman.FirstName);
49             System.Console.WriteLine(Salesman.LastName);
50             System.Console.WriteLine(Salesman.Gender);
51             System.Console.WriteLine(Salesman.SocialInsuranceNumber);
52             System.Console.WriteLine(Salesman.EmploymentStartDate);
53             System.Console.WriteLine(Salesman.YearlySalary);
54 
55             System.Console.WriteLine("The employee information: Shipper");
56             System.Console.WriteLine(Shipper.FirstName);
57             System.Console.WriteLine(Shipper.LastName);
58             System.Console.WriteLine(Shipper.Gender);
59             System.Console.WriteLine(Shipper.SocialInsuranceNumber);
60             System.Console.WriteLine(Shipper.EmploymentStartDate.ToString("MMMM \
61 d, yyyy"));
62             System.Console.WriteLine(Shipper.YearlySalary);
63         }
64     }
65 }

Practice Exercises

• AnsweringMachine - Create the AnsweringMachine class so that it can provide a default answer for an incoming phone call as well as a customizable answer.
• Account - Extend the Account class from the example to include more information. Specifically, include an AccountType:String, BankName:String, BranchNumber:Integer, and InstitutionNumber:Integer.
• CanadianAddress - Create the CanadianAddress class so that it can represent the majority of possible addresses that some place may have in Canada.
• Course - Create the Course class so that it represents a post-secondary course.
• ExamResult - Create the ExamResult class so that it represents the results of an exam written by a student.
• LabResult - Create the labResult class so that it represents the results of a lab submitted by a student.

AnsweringMachine

The AnsweringMachine class provides a method to give an answer to an incoming phone call.

Problem Statement:

Create the AnsweringMachine class so that it can provide a default answer for an incoming phone call as well as a customizable answer. The methods should be named answer and they should return a String. There should be two methods in total, and both of them should be declared as instance members (non-static). The actual content of the default message can be whatever you choose, while the customizable method will receive a single String argument that has the name of the person receiving the message.

Also create a driver that demonstrates the AnsweringMachine in a Console environment

Create a driver for the AnsweringMachine class that creates an instance of the class and displays the results of calling the answer methods.

Account

Extend the Account class from the example to include more information.

Problem Statement:

Extend the Account class from the example to include more information. Specifically, include an AccountType:String, BankName:String, BranchNumber:Integer, and InstitutionNumber:Integer.

Also modify the driver to make use of the added information.

Notes

The branch number and the institution number together make up the Transit Number for a bank. “The bank transit number is 8 digits long. This is divided into a 5 digit branch number and 3 digit institution code, for example 10000-200.” (See http://en.wikipedia.org/wikiSort_code)

For more information on bank accounts and transit numbers in Canada, see http://en.wikipedia.org/wiki/Routing_transit_number#Canadian_transit_number.

CanadianAddress

This class represents an address for some place in Canada.

Problem Statement:

Create the CanadianAddress class so that it can represent the majority of possible addresses that some place may have in Canada. Design the class to have only public fields, as specified in this document.

• Data Attributes of the CanadianAddress class:
  
  • Street : String
  • Unit : String
  • City : String
  • Province : String
  • PostalCode : String
  • RuralRoute : String
  • BoxNumber : String

Also create a driver for testing this class; you may use any name for the driver as long as it is not already mentioned in this package. In the driver, create instances of the CanadianAddress class that represent your current address as well as the address of your school (use hard-coded data).

Course

This class represents a post-secondary course with a theory (exam) and a lab portion.

Problem Statement:

Create the Course class so that it represents a post-secondary course. Design the class to have only public fields, as specified in this document.

• Data Attributes of the Course class:
  
  • CourseName : String
  • CourseNumber : String
  • ExamCount : Integer
  • LabCount : Integer
  • ClassHours : Integer

Also create a driver for testing this class; you may use any name for your driver as long as it is not already mentioned in this package. In the driver, instantiate all of the first term classes you are taking and populate those objects with data (use hard-coded data).

ExamResult

This class represents the results of an exam for a student.

Problem Statement:

Create the ExamResult class so that it represents the results of an exam written by a student. Design the class to have only public fields, as specified in this document.

• Data Attributes of the ExamResult class:
  
  • Name : String
  • TotalMarks : Integer
  • MarksEarned : Real
  • ExamWeight : Integer
  • StudentId : Integer

Also create a driver for testing this class; you may use any name for the driver as long as it is not already mentioned in this package. In the driver, instantiate all of the exams you have taken to date in this course and populate those objects with data (use hard-coded data).

LabResult

This class represents the results of an lab for a student.

Problem Statement:

Create the labResult class so that it represents the results of a lab submitted by a student. Design the class to have only public fields, as specified in this document.

• Data Attributes of the LabResult class:
  
  • LabNumber : Integer
  • TotalMarks : Integer
  • MarksEarned : Real
  • LabWeight : Integer
  • StudentId : Integer

Also create a driver for testing this class; you may use any name for the driver as long as it is not already mentioned in this package. In the driver, instantiate all of the labs you have submitted to date in this course and populate those objects with data (use hard-coded data).

Topic C – Starting Classes

Overview

This topic introduces some of the basic syntax and grammar surrounding Object-Oriented Programming in C#. The following keywords are introduced. (Note that additional keywords from previous topics may also be present.)

• private
• this
• bool
• true
• false
• DateTime

This topic will also introduce the following grammars, syntax and language constructs. (Note that additional concepts from previous topics may also be present.)

• Private fields (encapsulation)
• Public properties (encapsulation)
• Constructor syntax
• Object instantiation with parameterized constructors
• Overriding the Object’s ToString() method

Daily LOGs

The following daily LOGs are covered in this package.

OOP Basics

• Define the term “encapsulation” as used in OOP
• Explain why encapsulation is a good design principle
• Define the term “access specifier” and identify where it occurs in the code for a class
• List the two access specifiers that are used in this course
• Describe the difference between “private” and “public” members of a class
• Describe the concepts of “properties” as used in OOP
• Define the term “backing store” as it applies to properties and fields
• Describe and explain the purpose and function of a constructor for a class
• Describe the syntax of a class constructor
• Identify when a class constructor is “called”
• Define the term “class scope” as used in OOP
• Define the term “local scope” as used in OOP
• Define the term “state” as applied to objects used in OOP
• Define the term “override” as used in OOP
• Explain the purpose and function of the ToString() method and why we sometimes want to change its default behaviour when we create classes
• Create simple class diagrams to represent classes

General Programming Concepts and Terms

• List three levels of scope

Code Samples

The following examples are used to illustrate this topic.

1. Person - This simple class illustrates and introduces the idea of encapsulation (private fields with public properties). This example does not have a constructor. This example includes a driver. The driver is also used to illustrate how, with only fields & getter/setter methods, an object can be in an “unknown” (and invalid) state as soon as it is created; this idea is introduced to show the need for a constructor, and opens the discussion of the idea of a “default constructor”.
2. Account - This simple class also illustrates encapsulation, but with some of the fields being read-only. This necessitates the presence of a constructor. This example includes a driver which shows that a class is in a “known state” as soon as it is created.
3. Student - This class reinforces the idea of encapsulation and constructors. It also introduces the idea of overloading the default toString() method that every class inherits from the Object class. This example includes a driver with multiple objects, showing how the use of constructors makes it easier to create many objects in a few lines of code.
4. Employee + Company - These are other classes similar to the Person and Student classes, but the Employee class uses Auto-Implemented properties (new since C# 3.0). Lastly, these classes “share” a driver, illustrating the fact that any given “program” typically uses more than one class.

The following class diagrams detail the design of these examples.

Person

This simple class illustrates and introduces the idea of encapsulation (private fields with public properties). This example does not have a constructor. This example includes a driver. The driver is also used to illustrate how, with only fields & getter/setter methods, an object can be in an “unknown” (and invalid) state as soon as it is created; this idea is introduced to show the need for a constructor, and opens the discussion of the idea of a “default constructor”.

Account

This simple class also illustrates encapsulation, but with some of the fields being read-only. This necessitates the presence of a constructor. This example includes a driver which shows that a class is in a “known state” as soon as it is created.

Student

This class reinforces the idea of encapsulation and constructors. It also introduces the idea of overloading the default ToString() method that every class inherits from the Object class. This example includes a driver with multiple objects, showing how the use of constructors makes it easier to create many objects in a few lines of code.

Company and Employee

These are other classes similar to the Person and Student classes, but the Employee class uses Auto-Implemented properties (new since C# 3.0). Lastly, these classes “share” a driver, illustrating the fact that any given “program” typically uses more than one class.

Practice Exercises

• Person - Extend the Person class to include a constructor.
• Account – Extend the Account class from the example to include more information. Specifically, include an AccountType:String, BankName:String, BranchNumber:Integer, and InstitutionNumber:Integer.
• CanadianAddress - This class represents an address for some place in Canada.
• Course - This class represents a post-secondary course with a theory (exam) and a lab portion.
• ExamResult - This class represents the results of an exam for a student.
• LabResult - This class represents the results of an lab for a student.

Person

This simple class illustrates and introduces the idea of encapsulation (private fields with public properties). This example uses a constructor for ensuring the state of an object when it is instantiated (created).

Extend the Person class from the example to include a constructor that takes in a first and last name as well as an age in the parameter list.

Account

Extend the Account class from the example to include more information.

Problem Statement:

Extend the Account class from the example to include more information. Specifically, include an AccountType:String, BankName:String, BranchNumber:Integer, and InstitutionNumber:Integer. Base your solution on the following class diagram.

Also modify the driver to make use of the added information.

Notes

The branch number and the institution number together make up the Transit Number for a bank. “The bank transit number is 8 digits long. This is divided into a 5 digit branch number and 3 digit institution code, for example 10000-200.” (See http://en.wikipedia.org/wikiSort_code)
For more information on bank accounts and transit numbers in Canada, see http://en.wikipedia.org/wiki/Routing_transit_number#Canadian_transit_number.

CanadianAddress

This class represents an address for some place in Canada.

Problem Statement:

Create the CanadianAddress class so that it can represent the majority of possible addresses that some place may have in Canada. Design the class to use auto-implemented properties as specified in this class diagram. No constructor is required for this class.

Also create a driver for testing this class; you may use any name for the driver as long as it is not already mentioned in this namespace. In the driver, create two instances of the CanadianAddress class that represent your current address as well as the address of your school (use hard-coded data).

Course

This class represents a post-secondary course with a theory (exam) and a lab portion.

Problem Statement:

Create the Course class so that it represents a post-secondary course. Design the class to have auto-implemented properties and a constructor as specified in this class diagram. Note that the auto-implemented properties should have their “set” implementations marked as private.

Also create a driver for testing this class; you may use any name for your driver as long as it is not already mentioned in this namespace. In the driver, instantiate all of the first term classes you are taking and populate those objects with data (use hard-coded data).

LabResult

This class represents the results of a lab for a student.

Problem Statement:

Create the LabResult class so that it represents the results of a lab submitted by a student. Design the class to have the fields, properties, and constructor as specified in this document. Also create a ToString() method that describes the information in any given instance of this class.

Use an auto-implemented property for the MarksEarned; use fields as the “backing store” for all other properties.

Note that the following properties should not have “set” implementations: TotalMarks, LabNumber, LabWeight, and StudentId.

Here are some XML comments to describe the ToString( ) method.

 1 /// <summary>
 2 /// This method overrides the default ToString() method to display 
 3 /// more meaningful information about this object.
 4 /// </summary>
 5 /// <returns>A string displaying the StudentId, MarksEarned, and 
 6 /// TotalMarks.</returns>
 7 /// <remarks>
 8 /// A call to this method (such as <c>Lab4.ToString()</c>) 
 9 /// would produce the following result:
10 /// <code>The student (200702694) received 24.5/35 for this lab.</code>
11 /// </remarks>

Also create a driver for testing this class; you may use any name for the driver as long as it is not already mentioned in this namespace. In the driver, instantiate all of the labs you have submitted to date in any course and populate those objects with data (use hard-coded data); if you haven’t had any labs as of yet, then make up some data.

### ExamResult

This class represents the results of an exam for a student.

Problem Statement:

Create the ExamResult class so that it represents the results of an exam written by a student. Design the class to have the properties and constructors as specified in this document. (Note that there are two constructors for this class.) Also create a ToString( ) method that describes the information in any given instance of this class.

Use auto-implemented properties for the entire class. Note that only the following properties should have private “set” implementations: TotalMarks, ExamName, ExamWeight, and StudentId.

Also create a driver for testing this class; you may use any name for the driver as long as it is not already mentioned in this namespace. In the driver, instantiate all of the exams you have taken to date in this course and populate those objects with data (use hard-coded data); if you need to, you may create fake data for the driver.

Topic D – Testing and Debugging

Overview

This topic introduces the concepts of testing and verifying that code is running correctly. Two approaches will be presented and compared: Ad-hoc test drivers and Unit Tests.

Test drivers that rely on user input/output are the traditional means of verifying that code runs properly. The biggest benefit of test drivers is that they provide quick “ad-hoc” tests and are simple to produce on any IDE. However, test drivers have some major downfalls.

Current programming techniques make use of Unit Tests. A unit test is a simple, isolated test of some part of a class. Unit tests provide a way to clearly show the success or failure of a particular section of code. Unit tests are a key part of Test Driven Development (TDD).

Regardless of whether the developer uses test drivers or unit tests, it is important to remember that the developer is still responsible to make sure that the tests (and thus, the test results) are valid. Improper use of test drivers and unit tests can lead to
* “false positives” - indicating that something works when it really doesn’t, and
* “false negatives” - indicating that something is broken when it really isn’t

Note: For this course, students will be provided with unit tests and will not be expected to have to write their own unit tests. The unit tests supplied to students will use nUnit 2.5.7 which is already installed in the lab. To use these libraries at home, simply install nUnit 2.5.7 on your home computer.

LOGs

The following daily LOGs are covered in this package.

General Programming Concepts and Terms

• Explain the role of testing as it applies to software development
• Define and compare the terms “compile-time error” and “run-time error”
• Define the term “test driver”
• Create simple ad-hoc test drivers to test for run-time errors
• Define the term “TDD”
• Compare and contrast Test Drivers and Unit Tests
• Define the terms “false positive” and “false negative”
• List three downfalls of using Test Drivers
• Identify four benefits of using Unit Tests
• Add unit testing libraries and unit testing packages to existing programs
• Use unit tests to validate the requirements of a class’ design and behaviour
• Diagnose and correct software problems by using unit tests

Code Samples

The following examples are used to illustrate this topic.

1. Person - This simple class was used to introduce the idea of encapsulation (private fields with public getters and setters). This example uses a constructor for ensuring the state of an object when it is instantiated (created). In this topic, it is used to demonstrate unit testing.
2. Account - This simple class also illustrates encapsulation, but with some of the fields being read-only. This class uses a constructor (which is also necessary for getting state into fields which do not have corresponding setter methods).
3. Student - This class reinforces the idea of encapsulation and constructors. It also demonstrates the idea of overloading the default ToString() method that every class inherits from the Object class.
4. Employee – The Employee class represents basic information about an employee of a company.
5. Company - These are other classes similar to the Person and Student classes. These classes, however, “share” a driver, illustrating the fact that any given “program” typically uses more than one class.

Test Drivers (Console I/O)
TBA
Unit Tests (nUnit)
The unit tests for these classes are included in the solution folder under the “Demos + Practice” folder. Simply double-click the NUnit Test Project (.nunit) and the tests will open in the NUnit GUI.

Person

This simple class was used to introduce the idea of encapsulation (private fields with public getters and setters). This example uses a constructor for ensuring the state of an object when it is instantiated (created). In this topic, it is used to demonstrate unit testing. The following diagram represents the last design for the Person class, as completed in the exercises portion of the previous topic.

The supplied unit tests check all of this previously documented behaviour, but they also check to see if the Person class has overridden the ToString() method. Because this requirement is new, and has not yet been implemented, the unit tests show this as a “failed test.” The following diagram is the design that the unit tests are evaluating.

Should…
* Instantiate (build) from constructor
* Get/Set First Name
* Get/Set Last Name
* Get/Set Age
* [NOT-YET-IMPLEMENTED] Override ToString() to get the person’s full name (as first name then last name)
  The test for this method will report as “failed” because it has not yet been implemented.

Account

This simple class also illustrates encapsulation, but with some of the fields being read-only. This class uses a constructor (which is also necessary for getting state into fields which do not have corresponding setter methods).

Should…
* Get Bank Name
* Get Branch Number
* Get Institution Number
* Get Account Number
* Get Account Type
* Get/Set Balance
* Get/Set Overdraft Limit

Student

This class reinforces the idea of encapsulation and constructors. It also demonstrates the idea of overloading the default ToString() method that every class inherits from the Object class.

Should…
* Get/Set Name
* Get/Set Gender
* Get/Set Student Id
* Get/Set GPA
* Get/Set Program
* Get/Set Full-Time
* Override ToString() to get the student’s ID and name

Employee

Should…
* Get/Set First Name
* Get/Set Last Name
* Get/Set Gender
* Get/Set Employment Date
* Get/Set Salary
* Get Social Insurance Number

Company

Should…
* Get/Set Name
* Get/Set City
* Get/Set Incorporated
* Get/Set Number of Employees
* Get/Set Gross Income to Date
* Get Business Start Date

Practice Exercises

1. Person - This simple class was used to introduce the idea of encapsulation (private fields with public properties). This example uses a constructor for ensuring the state of an object when it is instantiated (created). It also demonstrates the overriding of the ToString() method inherited from the Object method.
2. CanadianAddress - This class represents an address for some place in Canada.
   Update this class to now include a constructor and to override the ToString() method.
3. Course - This class represents a post-secondary course with a theory (exam) and a lab portion.
4. ExamResult - This class represents the results of an exam for a student.
5. LabResult - This class represents the results of a lab for a student.

For this exercise, take the code solutions you created in the previous topic and compare your results with the jUnit tests for these classes; check with your instructor to see where you can download the unit tests.

Person

This simple class was used to introduce the idea of encapsulation (private fields with public properties). This example uses a constructor for ensuring the state of an object when it is instantiated (created). It also demonstrates the overriding of the ToString() method inherited from the Object method.

Should…
* Instantiate (build) from constructor
* Get/Set First Name
* Get/Set Last Name
* Get/Set Age
* Override ToString() to get the person’s full name (as first name then last name)

CanadianAddress

Should…
* Instantiate (build) from Constructor
* Get/Set: Street, Unit, City, Province, Postal Code, Rural Route, Box Number
* Override ToString() to just show Street, City, Province, and Postal Code

Course

Should…
* Instantiate from Constructor
* Get: Course Name, Course Number, Exam Count, Lab Count, Class Hours

ExamResult

Should…
* Instantiate from Constructor
* Get/Set: Marks Earned
* Get: Name, Student Id, Total Marks, Exam Weight
* Override ToString() to show
  “The student (studentId) received earnedMarks/totalMarks for this examName exam.”

LabResult

Should…
* Instantiate from Constructor
* Get/Set: Marks Earned
* Get: Lab Number, Student Id, Total Marks, Lab Weight
* Override ToString() to show
  “The student (studentId) received earnedMarks/totalMarks for this lab.”

Expressions, Math, Exceptions, If-Else, and Case

Topic E – Expressions and Math

Overview

This topic introduces concepts surrounding the use of arithmetic expressions and common Math library routines.

This topic will introduce the following grammars, syntax and language constructs. (Note that additional concepts from previous topics may also be present.)

• Arithmetic expressions
• Assignment statements
• Automatic type conversion and casting
• Integer division
• String concatenation
• Math library routines and constants (such as Random, Square Root, and π)

This topic will also take a deeper look at the distinctive aspects of variables, values and data types as well as demonstrate the use of overloaded constructors. This is also the first foray into creating classes that actually “do something” – these classes not only maintain state but also provide methods to generate other information besides that which is stored in a class’ fields.

LOGs

OOP Basics

• Explain how method overloading is applied to constructors

General Programming Concepts and Terms

• Name at least three kinds of program statements commonly seen in all high-level programming languages
• Distinguish between Variables, Values and Data Types
• List the five basic rules governing variables, values and data types
• List the intrinsic (built-in) data types in C#
• Explain what is meant by the phrase “type extensibility”
• Define the terms Reference Type and Value Type as they apply to data types in C#
• Define the term Identifier
• Create and initialize variables in C#
• Explain what is meant by the terms “scope” and “lifetime” as they apply to variables
• Describe what is meant by the term “expression”
• Explain the difference between program statements and expressions as well as how the two relate to each other
• List the three general sets of operators in C#
• Describe the two basic rules of using arithmetic operators that every compiler must follow.
• Use the arithmetic operators to create arithmetic expressions
• Explain what is meant by “integer division” and how that can be useful in solving particular problems regarding numbers.
• Explain the purpose of the modulus (%) operator.
• List and describe how to use the various assignment operators in C#
• Explain the difference between binary and unary operators
• Demonstrate understanding of operator precedence and how to override the default precedence of the arithmetic operators
• Summarize and distinguish the rules for automatic type conversion involving arithmetic operators and the assignment operator
• Determine the final data type for expressions involving mixed data types and type conversion
• Describe “type casting” and explain how to use it appropriately.
• Compare and contrast the prefix and postfix behaviour of the unary arithmetic operators
• Identify and explain how to use the common Math library routines (for Power, Square Root, Absolute, random numbers, pi, trigonometry, and the various types of rounding)
• Use Math rounding methods with arithmetic expressions to round real numbers to a specific precision
• Create random whole number values within a specific range
• Use type casting appropriately in C#
• Create constants in C#
• Explain how arithmetic operations affect character values in C#
• List the most common math functions of the Math class
• Demonstrate how to use the various Math functions in simple programs
• List and describe the commonly used fields and methods of the String class
• Demonstrate how to use “String Arithmetic” (concatenation)
• List the equivalent “wrapper” classes for each of the primitive types.

Code Samples

The following examples are used to illustrate this topic.

1. Calculator – This class introduces simple arithmetic operations, demonstrating simple addition and multiplication.
2. Person - This adaptation of the person class changes the previous design by replacing the age field with a “read-only” field for the person’s birth date. The approximate age of the person is then calculated based on the current date and the birth date.
3. Account - This class illustrates simple addition and calculation by allowing deposits and withdrawals. Note that changes to the balance can now only be made through deposits and withdrawals; the balance is now “read-only”.
4. ElapsedTime – This class demonstrates overloaded constructors and introduces the concepts of operator precedence and integer division.
5. ResolveExpressions – This class is used in conjuncture with several sample expressions that illustrate operator precedence and automatic type conversion.
6. Circle - This class represents a simple circle of a specified diameter. The radius, area and circumference are calculated.
7. Square - This class represents a simple square with a specified length for its side. The area and perimeter are calculated.
8. Fraction - This class represents a fraction as a numerator and denominator. It provides the double equivalent of the fraction’s value as well as a string representation that uses the numerator and denominator. It demonstrates type casting and the integer division issue.
9. Angle - This class represents an angle and provides the value in the following units: degrees, radians and grads. It also gives a simple example of unicode characters (for degrees).
10. StockItem - This class represents an item that is part of an inventory. The item has an item name, a cost and a profit margin (which can be positive or negative). By using the profit margin, it can derive the price of the item. This example illustrates rounding.
11. Die - This class represents a single six-sided die. This example is used to illustrate random number generation and casting.
12. ParkingCounter - This class represents a simple counter to monitor whether a parking lot is full or not; it tracks vehicles entering and leaving the parking lot and allows the counter to be reset when the lot is full or empty. This class illustrates increment and decrement operators and/or the assignment increment or assignment decrement operators.
13. QuadradicEquation - This class is used to solve for the two possible values of a quadratic formula where quadradic equals zero. This sample illustrates order of operations and parentheses.

Calculator

This class introduces simple arithmetic operations, demonstrating simple addition and multiplication.

Problem Statement

Write the code that will act as a calculator for doing math. This first version must be a working prototype; as a prototype, it does not have to support all of the features of the final product.

The solution must meet the following requirements:

• Should add two whole numbers.
• Should multiply two whole numbers.

Use the following class diagram when creating your solution. Since this class does not have properties or fields, make the methods static.

 1 public class Calculator
 2 {
 3     public static int Add(int firstNumber, int secondNumber)
 4     {
 5         return firstNumber + secondNumber;
 6     }
 7 
 8     public static int Multiply(int firstNumber, int secondNumber)
 9     {
10         return firstNumber * secondNumber;
11     }
12 }

Person

This adaptation of the person class changes the previous design by replacing the age field with a “read-only” field for the person’s birth date. The approximate age of the person is then calculated based on the current date and the birth date.

Problem Statement

Write the code that will represent a person with a first and last name and a date of birth.
The solution must meet the following requirements (new requirements are in bold):
* Should get and set the first and last name
* Should get the birth date
* Should get the person’s approximate age (which is the age that the person will turn to in the current year)
* Should get the person’s initials
* Should override ToString() to get the person’s full name (as first name then last name)

Use the following class diagram when creating your solution.

 1 public class Person
 2 {
 3     public string FirstName { get; set; }
 4 
 5     public string LastName { get; set; }
 6 
 7     public DateTime BirthDate { get; private set; }
 8 
 9     public int Age
10     {
11         get
12         {
13             int currentAge = 0;
14             currentAge = DateTime.Today.Year - BirthDate.Year;
15             return currentAge;
16         }
17     }
18     public Person(string firstName, string lastName, DateTime birthDate)
19     {
20         FirstName = firstName;
21         LastName = lastName;
22         BirthDate = birthDate;
23     }
24 
25 
26     public override string ToString()
27     {
28         return FirstName + " " + LastName;
29     }
30 
31     public string Initials
32     {
33         get
34         {
35             return FirstName[0] + "." + LastName[0] + ".";
36         }
37     }
38 }

Account

This class illustrates simple addition and calculation by allowing deposits and withdrawals. Note that changes to the balance can now only be made through deposits and withdrawals; the balance is now “read-only”.

Problem Statement

Write the code that will represent a simple bank account.

The solution must meet the following requirements (new requirements are in bold):

• Should get the bank name, branch number, institution number, account number, balance, overdraft limit, and account type
• Should allow the overdraft limit to be set
• Should support deposits and withdrawals

Use the following class diagram when creating your solution.

1   public void Withdraw(double amount)
2   {
3       Balance -= amount;
4   }
5 
6   public void Deposit(double amount)
7   {
8       Balance += amount;
9   }

ElapsedTime

This class demonstrates overloaded constructors and introduces the concepts of operator precedence and integer division.

Problem Statement

Write the code that will represent a period of elapsed time for a competitor in a marathon. It should be able to represent its information in two forms:

• Hours, minutes and seconds, and
• Total seconds.

The solution must meet the following requirements:

• Should calculate the hours, minutes and seconds given the total seconds
• Should calculate the total seconds given the hours, minutes and seconds

Use the following class diagram when creating your solution.

 1 public class ElapsedTime
 2 {
 3     public ElapsedTime(int hours, int minutes, int seconds)
 4     {
 5         TotalSeconds = hours * 60 * 60;
 6         TotalSeconds += minutes * 60;
 7         TotalSeconds += seconds;
 8 
 9         Hours = hours;
10         Minutes = minutes;
11         Seconds = seconds;
12     }
13 
14     public ElapsedTime(int totalSeconds)
15     {
16         Hours = totalSeconds / (60 * 60);
17         Minutes = (totalSeconds - Hours * 60 * 60) / 60;
18         Seconds = totalSeconds - Hours * 60 * 60 - Minutes * 60;
19 
20         TotalSeconds = totalSeconds;
21     }
22 
23     public int Hours { get; private set; }
24 
25     public int Minutes { get; private set; }
26 
27     public int Seconds { get; private set; }
28 
29     public int TotalSeconds { get; private set; }
30 }

ResolveExpressions

This class is used in conjuncture with several sample expressions that illustrate operator precedence and automatic type conversion.

Problem Statement

Write the code that will provide the final value for the expressions in the following exercise (as a solution for a student’s exercise).

Expressions Exercise

On a piece of paper, evaluate the following expressions to show the final value and the data type of the final value. Show the order in which the operations are evaluated.

1. 10.0 + 15 / 2 + 4.3
2. 8 / 5 + 1.25
3. 10.0 + 15.0 / 2 + 4.3
4. 3.0 * 4 / 6 + 6
5. 3.0 * (4 % 6) + 6
6. 3 * 4.0 / 6 + 6
7. 20.0 - 2 / 6 + 3
8. 10 + 17 % 3 + 4
9. (10 + 17) % 3 +4.0
10. 10 + 17 / 4.0 + 4

The solution for question 2 is provided as an example. Use the accompanying class diagram when creating your coded solution as proof of your final answers.

 1 namespace Topic.E.Examples
 2 {
 3     public class ResolveExpressions
 4     {
 5         public static double Sample1
 6         { get { return 10.0 + 15 / 2 + 4.3; } }
 7 
 8         public static double Sample3
 9         { get { return 10.0 + 15.0 / 2 + 4.3; } }
10 
11         public static double Sample4
12         { get { return 3.0 * 4 / 6 + 6; } }
13 
14         public static double Sample5
15         { get { return 3.0 * (4 % 6) + 6; } }
16 
17         public static double Sample6
18         { get { return 3 * 4.0 / 6 + 6; } }
19 
20         public static double Sample7
21         { get { return 20.0 - 2 / 6 + 3; } }
22 
23         public static int Sample8
24         { get { return 10 + 17 % 3 + 4; } }
25 
26         public static double Sample9
27         { get { return (10 + 17) % 3 + 4.0; } }
28 
29         public static double Sample10
30         { get { return 10 + 17 / 4.0 + 4; } }
31     }
32 }

Circle

This class represents a simple circle of a specified diameter. The radius, area and circumference are calculated.

Problem Statement

Write the code for the Circle class. The solution must meet the following requirements:

• Should get and set the diameter
• Should calculate the area, radius, and circumference

Use the following class diagram when creating your solution.

 1 using System;
 2 namespace Topic.E.Examples
 3 {
 4     public class Circle
 5     {
 6         public Circle(double diameter)
 7         {
 8             this.Diameter = diameter;
 9         }
10 
11         public double Diameter { get; set; }
12 
13         public double Radius
14         { get { return Diameter / 2; } }
15 
16         public double Circumference
17         { get { return Math.PI * Diameter; } }
18 
19         public double Area
20         { get { return Math.PI * Radius * Radius; } }
21     }
22 }

Square

This class represents a simple square with a specified length for its side. The area and perimeter are calculated.

Problem Statement

Write the code for the Square class. The solution must meet the following requirements:

• Should get and set the length of the side of the square
• Should calculate the area and perimeter

Use the following class diagram when creating your solution.

 1 namespace Topic.E.Examples
 2 {
 3     public class Square
 4     {
 5         public Square(double side)
 6         {
 7             this.Side = side;
 8         }
 9 
10         public double Side { get; set; }
11 
12         public double Area
13         {
14             get { return Side * Side; }
15         }
16 
17         public double Perimeter
18         {
19             get { return Side * 4; }
20         }
21     }
22 }

Fraction

This class represents a fraction as a numerator and denominator. It provides the double equivalent of the fraction’s value as well as a string representation that uses the numerator and denominator. It demonstrates type casting and the integer division issue.

Problem Statement

Write the code for the Fraction class. The solution must meet the following requirements:

• Should get the string representation of the fraction, as “numerator/denominator”
• Should get the numeric value of the fraction (as a real number)
• Should get the reciprocal of the fraction

Use the following class diagram when creating your solution.

 1 public class Fraction
 2 {
 3     public int Numerator { get; private set; }
 4 
 5     public int Denominator { get; private set; }
 6 
 7     public Fraction(int numerator, int denominator)
 8     {
 9         Numerator = numerator;
10         Denominator = denominator;
11     }
12 
13     public Fraction Reciprocal
14     {
15         get { return new Fraction(Denominator, Numerator); }
16     }
17 
18     public override string ToString()
19     {
20         string stringValue = "";
21         stringValue += Numerator + "/" + Denominator;
22         return stringValue;
23     }
24 
25     public double ToDouble()
26     {
27         // The casting of numerator to a double helps
28         // ensure that we don't lose any fractional
29         // portion due to integer division.
30         double value = (double)(Numerator) / Denominator;
31         return value;
32     }
33 }

Angle

This class represents an angle and provides the value in the following units: degrees, radians and grads. It also gives a simple example of unicode characters (for degrees).

Problem Statement

Write the code for the Angle class. The solution must meet the following requirements:

• Should get and set the angle’s value (in degrees)
• Should calculate the equivalent angle in Radians and Grads, using the following formulas:
• Radians = Degrees * (π / 180)
• Grads = Radians * (200 / π)
• Should override the ToString() method to return the angle in degrees, in the following format:
• degrees°
• The Unicode character for the degrees symbol (°) is ‘\u00B0’

Use the following class diagram when creating your solution.

 1 using System;
 2 namespace Topic.E.Examples
 3 {
 4     public class Angle
 5     {
 6         public Angle(double degrees)
 7         {
 8             this.Degrees = degrees;
 9         }
10 
11         public double Degrees { get; set; }
12 
13         public double Radians
14         {
15             get
16             {
17                 double radians = Degrees * (Math.PI / 180);
18                 return radians;
19             }
20         }
21 
22         public double Grads
23         {
24             get
25             {
26                 double grads = Radians * (200 / Math.PI);
27                 return grads;
28             }
29         }
30 
31         // http://unicode.org/notes/tn28/UTN28-PlainTextMath.pdf
32         // Page 40 of the above reference for the degree symbol
33         public override string ToString()
34         {
35             return Degrees.ToString() + '\u00B0';
36         }
37     }
38 }

StockItem

This class represents an item that is part of an inventory. The item has an item name, a cost and a profit margin (which can be positive or negative). By using the profit margin, it can derive the price of the item. This example illustrates rounding.

Problem Statement

Write the code for the StockItem class. The solution must meet the following requirements:

• Should get and set the name, cost and profit margin of the stock item
• Should represent the profit margin as a percent; a value of 45 means 45%
• Should calculate the price of the item, to the nearest cent
• Use the rounding where values under a half-cent are rounded down and values greater than or equal to a half-cent are rounded up

Use the following class diagram when creating your solution.

 1 using System;
 2 namespace Topic.E.Examples
 3 {
 4     public class StockItem
 5     {
 6         public double Cost { get; set; }
 7 
 8         public double ProfitMargin { get; set; }
 9 
10         public StockItem(string itemName, double cost, double profitMargin)
11         {
12             this.ItemName = itemName;
13             this.Cost = cost;
14             this.ProfitMargin = profitMargin;
15         }
16 
17         public string ItemName { get; set; }
18 
19         public double Price
20         {
21             get
22             {
23                 // Round to the nearest cent
24                 double price = Cost;
25                 price += Cost * (ProfitMargin / 100);
26                 return Math.Round(price * 100) / 100.0;
27             }
28         }
29     }
30 }

Die

This class represents a single six-sided die. This example is used to illustrate random number generation and casting.

Problem Statement

Write the code for the Die class. The solution must meet the following requirements:

• Should generate a random value from 1 to 6, when initially created and when re-rolled
• Should get the face value of the die

Use the following class diagram when creating your solution. Note that this uses the Random class as a private static field.

 1 using System;
 2 namespace Topic.E.Examples
 3 {
 4     public class Die
 5     {
 6         private static Random rnd = new Random();
 7 
 8         public Die()
 9         {
10             Roll();
11         }
12 
13         public int FaceValue { get; private set; }
14 
15         public void Roll()
16         {
17             FaceValue = rnd.Next(6000) % 6 + 1;
18         }
19     }
20 }

ParkingCounter

This class represents a simple counter to monitor whether a parking lot is full or not; it tracks vehicles entering and leaving the parking lot and allows the counter to be reset when the lot is full or empty. This class illustrates increment and decrement operators and/or the assignment increment or assignment decrement operators.

Problem Statement

Write the code that will monitor vehicles entering and leaving a parking lot. The solution must meet the following requirements:

• Should track vehicles entering
• Should track vehicles leaving
• Should get total parking spots
• Should get open (empty) spots
• Should reset lot as full (that is, fill the parking lot)
• Should reset lot as empty (that is, clear all the parking spots of vehicles)

Use the following class diagram when creating your solution.

 1 namespace Topic.E.Examples
 2 {
 3     public class ParkingCounter
 4     {
 5         public int ParkingSpots { get; private set; }
 6 
 7         public int OpenSpots { get; private set; }
 8 
 9         public ParkingCounter(int parkingSpots)
10         {
11             this.ParkingSpots = parkingSpots;
12             this.OpenSpots = parkingSpots;
13         }
14 
15         public ParkingCounter(int parkingSpots, int numberOfCars)
16         {
17             this.ParkingSpots = parkingSpots;
18             this.OpenSpots = this.ParkingSpots - numberOfCars;
19         }
20 
21         public void Leave()
22         {
23             OpenSpots++;
24         }
25 
26         public void Enter()
27         {
28             OpenSpots--;
29         }
30 
31         public void ResetLotAsEmpty()
32         {
33             OpenSpots = ParkingSpots;
34         }
35 
36         public void ResetLotAsFull()
37         {
38             OpenSpots = 0;
39         }
40     }
41 }

QuadradicEquation

This class is used to solve for the two possible values of a quadratic formula where quadratic equals zero. It is based off of the following formula.

This sample illustrates order of operations and parentheses.

Problem Statement

Write the code that will represent a quadratic equation that has a higher and lower root. It is to use the Quadratic formula, which states:

For ax^2 + bx + c = 0$, the value of x is given by

More information on the quadratic formula can be found at http://www.purplemath.com/modules/quadform.htm.

The solution must meet the following requirements:

• Should get the lower root, using the quadratic formula
  x=(-b-√(b^2-4ac))/2a$
• Should get the higher root, using the quadratic formula
  x=(-b+√(b^2-4ac))/2a$
• Should overload the ToString() method to represent the quadratic formula showing the values for a, b and c in the following format:
  a____x2 + ____b____x + ____c = 0
  For example, given the values of 1, 3 and -4 for a, b and c respectively, the method should produce
  1x2 + 3x + -4 = 0

Use the accompanying class diagram when creating your solution.

 1 using System;
 2 namespace Topic.E.Examples
 3 {
 4     public class QuadraticEquation
 5     {
 6         private int a;
 7         private int b;
 8         private int c;
 9 
10         public QuadraticEquation(int a, int b, int c)
11         {
12             this.a = a;
13             this.b = b;
14             this.c = c;
15         }
16 
17         public double LowerRoot
18         {
19             get
20             {
21                 double value;
22                 value = (-b - Math.Sqrt(b * b - 4 * a * c)) / (2 * a);
23                 return value;
24             }
25         }
26 
27         public double HigherRoot
28         {
29             get
30             {
31                 double value;
32                 value = (-b + Math.Sqrt(b * b - 4 * a * c)) / (2 * a);
33                 return value;
34             }
35         }
36 
37 
38         public override string ToString()
39         {
40             return a.ToString() + "x^2 + " + b + "x + " + c + " = 0";
41         }
42     }
43 }

Practice Exercises

• Calculator – This exercise expands on the original Calculator class to perform subtraction and division with integers.
• Fraction – This exercise expands on the original Fraction class to include methods that allow for adding, subtracting, multiplying, and dividing fractions.
• Square – This exercise expands on the original Square class to include a method that determines the diagonal of a square.
• Coordinate – Not Yet Implemented The Coordinate class represents a geographical co-ordinate for either longitude or latitude. A Coordinate’s value can be expressed either as a real number or as degrees, minutes and seconds. It makes use of integer division and overloaded constructors.
• PaintEstimator – The PaintEstimator class is used to estimate the number of paint cans needed for painting a simple room (with or without a window). It makes use of a constant and the Math library; it also uses overloaded constructors.
• BulkItem – The BulkItem class represents products that are available in bulk and shows the cost of individual items. It makes use of rounding (to two decimal places).
• Die - This exercise expands on the original Die class to allow for creating a die of any number of sides, with a default of six sides. This means that there is an overloaded constructor.
• RoundingCalculator – This exercise demonstrates rounding using separate methods for each level of rounding precision.
• GenericRoundingCalculator – This exercise demonstrates rounding to the nearest whole number of fractional number using a couple of “generic” methods.
• PeopleCounter – This simple class is used to count the number of people who have entered a store in a single day. It takes a simplistic approach, counting each person entering and leaving, estimating the number of people for the day by dividing the total count by two.
• ScoreCard – Not Yet Implemented This class represents a scorecard for tracking bowling scores frame by frame. It produces a final tally for the game, as well as the current score and the current frame.
• Cylinder – The Cylinder class represents a cylindrical object whose height and radius is known. The class provides methods to calculate the volume and surface area.
• Cone – The Cone class represents a conical object whose height and base radius is known. The class provides methods to determine the volume and surface area with this information.
• GravityCalculator – The GravityCalculator provides static methods for determining an object’s weight for the various planets in our solar system, given the equivalent weight as found on Earth.
• CurrencyCalculator – The CurrencyCalculator allows the conversion of US dollars to four other currencies, given the current exchange rate of those currencies.

For these exercises, compare your results with the unit tests for these classes.

Calculator

This exercise expands on the original Calculator class to perform subtraction and division with integers.

Problem Statement

Write the code that will act as a calculator for doing math. This version is a follow-up on the previous prototype; now it should support subtraction and division.

The solution must meet the following requirements:

• Should add two whole numbers.
• Should multiply two whole numbers.
• Should subtract two whole numbers.
• Should divide two whole numbers.

Use the following class diagram when creating your solution.

Fraction

This exercise expands on the original Fraction class to include methods that allow for adding, subtracting, multiplying, and dividing fractions.

Problem Statement

Write the code needed to expand the capabilities of the Fraction class. The class must now support the ability to add, subtract, multiply, and divide fractions as well as allow the individual numerator and denominator values to be seen. The solution must meet the following requirements:

• Should get the string representation of the fraction, as “numerator/denominator”
• Should get the numeric value of the fraction (as a real number)
• Should get the reciprocal of the fraction
• Should get the numerator and denominator
• Should add another fraction to its existing value
• Should subtract another fraction from its existing value
• Should multiply its existing value by another fraction
• Should divide its existing value by another fraction

As an assist, the following code can be used for the multiplication method.

1   public void multiplyBy(Fraction otherFraction)
2   {
3       this.numerator = this.numerator * otherFraction.numerator;
4       this.denominator = this.denominator * otherFraction.denominator;
5   }

Use the following class diagram when creating your solution.

Square

This exercise expands on the original Square class to include a method that determines the diagonal of a square.

Problem Statement

Write the code needed to add the ability for a Square to determine the length of its diagonal. The solution must meet the following requirements:

• Should get and set the length of the side of the square.
• Should calculate the area, perimeter, and diagonal of the square.

Use the following class diagram when creating your solution.

Coordinate

Not Yet Implemented The Coordinate class represents a geographical co-ordinate for either longitude or latitude. A Coordinate’s value can be expressed either as a real number or as degrees, minutes and seconds. It makes use of integer division and overloaded constructors.

Problem Statement

Write the code needed to represent a geographical co-ordinate for longitude and latitude. The solution must meet the following requirements:

• Should get the type of coordinate (such as “longitude” or “latitude”)
• Given the hours, minutes and seconds, it
  
  • should calculate coordinate value as a real number
  • should get hours, minutes, and seconds
• Given the coordinate value as a real number, it
  
  • should calculate the hours, minutes and seconds
  • should get the coordinate value as a real number

Use the following class diagram when creating your solution.

PaintEstimator

The PaintEstimator class is used to estimate the number of paint cans needed for painting a simple room (with or without a window). It makes use of a constant and the Math library; it also uses overloaded constructors.

Problem Statement

Write the code needed to help a painter to estimate the number of paint cans to paint simple rooms (with or without a window). The solution must meet the following requirements:

• Uses a constant value of 8.0 for the paint coverage. (8 square metres per can)
• Should get room height, width, and length
• Should get and set the window’s width and height
• Should calculate the number of paint cans for the room and the window
• Should calculate the surface area to be painted
• The room’s height, length and width should have a private set property.

Use the following class diagram when creating your solution.

BulkItem

The BulkItem class represents products that are available in bulk and shows the cost of individual items. It makes use of rounding (to two decimal places).

Problem Statement

Write the code for the BulkItem class. The solution must meet the following requirements:

• Should get and set the cost and quantity of the bulk item
• Should calculate the cost for each item in the bulk item
• Should properly round values for currency (either the US or Canadian dollar)
• The Quantity property’s set should be private.

Use the following class diagram when creating your solution.

Die

This exercise expands on the original Die class to allow for creating a die of any number of sides, with a default of six sides. This means that there is an overloaded constructor.

Problem Statement

Modify the Die class from the examples to support multi-sided die other than just the standard six sides. The solution must meet the following requirements (new requirements are in bold):

• The Sides and FaceValue properties’ set should be private.
• Should generate a six-sided die by default
• Should get the number of sides of the die
• Should randomly generate each side (if rolled enough); for example, if the die has ten sides, it should eventually roll a 1, 2, 3, 4, 5 6, 7, 8, 9, and 10

Use the following class diagram when creating your solution.

RoundingCalculator

This exercise demonstrates rounding using separate methods for each level of rounding precision.

Problem Statement

Write the code needed to provide rounding of various degrees of accuracy. The solution must meet the following requirements:

• All of the methods should be static.
• Should correctly round up to the nearest thousand
• Should correctly round down to the nearest thousand
• Should correctly round up to the nearest hundred
• Should correctly round down to the nearest hundred
• Should correctly round up to the nearest ten
• Should correctly round down to the nearest ten
• Should correctly round up to the nearest one
• Should correctly round down to the nearest one
• Should correctly round up to the nearest tenth
• Should correctly round down to the nearest tenth
• Should correctly round up to the nearest hundredth
• Should correctly round down to the nearest hundredth

Use the following class diagram when creating your solution.

GenericRoundingCalculator

This exercise demonstrates rounding to the nearest whole number of fractional number using a couple of “generic” methods.

Problem Statement

Write the code needed to perform rounding to either whole numbers or fractions at a specified level of precision. The solution must meet the following requirements:

• All of the methods should be static.
• Should correctly round up or down to the nearest whole number, such as
  
  • the nearest thousand
  • the nearest hundred
  • the nearest ten
  • the nearest one
• Should correctly round up or down to the nearest fractional value, such as
  
  • the nearest tenth
  • the nearest hundredth

Use the following class diagram when creating your solution.

PeopleCounter

This simple class is used to count the number of people who have entered a store in a single day. It takes a simplistic approach, counting each person entering and leaving, estimating the number of people for the day by dividing the total count by two.

Problem Statement

Write the code needed to track people entering and leaving a store. It must be able to estimate the number of people that have entered the store at the end of the day. The solution must meet the following requirements:

• The Count property should have a private set.
• Should default to having a count of zero people when first started up
• Should increment by one (that is, count a single person)
• Should increment by a specified quantity (for when a group of people enter)
• Should adequately estimate the number of people who entered the store, assuming that each person who enters also leaves the store
  
  • Each estimate should be rounded down; for example, if 15 people are counted, then the estimate should be for only 7 (not 7.5 or 8)

Use the following class diagram when creating your solution.

ScoreCard

Not Yet Implemented This class represents a scorecard for tracking bowling scores frame by frame. It produces a final tally for the game, as well as the current score and the current frame.

Problem Statement

Write the code needed to.

The solution must meet the following requirements:

• Should

Use the following class diagram when creating your solution.

### Cylinder

The Cylinder class represents a cylindrical object whose height and radius is known. The class provides methods to calculate the volume and surface area.

Problem Statement

Write the code for the Cylinder class that meets the following requirements:

• The Radius and Height properties should have a private set.
• Should get the radius and the height
• Should calculate the volume and the surface area
  
  • Volume of a Cylinder = pi * r^2 * h$
  • Surface Area of a Cylinder = 2 * pi * r^2 + 2 * pi * r * h$

Use the following class diagram when creating your solution.

Cone

The Cone class represents a conical object whose height and base radius is known. The class provides methods to determine the volume and surface area with this information.

Problem Statement

Write the code for the Cone class that meets the following requirements:

• The Radius and Height properties should have a private set.
• Should get the radius and the height
• Should calculate the volume and the surface area
  
  • Volume of a Cone = 1/3 * pi * r^2 * h$
  • Surface Area of a Cone = pi * r^2 + pi * r * sqrt(r^2 + h^2)$

Note that the portion sqrt(r^2 + h^2)$ is known as the slant height.

Use the following class diagram when creating your solution.

GravityCalculator

The GravityCalculator provides static methods for determining an object’s weight for the various planets in our solar system, given the equivalent weight as found on Earth.

Problem Statement

Write the code needed to convert Earth weights to their equivalent for the other planets in our solar system. The solution must meet the following requirements:

• All the methods should be static.
• Should convert a weight in Earth kilograms to their equivalent weight on
  
  • Mercury
  • Venus
  • Mars
  • Jupiter
  • Saturn
  • Uranus
  • Neptune
• For information on equivalent weights among the planets, see these URLS.
  
  • NinePlanets.org
  • http://www.serve.com/chunter/index/info/aweigh.html

Use the following class diagram when creating your solution.

CurrencyCalculator

The CurrencyCalculator allows the conversion of US dollars to four other currencies, given the current exchange rate of those currencies.

Problem Statement

A currency exchange store at the international airport needs a program to convert from US dollars to four other currencies: Canadian dollar, Euro, Japanese Yen, and the Great Britain Pound. The store uses a set exchange rate for each currency as established at the start of the day. Write the code for a class called CurrencyCalculator to meet this need. The solution must meet the following requirements:

• Should correctly convert US dollars to the
  
  • British Pound (GBP)
  • Canadian Dollar (CAD)
  • Euro (EUR)
  • Japanese Yen (JPY)
• Should use the correct level of precision when making the exchange; each currency uses a different number of significant digits:
  
  • CAD, GBP and EUR use two digits
  • JPY uses three digits

To illustrate the possible exchange rates, please refer to the following images.

Use the following class diagram when creating your solution.

As a starter, you can use the following code to begin creating your class.

 1 public class CurrencyCalculator
 2 {
 3     // The following are multipliers to convert the
 4     // US dollar to different currencies.
 5     /* The multiplier to convert US dollars to Canadian dollars. */
 6     private double _ToCanadian;  // CAD - Canadian Dollar
 7     /* The multiplier to convert US dollars to the Euro. */
 8     private double _ToEuro;      // EUR - Euro
 9     /* The multiplier to convert US dollars to the Japanese Yen. */
10     private double _ToYen;       // JPY - Japanese Yen
11     /* The multiplier to convert US dollars to the British Pound. */
12     private double _ToPound;     // GBP - Great Britain Pound
13     
14     /* The number of significant digits for the Canadian dollar.
15      * The unit for portions of a dollar is the Cent. */
16     private static int _CadDigits = 2; // Cents
17     /* The number of significant digits for the Euro.
18      * The unit for portions of a dollar is the Cent. */
19     private static int _EuroDigits = 2; // Cents
20     /* The number of significant digits for the Japanese Yen.
21      * The unit for 1/100<sup>th</sup> portions of the Yen is the Sen,
22      * while each 1/1000<sup>th</sup> is known as a Rin. */
23     private static int _YenDigits = 3; // 1/100 is sen, 1/1000 is rin
24     /* The number of significant digits for the British Pound.
25      * The unit for portions of a Pound is the Pence (or P). */
26     private static int _PoundDigits = 2; // Pence (or p)
27     
28     /*
29      * This constructor initializes a CurrencyCalculator object
30      * by taking the supplied parameter values and storing
31      * them in the fields of this instance of the class.
32      */
33     public CurrencyCalculator(double toCanadian, double toEuro, double toYen,
34             double toPound)
35     {
36         // Your code goes here...
37     }
38 
39     /* ************** Methods **************** */
40     // Your code goes here...
41 }

Topic F – If-Else Structures

Overview

This topic introduces the if-else control flow statement and demonstrates both simple and complex conditional expressions. This topic will also introduce how to nest program statements.

LOGs

General Programming Concepts and Terms

• Describe and draw a diagram of the If-Then-Else logical structure
• Identify the programming statement that corresponds to the If-Then-Else logical structure
• Translate If-Then-Else structures into code
• Describe what is meant by a “conditional expression”
• List the operator precedence for mixing logical, arithmetic, and relational operations
• List the relational operators
• List the logical operators
• Use relational, logical, and arithmetic operators to construct conditional expressions
• Demonstrate an understanding of operator precedence in conditional expressions
• Use statement blocks to allow nesting program statements into control structures
• Define the term “boundary condition” as it relates to if-else statements and testing
• Identify the correct way to compare or check the contents of strings in conditional expressions
• List and describe the commonly used properties and methods of the String class that would be used in if-else statements

Code Samples

The following examples are used to illustrate this topic.

1. StockItem - This class represents an item that is part of an inventory. The item has an item name, a cost and a profit margin (which can be positive or negative). By using the profit margin, it can derive the price of the item. The class can also report if the item is priced at or below cost.
2. Account - This class illustrates simple if structure in handling withdrawals; withdrawals are only made when the amount does not exceed the balance and the overdraft. It also identifies if the account is overdrawn.
3. Person - This adaptation of the person class checks the age of the person to see if the person’s life stage is infant, toddler, preschooler, school age, or adult.
4. Fraction - This class now ensures that any negative denominators have their negative sign “moved” to the numerator. It also recognizes whether a fraction is proper (numerator less than denominator) or not and provides a method to express the fraction as a mixed number string.
5. Angle - This version of the Angle class includes an attribute to identify the type of the angle as either acute, right, obtuse, straight, reflex, full rotation, or undefined.
6. ParkingCounter - This class represents a simple counter to monitor whether a parking lot is full or not; it tracks vehicles entering and leaving the parking lot and allows the counter to be reset when the lot is full or empty. This class illustrates increment and decrement operators and/or the assignment increment or assignment decrement operators.
7. MemoryAddress - This class represents a single memory address in both its base 10 and hexadecimal value.
8. Color - This class represents a color as three base-10 RGB values and as a single hexadecimal value.

StockItem

This class represents an item that is part of an inventory. The item has an item name, a cost and a profit margin (which can be positive or negative). By using the profit margin, it can derive the price of the item. The class can also report if the item is priced at or below cost.

Problem Statement

Write the code for the StockItem class. The solution must meet the following requirements (new requirements are in bold):

• Should get and set the name, cost and profit margin of the stock item
• Should represent the profit margin as a percent; a value of 45 means 45%
• Should calculate the price of the item, to the nearest cent
  
  • Use the rounding where values under a half-cent are rounded down and values greater than or equal to a half-cent are rounded up
• Should recognize when the stock item is priced at cost (that is, the profit margin is zero)
• Should recognize when the stock item is priced below cost (that is, the profit margin is negative)

Use the following class diagram when creating your solution.

 1   public bool IsPricedAtCost
 2   {
 3       get
 4       {
 5           bool atCost = false;
 6           if (ProfitMargin == 0)
 7               atCost = true;
 8           return atCost;
 9       }
10   }
11 
12   public bool IsPricedBelowCost
13   {
14       get
15       {
16           bool belowCost;
17           if (ProfitMargin < 0)
18               belowCost = true;
19           else
20               belowCost = false;
21           return belowCost;
22       }
23   }

Account

This class illustrates simple if structure in handling withdrawals; withdrawals are only made when the amount does not exceed the balance and the overdraft. It also identifies if the account is overdrawn.

Problem Statement

Write the code that will represent a simple bank account. The solution must meet the following requirements (new requirements are in bold):

• Should get the bank name, branch number, institution number, account number, balance, overdraft limit, and account type and allow the overdraft limit to be set
• Should support deposits
• Should only support withdrawals if the amount does not exceed the sum of the balance and the overdraft limit
• Should identify if the account is overdrawn

Use the following class diagram when creating your solution.

 1   public double Withdraw(double amount)
 2   {
 3       if (amount <= Balance + OverdraftLimit)
 4           Balance = Balance - amount;
 5       else
 6           amount = 0;
 7       return amount;
 8   }
 9 
10   public bool IsOverdrawn
11   {
12       get
13       {
14           bool overdrawn;
15           if (Balance < 0)
16               overdrawn = true;
17           else
18               overdrawn = false;
19           return overdrawn;
20       }
21   }

Person

This adaptation of the person class checks the age of the person to see if the person’s life stage is infant, toddler, preschooler, school age, or adult.

Problem Statement

Write the code that will represent a person with a first and last name and a date of birth. The solution must meet the following requirements (new requirements are in bold):

• Should get and set the first and last name
• Should get the birth date
• Should get the person’s approximate age (which is the age that the person will turn to in the current year)
• Should override ToString() to get the person’s full name (as first name then last name)
• Should get the life stage, based on the following table

Use the following class diagram when creating your solution.

 1   public string LifeStage
 2   {
 3     get{
 4       string stage;
 5       if (Age == 0)
 6           stage = "infant";
 7       else if (Age < 3)
 8           stage = "toddler";
 9       else if (Age < 5)
10           stage = "preschooler";
11       else if (Age < 18)
12           stage = "school age";
13       else
14           stage = "adult";
15       return stage;
16     }
17   }