1. Lecture 13
Writing Classes
Richard Gesick

2. Topics Adding a Class to a Project Defining a Class Using a Class
Attributes
Methods
Using a Class
Visibility
Instance Variables
Properties

3. Multiple Classes in a Project
adding classes to our project
Keep them all in one file (~bad choice)
One class per file (better choice)

4. Why User-Defined Classes?
Primitive data types (int, double, char, .. ) are great … … but in the real world, we deal with more complex objects: products, Web sites, flight records, employees, students, .. Object-oriented programming enables us to manipulate real-world objects.

5. User-Defined Classes
Combine data and the methods that operate on the data
Advantages:
Class is responsible for the validity of the data.
Implementation details can be hidden.
Class can be reused.
Client of a class
A program that instantiates objects and calls methods of the class

7. Classes A class can contain data declarations and method declarations
int size, weight;
char category;
Data declarations
Method declarations

8. Important Terminology
Fields
instance variables: data for each object
class data: static data that all objects share
Members
fields and methods
Access Modifier
determines access rights for the class and its members
defines where the class and its members can be used

9. Using the Class Before we define the Die class, let’s use it
Remember that OOP allows us to ignore the “guts” and just presume it works
There are 3+ categories of people involved
The writer of the class (knows what the “guts” are)
The user of the class, writing the main program (knows his code, but doesn’t know the class “guts”)
The user of the program – sees the interface, doesn’t see program code at all

10. The “User” of a Class
Recall we don’t want to have to expose the “guts”
But we do need to tell a user of our class what it can do and what they have access to
Define the API of the class

11. The Die Class API Die() Default constructor, sets sides to 6
Die(int s)
Overloaded constructor, sets sides to s
int roll()
Returns a value from 1 to sides
int Sides
Property for sides with get and set
string ToString()
The overridden ToString method

12. Die UML
Die -sides: int -rand:Random +Die(): +Die(int): +roll():int +ToString():string

13. using System;
//gesick
namespace L13_DiceClassDemo {
class Program
static void Main(string[] args)
Die d = new Die();
Die d2 = new Die();
int num = 0;
int num2 = 0;
for (int i = 1; i <= 5; i++)
num = d.Roll();
Console.WriteLine);
num2 = d2.Roll();
Console.WriteLine(("d1 " + num +“ d2 " + num2); }

14. d2.Sides = 50;
Console.WriteLine(d2);
for (int i = 1; i <= 5; i++) {
num = d.Roll();
num2 = d2.Roll();
Console.WriteLine("d1 " + num + "\td2 "+ num2 +"\tdice 2 sides = " d2.Sides);
d2.Sides += 10; }
Console.WriteLine(d2.ToString());

15. The output
d1 3 d2 1 d1 2 d2 5 d1 2 d2 6 d1 6 d2 3 d1 1 d2 3 class die, number of sides is 50 d1 5 d2 26 dice 2 sides = 50 d1 1 d2 28 dice 2 sides = 60 d1 3 d2 50 dice 2 sides = 70 d1 3 d2 10 dice 2 sides = 80 d1 4 d2 17 dice 2 sides = 90 class die, number of sides is 100

16. The Die At this point, what do you know about Die from the code?
You can “Roll()” it
It has a number of sides
You can make 2 different dice
It has a ToString method
You can change the number of sides
Now let’s look at the guts…

17. Die Class with a static variable
namespace L13_DiceClassDemo {
/// <summary>
/// uses a random number generator to simulate rolls on a die, values 1 to sides
/// </summary>
public class Die
private static Random r;
private int sides;
/// default, creates a 6 sided die
public Die()
sides = 6;
r = new Random(); }

18. Die Class (cont) /// <summary>
/// overloaded, creates a s sided die
/// </summary>
/// <param name="s">the number of sides for the die</param>
public Die(int s) {
sides = s;
r = new Random(); }
/// returns a random value, 1 to sides
/// <returns>the generated random number</returns>
public int Roll()
return r.Next(sides) + 1;

19. Die Class (cont) /// <summary>
/// sides property with get and set
/// </summary>
public int Sides {
get { return sides; }
set { sides = value; } }
/// returns the class name and number of sides of the die object
/// <returns></returns>
public override string ToString()
return "class die, number of sides is " + sides;

20. Visibility OO motivation: protection/security
We need a way of selectively “publishing” parts of a class and “hiding” other parts of the class
Public & private

21. public vs. private
Instance variables are usually declared to be private
Methods that will be called by the client of the class are usually declared to be public
Methods that will be called only by other methods of the class are usually declared to be private
APIs of methods are published (made known) so that clients will know how to instantiate objects and call the methods of the class

22. Visibility Example Method are typically public
class BMW_Z4 {
private int ModelYear;
public string LicensePlate;
private bool TopUp;
public void Drive() {
Console.WriteLine("Roadin’ and Rockin’"); }
public void OpenTop()
TopUp = false;
Note the visibility (attributes will usually be private)
Method are typically
public

23. Object Method & Attribute Visibility
BMW_Z4 myCar; myCar = new BMW_Z4(); myCar.LicensePlate = "BMR4ME"; myCar.ModelYear = 2004; myCar.Drive(); myCar.OpenTop();
Illegal b/c private

24. Interacting with Objects
Keep private/public visibility as needed

25. Visibility

26. Defining Instance Variables
Syntax: accessModifier dataType identifierList;
dataType can be primitive date type or a class type
identifierList can contain:
one or more variable names of the same data type
multiple variable names separated by commas
initial values
Optionally, instance variables can be declared as const

27. Examples of Instance Variable Definitions
private string name = ""; private const int PERFECT_SCORE = 100, PASSING_SCORE = 60; private int startX, startY, width, height;

28. The Auto Class
class Auto { private string model; private int milesDriven; private double gallonsOfGas; }

29. Properties Combines field/attribute with method Standard:
Make attributes private
Lower-case first letter of attribute
Make properties public
Upper-case first letter of properties
Define “get” and “set” for each property (selectively)

30. Properties Example class BMW_Z4 { private string licensePlate;
private int modelYear;
private string licensePlate;
private bool topUp;
public int ModelYear {
get { return modelYear; }
set { if (value >= 2003) modelYear = value; } }
public string LicensePlate
get { return licensePlate; }
set { if (value.Length() == 6) licensePlate = value; }
} ...

31. Auto Properties
Now how would you write the properties for the Auto class?
class Auto {
private string model;
private int milesDriven;
private double gallonsOfGas; }