CSCI 3005 ObjectOriented Programming

1
CSCI 3005Object-Oriented Programming

• Chapter 3 C Language Fundamentals
• Part 1

2
Outline

• A Simple C Program
• Classes and Objects
• System.Console Class
• Member and Type Visibility
• Default Values, Local Variables, and
  Initialization
• Constant Data and Read-Only Fields
• static Keyword
• Static Methods, Data, Constructors, and Classes
• Method Parameter Modifiers
• Default, out, ref, and params Modifiers
• Iteration Constructs
• for, foreach, while and do/while loops
• Decision Constructs and Relational Operators
• if/else and switch statements

3
A Simple C Program

• C files end with a .cs file extension
• C is case-sensitive
• Type class, interface, structure, enumeration,
  delegates

using System class HelloClass public static
int Main(string args)
Console.WriteLine(Hello World!)
Console.ReadLine() return 0
declarations
// no semi-colon needed
4
Variations on the Main() Method
// Integer return type, array of strings as
argument. public static int Main(string
args)
// No return type, array of strings as
argument. public static void Main(string
args)
// No return type, no arguments. public static
void Main()
// Integer return type, no arguments. public
static int Main()
5
Processing Command-Line Arguments
using System class HelloClass public static
int Main(string args)
Console.WriteLine(" Command line args
") for (int i 0 i lt args.Length
i) Console.WriteLine("Arg 0",
argsi) ...
6
Defining Classes and Creating Objects

• A class is a definition (blueprint) for a
  user-defined type (UDT).
• An object is a term describing a given instance
  of a particular class.
• C uses the new keyword to create an object.
• Unlike C, C does not allow allocation of an
  object on the stack,
• i.e., the object must be new-ed.

class HelloClass public static int
Main(string args) // Error! Use of
unassigned local variable! Must use 'new'.
HelloClass c1 c1.SomeMethod() ...
7
Defining Classes and Creating Objects
class HelloClass public static int
Main(string args) // You can declare
and create a new object in a single line...
HelloClass c1 new HelloClass() //
...or break declaration and creation into two
lines. HelloClass c2 c2 new
HelloClass() ...
8
Constructors

• Named identically to the class, no return value
  (not even void)
• Every class is automatically provided a free
  default constructor.
• All members are set to their default values,
  unlike C where uninitialized data points to
  garbage.
• The default constructor is removed when a custom
  constructor is defined.

class HelloClass public string userMessage
// Constructors always assign state data to
default values. public HelloClass()
Console.WriteLine("Default ctor called!")
// This custom constructor assigns state data to
a known value. public HelloClass(string msg)
Console.WriteLine("Custom ctor called!")
userMessage msg
9
Constructors

• The .NET garbage collector frees the allocated
  memory automatically
• C does not support a delete keyword.

public static int Main(string args) // Call
default constructor. HelloClass c1 new
HelloClass() Console.WriteLine(Value of
userMessage is 0\n", c1.userMessage) //
Call parameterized constructor. HelloClass c2
c2 new HelloClass("Testing, 1, 2, 3")
Console.WriteLine("Value of userMessage is
0\n", c2.userMessage)
10
Defining an Application Object

• Split current HelloClass into two classes
• HelloApp that contains the Main() Method
• HelloClass that contains the declarations
• Separation of Concerns
• A class should be responsible for the least
  amount of work

class HelloApp public static int
Main(string args) HelloClass c1 new
HelloClass("Hey there...")
c1.PrintMessage() ...
11
Defining an Application Object
class HelloClass public string userMessage
// Constructors always assign state data to
default values. public HelloClass()
Console.WriteLine("Default ctor called!")
// This custom constructor assigns state data to
a known value. public HelloClass(string msg)
Console.WriteLine("Custom ctor called!")
userMessage msg public void
PrintMessage() Console.WriteLine("Message is
0\n", c2.userMessage)
12
Formatting Console Output

• .NET introduces a new style of string formatting,
  slightly reminiscent of the C printf() function,
  but without the cryptic d, s, or c flags.

static void Main(string args) ... int
theInt 90 double theDouble 9.99 bool
theBool true // The '\n' token in a string
literal inserts a newline. Console.WriteLine("In
t is 0\nDouble is 1\nBool is 2",
theInt, theDouble, theBool)
13
Member Visibility
14
Member Visibility
class SomeClass // Accessible anywhere.
public void PublicMethod() // Accessible
only from SomeClass types. private void
PrivateMethod() // Accessible from
SomeClass and any descendent. protected void
ProtectedMethod() // Accessible from
within the same assembly. internal void
InternalMethod() // Assembly-protected
access. protected internal void
ProtectedInternalMethod() // Unmarked
members are private by default in C. void
SomeMethod()
15
Member Visibility
class Program static void
Main(string args) //
Make an object and attempt to call members.
SomeClass c new SomeClass()
c.PublicMethod() c.InternalMethod()
c.ProtectedInternalMethod() //
c.PrivateMethod() // Error! //
c.ProtectedMethod() // Error! //
c.SomeMethod() // Error!
Console.ReadLine()
16
Default Values and Local Variables

• The member variables are automatically set to a
  default value

class Test public int myInt // Set to 0
public double myDouble // Set to 0.0 public
char myChar // Set to \0 public bool
myBool // Set to false public string
myString // Set to null public object
myObj // Set to null

• You must assign an initial value to local
  variables before use them

// Compiler error! Must assign // 'localInt' to
an initial // value before use. static void
Main(string args) int localInt
Console.WriteLine(localInt)
// Better everyone is happy. static void
Main(string args) int localInt 0
Console.WriteLine(localInt)
17
Member Variable Initialization

• C allows to assign member variable to an initial
  value at the time of declaration
• Note that C does not allow you to do so.
• It is useful when you dont want to accept the
  default values and would rather not write the
  same initialization code in each constructor.

class Test public int myInt 9 public
string myString I am A String. public
SportsCar viper new SportsCar(Color.Red)
...
18
Defining Constant Data

• The const keyword define variables with a fixed,
  unalterable value.
• Unlike C, the const keyword in C can not be
  used to qualify parameters or return values

class ConstData // The value of a const must
be known at compile time. public const string
BestNbaTeam "Timberwolves" public const
double SimplePI 3.14 public const bool
Truth true public const bool Falsity
!Truth
19
Referencing Constant Data

• Constant fields are implicitly static.
• prefix the defining type name when referencing a
  constant defined externally
• dont need the prefix if the constant data is
  defined in the current type

class Program public const string
BestNhlTeam "Wild" static void
Main(string args) // Print const values
defined by other type. Console.WriteLine("Nba
const 0", ConstData.BestNbaTeam)
Console.WriteLine("SimplePI const 0",
ConstData.SimplePI) Console.WriteLine("Truth
const 0", ConstData.Truth)
Console.WriteLine("Falsity const 0",
ConstData.Falsity) // Print member
level const. Console.WriteLine("Nhl const
0", BestNhlTeam) // Print local-scoped
const. const int LocalFixedValue 4
Console.WriteLine("Local const 0",
LocalFixedValue) Console.ReadLine()
20
static Keyword

• C class members defined using static keyword
  must be invoked directly from the class level,
  rather than from a type instance.
• e.g., System.Console

// Error! WriteLine() is not an instance level
method! Console c new Console() c.WriteLine("I
can't be printed...")

• but instead simply prefix the type name to the
  static WriteLine() member

// Correct! WriteLine() is a static
method. Console.WriteLine("Thanks...")
21
Static Methods

• Static members can operate only on other static
  members.

class Teenager private static Random r new
Random() private static int GetRandomNumber(sho
rt upperLimit) return r.Next(upperLimit)
public static string Complain() string
messages new string5 "Do I have to?",
"He started it!", "I'm too tired...",
"I hate school!", "You are sooo wrong."
return messagesGetRandomNumber(5)
static void Main(string args) for (int i
0 i lt 10 i) Console.WriteLine("-gt 0",
Teenager.Complain())
22
Static Data

• When a class defines nonstatic data, each object
  of this type maintains a private copy of the
  field
• Static data is allocated once and shared among
  all object instances of the same type

class SavingsAccount public double
currBalance public static double
currInterestRate 0.04 public
SavingsAccount(double balance)
currBalance balance
23
Static Data
static void Main(string args) // Each
SavingsAccount object maintains a copy of the
currBalance SavingsAccount s1 new
SavingsAccount(50) SavingsAccount s2 new
SavingsAccount(100) SavingsAccount s3 new
SavingsAccount(10000.75)
24
Static Data Updated Example
class SavingsAccount public double
currBalance public static double
currInterestRate public SavingsAccount(doubl
e balance) currBalance balance //
Static methods to get/set interest rate. public
static void SetInterestRate(double newRate)
currInterestRate newRate public
static double GetInterestRate() return
currInterestRate // Instance methods to
get/set current interest rate public void
SetInterestRateObj(double newRate)
currInterestRate newRate public double
GetInterestRateObj() return currInterestRate

25
Static Data Updated Example
static void Main(string args)
Console.WriteLine(" Fun with Static Data
") SavingsAccount s1 new
SavingsAccount(50) SavingsAccount s2 new
SavingsAccount(100) // Get and
set interest rate. Console.WriteLine("Interest
Rate is 0",
s1.GetInterestRateObj()) s2.SetInterestRateObj(
0.08) // Make new object, this does NOT
'reset' the interest rate. SavingsAccount s3
new SavingsAccount(10000.75)
Console.WriteLine("Interest Rate is 0",
SavingsAccount.GetInterestRate())
Console.ReadLine()
26
Static Constructors

• We will get into trouble if we assign the value
  to a piece of static data within an
  instance-level constructor
• The value is reset each time we create a new
  object

class SavingsAccount public double
currBalance public static double
currInterestRate public SavingsAccount(double
balance) currBalance balance
currInterestRate 0.04 ...
27
Static Constructors
class SavingsAccount ... // Static
constructor. static SavingsAccount()
Console.WriteLine("In static ctor!")
currInterestRate 0.04

• A given class (or structure) may define only a
  single static constructor.
• A static constructor executes exactly one time,
  regardless of how many objects of the type are
  created.
• A static constructor does not take an access
  modifier and cannot take any parameters.
• The runtime invokes the static constructor when
  it creates an instance of the class or before
  accessing the first static member invoked by the
  caller.
• The static constructor executes before any
  instance-level constructors.

28
Static Classes

• If you create a class that contains nothing but
  static members and/or constant data, the class
  has no need to be allocated in the first place.

// Static classes can only // contain static
members and constant fields. static class
UtilityClass public static void PrintTime()
Console.WriteLine(DateTime.Now.ToShortTimeString
()) public static void PrintDate()
Console.WriteLine(DateTime.Today.ToShortDateString
())
static void Main(string args)
UtilityClass.PrintDate() // Compiler error!
Can't create static classes. UtilityClass u
new UtilityClass() ...
29
Method Parameter Modifiers

• C provides a set of parameter modifiers that
  control how arguments are sent into (and returned
  from) a given method.

30
The Default Parameter-Passing

• Arguments are passed by value by default, i.e., a
  copy of the variable is passed into the method.

// Arguments are passed by value by
default. public static int Add(int x, int y)
int ans x y // Caller will not see these
changes as you are modifying // a copy of the
original data. x 10000 y 88888 return
ans
static void Main(string args) int x 9, y
10 Console.WriteLine("Before call X 0,
Y 1", x, y) Console.WriteLine("Answer is
0", Add(x, y)) Console.WriteLine("After
call X 0, Y 1", x, y)
31
The out Modifier

• A method with output parameters must assign them
  a value.

// Output parameters are assigned by the
member. public static void Add(int x, int y, out
int ans) ans x y public static void
Main() // Use 'out' keyword (no need to
assign because it is an out). int ans
Add(90, 90, out ans) Console.WriteLine("90
90 0\n", ans)
32
The out Modifier

• The out modifier allows the caller to receive
  multiple return values from a single method
  invocation.

// Returning multiple output parameters. public
static void FillTheseValues(out int a, out string
b, out bool
c) a 9 b "Enjoy your string..." c
true public static void Main() // Calling
method with multiple output params. int i
string str bool b FillTheseValues(out i, out
str, out b) Console.WriteLine("Int is 0",
i) Console.WriteLine("String is 0", str)
Console.WriteLine("Boolean is 0", b)
33
The ref Modifier

• Reference parameters allows a method to change
  the value of data declared in the callers scope
  (e.g., swapping, sorting).
• Output parameters do not need to be initialized
  before they passed to the method.
• The method must assign output parameters before
  exiting.
• Reference parameters must be initialized before
  they are passed to the method.
• We are passing a reference to an existing
  variable.
• If we dont assign it to an initial value, that
  would be the equivalent of operating on an
  unassigned local variable.

34
The ref Modifier
// reference parameter. public static void
SwapStrings(ref string s1, ref string s2)
string tempStr s1 s1 s2 s2
tempStr public static void Main() // Swap
some string data. Console.WriteLine("
Swapping two strings ") string s
"First string" string s2 "My other string"
Console.WriteLine("Before 0, 1", s,
s2) SwapStrings(ref s, ref s2)
Console.WriteLine("After 0, 1", s, s2)
35
The params Modifier

• Allows a method to receive a set of identically
  typed arguments as a single logical parameter.

// Return average of some number of
doubles. static double CalculateAverage(params
double values) double sum 0 for (int i
0 i lt values.Length i) sum
valuesi return (sum / values.Length)

• This method has been defined to take a parameter
  array of doubles.
• What this method is in fact saying is, Send me
  any number of doubles and Ill compute the
  average.

36
The params Modifier
public static void Main() // Pass in a
comma-delimited list of doubles... double
average average CalculateAverage(4.0, 3.2,
5.7) Console.WriteLine("Average of 4.0, 3.2,
5.7 is 0", average) // ...or pass an
array of doubles.. double data 4.0, 3.2,
5.7 average CalculateAverage(data)
Console.WriteLine("Average of data is 0",
average) Console.ReadLine()

• If we did not make use of the params modifier in
  the definition of CalculateAverage(), the first
  invocation of this method would result in a
  compiler error).

37
Iteration Constructs

• Iteration
• To repeat blocks of code until a terminating
  condition has been met.
• for loop
• foreach/in loop
• while loop
• do/while loop

// A basic for loop. static void Main(string
args) // Note! 'i' is only visible within the
scope of the for loop. for(int i 0 i lt 10
i) Console.WriteLine("Number is 0 ",
i) // 'i' is not visible here.
38
The foreach Loop

• Specialized foreach loop provided for collections
  like array
• without the need to test for the arrays upper
  limit.
• reduces risk of indexing error

static void Main(string args) string
books "Complex Algorithms",
"Do you Remember Classic COM?",
"C and the .NET Platform" foreach (string
s in books) Console.WriteLine(s) int
data 1, 2, 3, 4, 5 int sum 0
foreach (int x in data) sum x
value
type
collection

• foreach can iterate over system-supplied or
  user-defined collections
• Chapter 7 interface programming IEnumerator and
  IEnumerable

39
The while Loop and do/while Loop
static void Main(string args) string
userIsDone "no" // Test on a lower class
copy of the string. while(userIsDone.ToLower()
! "yes") Console.Write("Are you done?
yes no ") userIsDone
Console.ReadLine() Console.WriteLine("In
while loop")
static void Main(string args) string
userIsDone "" do Console.WriteLine("I
n do/while loop") Console.Write("Are you
done? yes no ") userIsDone
Console.ReadLine() while(userIsDone.ToLower()
! "yes") // Note the semicolon!
40
Decision Constructs

• The if/else Statement and The switch Statement

• Unlike in C, the if/else statement in C
  operates only on Boolean expressions, not ad hoc
  values such as 1, 0.
• C programmers need to be aware that the old
  tricks of testing a condition for a value not
  equal to zero will not work in C.

// This is illegal, given that Length returns an
int, not a bool. string thoughtOfTheDay "You
CAN teach an old dog new tricks" if(thoughtOfTheD
ay.Length) ...
// Legal, as this resolves to either true or
false. if( 0 ! thoughtOfTheDay.Length) ...
41
The Relational Operators and Conditional Operators
42
The switch Statement

• To handle program flow based on a predefined set
  of choices.
• each case (including default) that contains
  executable statements have a terminating break or
  goto to avoid fall-through.

static void Main(string args)
Console.WriteLine("1 C, 2 VB")
Console.Write("Please pick your language
preference ") string langChoice
Console.ReadLine() int n int.Parse(langChoice
) switch (n) case 1
Console.WriteLine("Good choice, C is a fine
language.") break case 2
Console.WriteLine("VB .NET OOP, multithreading,
and more!") break default
Console.WriteLine("Well...good luck with
that!") break
43
The switch Statement

• Evaluate string data in addition to numeric data.
• no need to parse the user data into a numeric
  value

static void Main(string args)
Console.WriteLine("C or VB")
Console.Write("Please pick your language
preference ") string langChoice
Console.ReadLine() switch (langChoice)
case "C" Console.WriteLine("Good choice,
C is a fine language.") break case
"VB" Console.WriteLine("VB .NET OOP,
multithreading and more!") break
default Console.WriteLine("Well...good
luck with that!") break