Programación Orientada a Objetos
## Objetivos de Aprendizaje
- Comprender clases y objetos
- Dominar encapsulamiento
- Trabajar con constructores
- Crear y usar métodos de instancia
## Clases y Objetos
### Clase: Plano
```csharp
class Person
{
// Campos (atributos)
public string Name;
public int Age;
// Métodos (comportamientos)
public void Speak()
{
Console.WriteLine("Mi nombre es " + Name);
}
public void SayAge()
{
Console.WriteLine("Tengo " + Age + " años");
}
}
```
### Objeto: Instancia
```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(); // Mi nombre es Alice
person2.Speak(); // Mi nombre es Bob
}
}
```
## Encapsulamiento
### Campos Privados
```csharp
class Person
{
private string _name; // No se puede acceder directamente
private int _age;
}
```
### Propiedades
```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;
}
}
}
}
```
### Propiedades Auto-Implementadas
```csharp
class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
// Uso
Person p = new Person();
p.Name = "Alice";
p.Age = 25;
```
### Propiedades Solo-Inicialización (C# 9+)
```csharp
class Person
{
public string Name { get; init; }
}
// Uso
Person p = new Person { Name = "Alice" }; // OK
// p.Name = "Bob"; // Error - solo se puede establecer durante inicialización
```
## Constructores
### Constructor por Defecto
```csharp
class Person
{
private string _name;
// Constructor sin argumentos
public Person()
{
_name = "Unknown";
}
}
```
### Constructor con Parámetros
```csharp
class Person
{
private string _name;
private int _age;
public Person(string name, int age)
{
_name = name;
_age = age;
}
}
```
### Llamar Constructores
```csharp
Person p1 = new Person(); // Por defecto
Person p2 = new Person("Alice", 25); // Con parámetros
```
### Sobrecarga de Constructores
```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;
}
}
```
### Encadenamiento de Constructores
```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;
}
}
```
## Palabra Clave this
### Referencia al Objeto Actual
```csharp
class Person
{
private string _name;
public Person(string name)
{
_name = name; // this._name = parámetro name
}
}
```
## Estático vs Instancia
### Miembros de Instancia
```csharp
class Person
{
private string _name; // Variable de instancia (única por objeto)
public void Speak() // Método de instancia
{
Console.WriteLine("Soy " + _name);
}
}
Person p1 = new Person("Alice");
Person p2 = new Person("Bob");
p1.Speak(); // Soy Alice
p2.Speak(); // Soy Bob
```
### Miembros Estáticos
```csharp
class Counter
{
private int _count; // Variable de instancia
public static int TotalCount; // Compartida por todas las instancias
public Counter()
{
_count++;
TotalCount++;
}
public static void PrintTotal()
{
Console.WriteLine("Total: " + TotalCount);
}
}
```
## Sobrecarga de Métodos
### Mismo Nombre, Diferentes Parámetros
```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;
}
}
```
## Método ToString
### Representación en Cadena
```csharp
class Person
{
public string Name { get; set; }
public int Age { get; set; }
public override string ToString()
{
return $"Persona{{Nombre='{Name}', Edad={Age}}}";
}
}
// Uso
Person p = new Person { Name = "Alice", Age = 25 };
Console.WriteLine(p); // Imprime: Persona{Nombre='Alice', Edad=25}
```
## Modificadores de Acceso
| Modificador | Misma Clase | Mismo Ensamblado | Clase Derivada | En Todas Partes |
|-------------|------------|------------------|----------------|-----------------|
| private | Sí | No | No | No |
| internal | Sí | Sí | No | No |
| protected | Sí | No | Sí | No |
| protected internal | Sí | Sí | Sí | No |
| public | Sí | Sí | Sí | Sí |
### Uso Común
```csharp
class BankAccount
{
private string _accountNumber; // Solo en esta clase
internal decimal _balance; // Mismo ensamblado
protected string _routingNumber; // Esta clase + derivadas
public string _bankName; // En cualquier lugar
}
```
## Ejemplo de Propiedades
```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;
}
}
```
## Inicializador de Objetos
### Inicializar Sin Constructor
```csharp
class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
// Usando inicializador de objeto
Person p = new Person { Name = "Alice", Age = 25 };
// Combinado con constructor
Person p2 = new Person("Bob") { Age = 30 };
```
## Clase Estática
### Métodos de Utilidad
```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;
}
// Uso
int sq = MathHelper.Square(5);
```
## Resumen
- Las clases definen objetos; los objetos son instancias de clases
- Encapsulamiento: campos privados + propiedades públicas
- Los constructores inicializan objetos; pueden sobrecargarse
- `this` referencia el objeto actual
- Los miembros estáticos pertenecen a la clase; los de instancia pertenecen al objeto
- `ToString()` proporciona representación en cadena
- Modificadores de acceso: private, internal, protected, public
- Inicializadores de objetos: `new Class { Prop = value }`
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →