Object-Oriented Programming
## Learning Objectives
- Understand classes and objects
- Master encapsulation
- Work with constructors
- Create and use instance methods
## Classes and Objects
### Class: Blueprint
```csharp
class Person
{
// Fields (attributes)
public string Name;
public int Age;
// Methods (behaviors)
public void Speak()
{
Console.WriteLine("My name is " + Name);
}
public void SayAge()
{
Console.WriteLine("I am " + Age + " years old");
}
}
```
### Object: Instance
```csharp
class Program
{
static void Main()
{
Person person1 = new Person();
Person person2 = new Person();
person1.Name = "Alice";
person1.Age = 25;
person2.Name = "Bob";
person2.Age = 30;
person1.Speak(); // My name is Alice
person2.Speak(); // My name is Bob
}
}
```
## Encapsulation
### Private Fields
```csharp
class Person
{
private string _name; // Can't access directly
private int _age;
}
```
### Properties
```csharp
class Person
{
private string _name;
private int _age;
public string Name
{
get { return _name; }
set { _name = value; }
}
public int Age
{
get { return _age; }
set
{
if (value >= 0)
{
_age = value;
}
}
}
}
```
### Auto-Implemented Properties
```csharp
class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
// Usage
Person p = new Person();
p.Name = "Alice";
p.Age = 25;
```
### Init-Only Properties (C# 9+)
```csharp
class Person
{
public string Name { get; init; }
}
// Usage
Person p = new Person { Name = "Alice" }; // OK
// p.Name = "Bob"; // Error - can only set during initialization
```
## Constructors
### Default Constructor
```csharp
class Person
{
private string _name;
// No-arg constructor
public Person()
{
_name = "Unknown";
}
}
```
### Parameterized Constructor
```csharp
class Person
{
private string _name;
private int _age;
public Person(string name, int age)
{
_name = name;
_age = age;
}
}
```
### Calling Constructors
```csharp
Person p1 = new Person(); // Default
Person p2 = new Person("Alice", 25); // Parameterized
```
### Constructor Overloading
```csharp
class Person
{
private string _name;
private int _age;
public Person()
{
_name = "Unknown";
_age = 0;
}
public Person(string name)
{
_name = name;
_age = 0;
}
public Person(string name, int age)
{
_name = name;
_age = age;
}
}
```
### Constructor Chaining
```csharp
class Person
{
private string _name;
private int _age;
public Person() : this("Unknown", 0)
{
}
public Person(string name) : this(name, 0)
{
}
public Person(string name, int age)
{
_name = name;
_age = age;
}
}
```
## this Keyword
### Reference to Current Object
```csharp
class Person
{
private string _name;
public Person(string name)
{
_name = name; // this._name = parameter name
}
}
```
## Static vs Instance
### Instance Members
```csharp
class Person
{
private string _name; // Instance variable (unique per object)
public void Speak() // Instance method
{
Console.WriteLine("I am " + _name);
}
}
Person p1 = new Person("Alice");
Person p2 = new Person("Bob");
p1.Speak(); // I am Alice
p2.Speak(); // I am Bob
```
### Static Members
```csharp
class Counter
{
private int _count; // Instance variable
public static int TotalCount; // Shared by all instances
public Counter()
{
_count++;
TotalCount++;
}
public static void PrintTotal()
{
Console.WriteLine("Total: " + TotalCount);
}
}
```
## Method Overloading
### Same Name, Different Parameters
```csharp
class Calculator
{
public int Add(int a, int b)
{
return a + b;
}
public double Add(double a, double b)
{
return a + b;
}
public int Add(int a, int b, int c)
{
return a + b + c;
}
}
```
## ToString Method
### String Representation
```csharp
class Person
{
public string Name { get; set; }
public int Age { get; set; }
public override string ToString()
{
return $"Person{{Name='{Name}', Age={Age}}}";
}
}
// Usage
Person p = new Person { Name = "Alice", Age = 25 };
Console.WriteLine(p); // Prints: Person{Name='Alice', Age=25}
```
## Access Modifiers
| Modifier | Same Class | Same Assembly | Derived Class | Everywhere |
|----------|------------|---------------|---------------|------------|
| private | Yes | No | No | No |
| internal | Yes | Yes | No | No |
| protected | Yes | No | Yes | No |
| protected internal | Yes | Yes | Yes | No |
| public | Yes | Yes | Yes | Yes |
### Common Usage
```csharp
class BankAccount
{
private string _accountNumber; // Only in this class
internal decimal _balance; // Same assembly
protected string _routingNumber; // This class + derived
public string _bankName; // Anywhere
}
```
## Properties Example
```csharp
class BankAccount
{
private string _accountNumber;
private decimal _balance;
public BankAccount(string accountNumber, decimal initialBalance)
{
_accountNumber = accountNumber;
_balance = initialBalance;
}
public string AccountNumber
{
get { return _accountNumber; }
}
public decimal Balance
{
get { return _balance; }
}
public void Deposit(decimal amount)
{
if (amount > 0)
{
_balance += amount;
}
}
public bool Withdraw(decimal amount)
{
if (amount > 0 && amount <= _balance)
{
_balance -= amount;
return true;
}
return false;
}
}
```
## Object Initializer
### Initialize Without Constructor
```csharp
class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
// Using object initializer
Person p = new Person { Name = "Alice", Age = 25 };
// Combined with constructor
Person p2 = new Person("Bob") { Age = 30 };
```
## Static Class
### Utility Methods
```csharp
static class MathHelper
{
public static int Square(int x) => x * x;
public static int Cube(int x) => x * x * x;
public static bool IsEven(int x) => x % 2 == 0;
}
// Usage
int sq = MathHelper.Square(5);
```
## Summary
- Classes define objects; objects are class instances
- Encapsulation: private fields + public properties
- Constructors initialize objects; can be overloaded
- `this` references current object
- Static members belong to class; instance members belong to object
- `ToString()` provides string representation
- Access modifiers: private, internal, protected, public
- Object initializers: `new Class { Prop = value }`
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →