OOP Class7

esse quam videri
Revision as of 15:53, 17 June 2008 by Jeff (talk | contribs)
Jump to: navigation, search

Shared Members - static members

aka Shared Properties

Static - A type of member modifier that indicates that the member applies to the type rather than an instance of the type

<csharp>public class Dog { //some code

static private int dogCount; // total number of dogs

public Dog() { barkSound = "Woof!!!"; //Add a dog to the total dog count dogCount++; } public Dog(string newName) { name = newName; barkSound = "Woof!!!"; //Add a dog to the total dog count dogCount++; }</csharp>

Static dougCount Example
dogStatic.cs - source


public +

most permissive access. No restrictions on access

private -

least permissive access level. Only available to the class in which it was declared

protected #

accessible within its class and by derived classes


accessible only within files in the same assembly

protected internal

combination of protected and internal

Public Dog DogSimpleUML.png

Dog with private age DogsimpleAgePrivate.png

Private instance data members - accessors

Microsoft has stared calling private variables with accessors Properties

Private class memebers the use get and set keyword to set and retrieve data. Get and set are known as accessor methods private members are helpful when you want to also do other things when a data member is changed or change the rutern value under certain conditions. C# Programmer's Reference - Accessors http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csref/html/vclrfaccessorspg.asp. Lastly accessor also make read only and write only variables possible

<csharp>//private string color read/write private string color;

public string Color {

  return color;
  color = value;


//private string color read only private string color;

public string Color {

  return color;


Another property that is a good candidate for a private instance data member is the dogs age

<csharp> private string age;

public int Age {

 //age can only be accessed with get there is no set accessor
 //age must be set with HappyBirthday()
  return age;


public int HappyBirthday() {

 return age;



In class

In Class Project

*Build a Dog class with a private variable called age.
*Make a public Accessor for the private age the is read only
*Make a method that increments the age of your dog
*Make a test class for the new property and accessor

Here's a class of dogs that return different color depending on whether on not they are clean. It uses private private instance data members

OOP Arrays

Fancy Arrays


Regular Array objects are like list collections

Arrays are groups of variables of the same type

        type [] identifier

single dimension arrays

<csharp>string [] aryNames = new string[5];

aryNames [0] = "Feta"; aryNames [1] = "Colby"; aryNames [2] = "Gruyere"; aryNames [3] = "Edam"; aryNames [4] = "Colby";</csharp>

Arrays are actually objects and support various methods.

  • GetValue
  • IndexOf
  • LastIndexOf
  • SetValue
  • Reverse
  • Sort


<csharp>string s = aryNames.GetValue(1).ToString();</csharp>



<csharp>int i = Array.IndexOf(aryNames, "Colby");</csharp>



<csharp>int Lasti= Array.LastIndexOf(aryNames, "Colby");</csharp>


SetValue <csharp>

   aryNames.SetValue("Gouda", 1);
   string setValue = aryNames.GetValue(1).ToString();</csharp>

Now Array(1) == "Gouda"


Reverse reverses the array


The Reversed array looks like Reverse

0 Colby
1 Edam
2 Gruyere
3 Gouda
4 Feta


The Sort method sort the array. Arrays are sorted accourding to how objects compare to each other usually implemented using the IComparer interface


The Sorted Array List Looks like

0 Colby
1 Edam
2 Feta
3 Gouda
4 Gruyere

Array Example 2


Pros and Cons of working with arrays pros

  • East to use
  • Fast to alter
  • Flast to iterate though
  • Specific type of elements ( single type)


  • Fixed size
  • Insterting is difficult


Collections are groups of objects. types of collections

   * set - no index
   * list - has index
   * map - has key/value pair

Set is like storing a bunch of objects in a bag. The order they are removed from the bag has nothing to do with the order they are removed. Set collections do not have a unique identifier.

List types of collections have an integer for an indexer. This gives them a unique identifier and an order.

Map types also have an index but it is not necessarily an integer. It could be anything unique.


The Array List of now part of System.Collections. In order to user it you must add a using statement <csharp>using System.Collections;</csharp>

create an arraylist

<csharp>ArrayList myArrayList = new ArrayList();</csharp>

add and element or two <csharp> myArrayList.Add("Feta"); myArrayList.Add("Colby"); myArrayList.Add("Gruyere"); myArrayList.Add("Edam"); myArrayList.Add("Colby"); </csharp> This produces and Array list like


Insert an element


Now our ArrayList Looks like


Remove an element

<csharp>//remove by index myArrayList.RemoveAt(1); //remove by data myArrayList.Remove("Colby"); //removes first occurance of Colby </csharp>

Now our Array List looks like


Pros and con of ArrayList Pros

  • No fixed size
  • Insert and Remove


  • Slower than arrays
  • Inefficient with memory (when the array size exceeds the upper bound .NET doubles the size of the array.

ArrayList Example



Arrays and Collections of objects allow for polymorphism.


<csharp>foreach (string n in aryNames) {



Pair Programming

Pair Programming

We are going to pair off to do our next assignment. Many of the paired programming principles come from XP (http://www.extremeprogramming.org/ Extreeme Progamming)

Pairs are good because

  • Pairs keep each other on track
  • A partner can help when you are stuck
  • Keep each other accountable

Some XP Principles

Fail - If you are having trouble succeeding fail.

Baby Steps - Do the smallest thing that you possible can that moves you in the right direction

If you do decide to dive and conqure the problem please remember that integration process is unpredictable and can be quite difficult. Try to integrate your code often. Try posting up your code and emailing or plan on meeting several times.

When two pair programmers are together one you should sit a one computer (yeah that right two of you at one computer) and one should type while the other watches and reflects. Feel free to slide the keyboard back and forth when someone get tired, stuck or has a new idea.

I would like you and your paired partner to create and demonstate classes in c# from the diagram below.