Defining Classes
Classes, Fields, Constructors, Methods, Properties
Table of Contents
1. Defining Simple Classes
2. Access Modifiers
3. Using Classes and Objects
4. Constructors
5. Properties
6. Static Members
7. Structures in C#
DEFINING SIMPLE CLASSES
Classes in OOP
Classes model real-world objects and define
Attributes (state, properties, fields)
Behavior (methods, operations)
Classes describe structure of objects
Objects describe particular instance of a class
Properties hold information about the modeled
object relevant to the problem
Operations implement object behavior
Classes in C#
5
Classes in C# could have following members:
Fields, constants, methods, properties, indexers, events,
operators, constructors, destructors
Inner types (inner classes, structures, interfaces,
delegates, ...)
Members can have access modifiers (scope)
public, private, protected, internal
Members can be
static (common) or specific for a given object
SimpleBegin
Class Definition
of class definition
Begin of class definition
public class Cat : Animal
{ Inherited (base) class
private string name;
private string owner; Fields
public Cat(string name, string owner)
{
this.name = name; Constructor
this.owner = owner;
}
public string Name
{
get { return name; }
Property
set { name = value; }
}
Simple Class Definition (2)
public string Owner
{
get { return owner;}
set { owner = value; }
} Method
public void SayMiau()
{
Console.WriteLine("Miauuuuuuu!");
}
}
End of class
definition
Class Definition and Members
Class definition consists of:
Class declaration
Inherited class or implemented interfaces
Fields (static or not)
Constructors (static or not)
Properties (static or not)
Methods (static or not)
Events, inner types, etc.
ACCESS MODIFIERS
Public, Private, Protected, Internal
Access Modifiers
Class members can have access modifiers
Used to restrict the classes able to access them
Supports the OOP principle "encapsulation"
Class members can be:
public – accessible from any class
protected – accessible from the class itself and all its
descendent classes
private – accessible from the class itself only
internal – accessible from the current assembly (used
by default)
Defining Class Dog – Example
public class Dog
{
private string name;
private string breed;
public Dog()
{
this.name = "Balkan";
this.breed = "Street excellent";
}
public Dog(string name, string breed)
{
this.name = name;
this.breed = breed;
}
(example continues)
Defining Class Dog – Example (2)
public string Name
{
get { return name; }
set { name = value; }
}
public string Breed
{
get { return breed; }
set { breed = value; }
}
public void SayBau()
{
Console.WriteLine("{0} said: Bauuuuuu!", name);
}
}
USING CLASSES AND
OBJECTS
Using Classes
How to use classes?
Create a new instance
Access the properties of the class
Invoke methods
Handle events
How to define classes?
Create new class and define its members
Create new class using some other as base class
How to Use Classes (Non-static)?
1. Create an instance
Initialize fields
2. Manipulate instance
Read / change properties
Invoke methods
Handle events
3. Release occupied resources
Done automatically in most cases
CONSTRUCTORS
Defining and Using Class Constructors
What is Constructor?
Constructors are special methods
Invoked when creating a new instance of an object
Used to initialize the fields of the instance
Constructors has the same name as the class
Have no return type
Can have parameters
Can be private, protected, internal, public
Defining Constructors
Class Point with parameterless constructor:
public class Point
{
private int xCoord;
private int yCoord;
// Simple default constructor
public Point()
{
xCoord = 0;
yCoord = 0;
}
// More code ...
}
Defining Constructors (2)
public class Person
{
private string name;
private int age;
As rule constructors should
// Default constructor
initialize all own class fields.
public Person()
{
name = null;
age = 0;
}
// Constructor with parameters
public Person(string name, int age)
{
this.name = name;
this.age = age;
}
// More code ...
}
Constructors and Initialization
Pay attention when using inline initialization!
public class ClockAlarm
{
private int hours = 9; // Inline initialization
private int minutes = 0; // Inline initialization
// Default constructor
public ClockAlarm()
{ }
// Constructor with parameters
public ClockAlarm(int hours, int minutes)
{
this.hours = hours; // Invoked after the inline
this.minutes = minutes; // initialization!
}
// More code ...
}
Chaining Constructors Calls
Reusing constructors
public class Point
{
private int xCoord;
private int yCoord;
public Point() : this(0,0) // Reuse constructor
{
}
public Point(int xCoord, int yCoord)
{
this.xCoord = xCoord;
this.yCoord = yCoord;
}
// More code ...
}
PROPERTIES
Defining and Using Properties
The Role of Properties
Expose object's data to the outside world
Control how the data is manipulated
Properties can be:
Read-only
Write-only
Read and write
Give good level of abstraction
Make writing code easier
Defining Properties
Properties should have:
Access modifier (public, protected, etc.)
Return type
Unique name
Get and / or Set part
Can contain code processing data in specific way
Defining Properties – Example
public class Point
{
private int xCoord;
private int yCoord;
public int XCoord
{
get { return xCoord; }
set { xCoord = value; }
}
public int YCoord
{
get { return yCoord; }
set { yCoord = value; }
}
// More code ...
}
Dynamic Properties
Properties are not obligatory bound to a class field –
can be calculated dynamically
public class Rectangle
{
private float width;
private float height;
// More code ...
public float Area
{
get
{
return width * height;
}
}
}
Automatic Properties
27
Properties could be defined without an underlying field
behind them
It is automatically created by the compiler
class UserProfile
{
public int UserId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
}
…
UserProfile profile = new UserProfile() {
FirstName = "Steve",
LastName = "Balmer",
UserId = 91112 };
STATIC MEMBERS
Static vs. Instance Members
Static Members
Static members are associated with a type rather
than with an instance
Defined with the modifier static
Static can be used for
Fields
Properties
Methods
Events
Constructors
Static vs. Non-Static
Static:
Associated with a type, not with an instance
Non-Static:
The opposite, associated with an instance
Static:
Initialized just before the type is used for the first time
Non-Static:
Initialized when the constructor is called
Static Members – Example
static class SqrtPrecalculated
{
public const int MAX_VALUE = 10000;
// Static field
private static int[] sqrtValues;
// Static constructor
static SqrtPrecalculated()
{
sqrtValues = new int[MAX_VALUE + 1];
for (int i = 0; i < sqrtValues.Length; i++)
{
sqrtValues[i] = (int)Math.Sqrt(i);
}
}
(example continues)
Static Members – Example (2)
// Static method
public static int GetSqrt(int value)
{
return sqrtValues[value];
}
}
class SqrtTest
{
static void Main()
{
Console.WriteLine(SqrtPrecalculated.GetSqrt(254));
// Result: 15
}
}
The End
