Chapter 9

Classes and Multiform Projects

 Topics

9.1 Introduction to Classes

9.2 Properties
9.3 Parameterized Constructors and Overloading
9.4 Storing Class Type Object in Arrays and Lists
9.5 Finding the Classes and Their Responsibilities in a
Problem
9.6 Creating Multiple Forms in a Project

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 9.1 Introduction to Classes

A class is the blueprint for an object.

It describes a particular type of object, yet it is
not an object.
It specifies the fields and methods a particular
type of object can have.
One or more object can be created from the
class.
Each object created from a class is called an
instance of the class.

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Creating a Class

You can create a class by writing a class declaration. A generic

form is:
class className // class header
{
Member declaration(s)
}

Class headers starts with the keyword class, followed by the name
of the class.
Member declarations are statements that define the classs fields,
properties, and/or methods.
A class may contains a constructor, which is special method
automatically executed when an object is created.

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Sample Code
class Coin
{
private string sideUp; // field

public Coin() // constructor

{
sideUp = Heads;
}

public void Toss() // a void method

{
MessageBox.Show(sideUp);
}

public string GetSideUp() // a value-returning method

{
return sideUp;
}
}

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Creating an Object

Given a class named Coin, you can create a Coin object

use:
Coin myCoin = new Coin();

where,
myCoin is a variable that references an object of the Coin class;
the new keyword creates an instance of the Coin class; and
the = operator assigns the reference that was returned from the
new operator to the myCoin variable.
Once a Coin object is created, you can access members
of the class with it. E.g.
myCoin.Toss();

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Where to Write Class
Declarations
In C# you have flexibility in choosing where to write class
declarations. E.g.
To create the Coin class, you can:
Save the class declaration is a separated .cs file; or
Add the Coin class next to the Form1 class inside the Form1.cs file.
Namespace Example
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
.
}
class Coin
{
.
}
}
Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Passing an Object to a Method

Objects of a class can be used as parameter of a

method. E.g.
private void ShowCoinStatus(Coin coin)
{
MessageBox.Show(Side is + coin.GetSideUp());
}

In this example, a method named ShowCoinStatus

accepts a Coin object as an argument.
To create a Coin object and pass it as an argument to
the ShowCoinStatus method, use:
Coin myCoin = new Coin();
ShowCoinStatus(myCoin);

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 9.2 Properties

A property is a class member that holds a piece of data

about an object.
Properties can be implemented as special methods that set and
get the value of corresponding fields. class Pet
{
Both set and get methods are known private string _name; // backing field
public Pet()
as accessors. {
_name = ;
In the code, there is a private field (_name) }

which is a known as backing field and is public string Name

{
used to hold any data assigned to the get
{
Name property. return _name;
}
The value parameter of set accessor is set
{
automatically created by the compiler. _name = value;
}
}
}
Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Setting the myDog objects Name
Property to Fido
// Name property
public string Name
{ Pet object
get
{ Fido
_name
return _name;
myDog.Name = Fido; }

set
{
_name = value;
}
}

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 The Backing Field

The private backing field is a variable

that stores a value assigned to the
property which the backing fields is
associated with.
It is declared to be private to protect it from
accidental corruption.
If a backing field is public, it can then be
accessible directly by code outside the
class without the need for accessors.
Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 get vs set Accessors

The get accessor, if not empty, is a

method that returns the propertys value
because it has a return statement.
It is executed whenever the property is read.
The set accessor, if not empty, gets the
value stored in the backing field and
assigns the value to the property
It has an implicit parameter named value.
It is executed whenever a value is assigned to
the property.
Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Read-Only Properties

A read-only property can be read, but it cannot be

modified.
To set a read-only property, simply do no write a set accessor for
the property. E.g.
// read and write // read-only
public double Diameter public double Diameter
{ {
get { return _diameter; } get { return _diameter; }
set { _diameter = value; } }
}

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 9.3 Parameterized Constructor &
Overloading
A constructor that accepts arguments is known as parameterized
constructor. E.g.
public BankAccount(decimal startingBalance) { }

A class can have multiple versions of the same method known as

overloaded methods.
How does the compiler know which method to call?
Binding relies on the signature of a method which consists of the
methods name, the data type, and argument kind of the methods
parameter. E.g.
public BankAccount(decimal startingBalance) { }
public BankAccount(double startingBalance) { }

The process of matching a method call with the correct method

is known as binding.

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Overloading Methods

When a method is overloaded, it means that multiple

methods in the same class have the same name but use
different types of parameters.

public void Deposit(decimal amount) { }

public void Deposit(double amount) { } // overloaded
public void Deposit(int numbers) { } // overloaded
public void Deposit(string names) { } // overloaded

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Overloading Constructors

Constructors are special type of methods. They can also

be overloaded.
public BankAccount() { } // parameterless constructor
public BankAccount(decimal startingBalance) { } // overloaded
public BankAccount(double startingBalance) { } // overloaded

The parameterless constructor is the default constructor

Compiler will find the matching constructors

automatically. E.g.
BankAccount account = new BankAccount();
BankAccount account = new BankAccount(500m);

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 9.4 Storing Class Type Objects in
Array & Lists
Objects that are instances of a class can be
stored in an array. E.g.
Const int SIZE = 4;
CellPhone[] phone = new CellPhone[SIZE];
phone[0] = new CellPhone();
phone[1] = new CellPhone();
.

You can use a loop to step through the

array. E.g.
for (int index = 0; index < phone.Length; index++)
{
phones[index] = new CellPhone();
}
Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Initializing Array Elements

You can initialize the array elements in the declaration

statement:
CellPhone[] phone = {
new CellPhone(), new CellPhone(),
new CellPhone(), new CellPhone()
};

You can also initialize an array and assign its elements

with references to a class. E.g.
BankAccount[] accounts = {
new BankAccount(1000),
new BankAccount(2000),
new BankAccount(3000),
new BankAccount(4000),
};

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Lists of Class Type Objects

You can create a List to hold a class object. E.g.

List<CellPhone> phoneList = new List<CellPhone>();

This statement creates a List object, referenced by the phoneList

variable.
Each object of the CellPhone class needs an instance of
CellPhone class to hold data. E.g.
CellPhone myPhone = new CellPhone();
myPhone.Brand = Acme Electronics;
myPhone.Model = M1000;
myPhone.Price = 199;

To add the Cellphone object to the List, use:

phoneList.Add(myPhone);

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 9.5 Finding the Classes & their
Responsibilities in a Problem
When developing an object-oriented program, you need to identify
the classes that you will need to create.
One simple and popular techniques involves the following steps:
Get a written description of the problem domain.
Identify all the nouns (including pronouns and noun phrases) in the
description. Each of these is a potential class.
Refine the list to include only the classes that are relevant to the
problem.
Once the classes have been identified, you need to identify each
classs responsibilities. The responsibilities are:
The things that the class is responsible for knowing
The actions that the class is responsible for doing

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Example
In the textbook, there are three classes: Customer, Car, and
ServiceQuote.
The Customer class has the following actions:
Create and initialize an object of the Customer class.
Get and set the customers name.
Get and set the customers address.
Get and set the customers telephone number.
The Car class has the following actions:
Create and initialize an object of the Car class.
Get and set the cars make.
Get and set the cars model.
Get and set the cars year.
The ServiceQuote class has the following actions:
Create and initialize an object of the ServiceQuote class.
Get and set the estimated parts charges.
Get and set the estimated labor charges.
Get and set the sales tax rate.
Get the sales tax.
Get the total estimated charges.

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 9.6 Creating Multiple Forms in a
Project
Every project that has a form in a Visual C# has a class.
The default name of the form is Form1 and its class is also
named Form1 which is stored in the Form1.cs file.
A Visual C# project can have multiple forms.
Each form has its own class that can be instantiated and
displayed on the screen.
When you add additional forms to a project, you add
additional classe(s), which are stored in their own files.
When you create event handler for a specific forms
controls, you write them as methods in the forms class.

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Displaying a Form

To display a form in your application, you need to create an instance

of the forms class. E.g.
ErrorForm myErrorForm = new ErrorForm();

The above code:

declares a reference variable named myErrorForm;
creates an object of the ErrorForm class in memory; and
assigns a reference to the object to the myErroForm variable.
After creating the instance, use ShowDialog method to display the
form. E.g.
myErrorForm.ShowDialog();

The ShowDialog method displays a form on the screen and it gives

that form the focus.

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Accessing Control on a Different
Form
Controls provided by the .NET Framework have public access, even
when they are placed on a form.
Code that is outside the forms class can still have access to these
controls.
For example, you can create an instance of GreetingsForm, yet
assign a value to a Label control of another form.

GreetingsForm greetingsForm = new GreetingsForm();

greetingsForm.messageLabel.Text = Good day!;
greetingsForm.ShowDialog();

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Modal and Modeless Forms

A modal form or dialog box must be closed or hidden

before you can continue working with the rest of the
application.
When a modal form is displayed, no other form in the
application can receive the focus until the modal form is closed.

A modeless form allows the user to switch focus to

another form while it is displayed.
The user does not have to close a modeless form to switch focus
to another form.

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.
 Flow of Executions

In a modal form, statement In a modeless form,

next to the ShowDialog statement next to the Show
method will not execute until method will execute
the modal form is closed. E.g. immediately after the
modeless form is displayed.
statement;
E.g.
statement;
messageForm.ShowDialog();
statement;
statement;
statement;
statement; // not executed
messageForm.ShowDialog();
statement;
statement;
statement; // executed
statement;

Module Code and Module Title Title of Slides Copyright 2014 Pearson Education, Inc.