Definición de constructores
Cree instancias con constructores parametrizados.
Definición de constructores es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.
¿Qué es un constructor?
Un constructor es un método especial que se ejecuta cuando se crea un objeto con new. Tiene el mismo nombre que la clase y no tiene tipo de retorno. Su función es dejar el objeto en un estado inicial válido.
using System;
class Dog
{
public Dog()
{
Console.WriteLine("A dog was created");
}
}
class Program
{
static void Main()
{
var d = new Dog();
}
}Constructores parametrizados
Un constructor puede recibir parámetros para que quien lo llame proporcione los valores iniciales. Es el patrón más habitual para establecer los datos obligatorios.
using System;
class Person
{
public string Name;
public int Age;
public Person(string name, int age)
{
Name = name;
Age = age;
}
}
class Program
{
static void Main()
{
var p = new Person("Ada", 36);
Console.WriteLine(p.Name + " is " + p.Age);
}
}La palabra clave this en los constructores
Cuando el nombre de un parámetro coincide con el de un campo, utilice this. para referirse al campo y distinguirlo del parámetro.
using System;
class Book
{
public string Title;
public Book(string title)
{
this.Title = title;
}
}
class Program
{
static void Main()
{
var b = new Book("C# Basics");
Console.WriteLine(b.Title);
}
}El constructor predeterminado
Si no escribe ningún constructor, el compilador proporciona uno sin parámetros. Sin embargo, en cuanto define cualquier constructor, el predeterminado deja de existir, a menos que lo añada usted mismo.
using System;
class Empty
{
// No constructor written -> compiler supplies a default one
public int Value;
}
class Program
{
static void Main()
{
var e = new Empty();
Console.WriteLine("Default Value: " + e.Value);
}
}Validación en un constructor
Un constructor puede validar sus argumentos y garantizar que el objeto nunca se cree en un estado no válido.
using System;
class Account
{
public decimal Balance;
public Account(decimal initial)
{
if (initial < 0)
throw new ArgumentException("Initial balance cannot be negative");
Balance = initial;
}
}
class Program
{
static void Main()
{
var a = new Account(100m);
Console.WriteLine("Balance: " + a.Balance);
}
}Sobrecarga de constructores
Una clase puede tener varios constructores con distintas listas de parámetros. El compilador selecciona el que coincide con los argumentos que proporciona.
using System;
class Point
{
public int X;
public int Y;
public Point()
{
X = 0;
Y = 0;
}
public Point(int x, int y)
{
X = x;
Y = y;
}
}
class Program
{
static void Main()
{
var origin = new Point();
var p = new Point(3, 4);
Console.WriteLine(origin.X + "," + origin.Y + " | " + p.X + "," + p.Y);
}
}Establecer propiedades desde un constructor
Los constructores suelen asignar valores a propiedades autoimplementadas, incluidas las de solo inicialización y las que tienen setters privados.
using System;
class Product
{
public string Name { get; }
public decimal Price { get; }
public Product(string name, decimal price)
{
Name = name;
Price = price;
}
}
class Program
{
static void Main()
{
var p = new Product("Pen", 1.50m);
Console.WriteLine(p.Name + ": " + p.Price);
}
}Valores de parámetros predeterminados
Los parámetros de un constructor pueden tener valores predeterminados, lo que permite omitirlos al realizar la llamada. Esto suele reducir la necesidad de varias sobrecargas.
using System;
class Circle
{
public double Radius;
public string Color;
public Circle(double radius, string color = "black")
{
Radius = radius;
Color = color;
}
}
class Program
{
static void Main()
{
var c1 = new Circle(2);
var c2 = new Circle(3, "red");
Console.WriteLine(c1.Color + " | " + c2.Color);
}
}Realizar trabajo en un constructor
Además de asignar valores a los campos, un constructor puede calcular datos derivados o preparar los recursos que necesita el objeto.
using System;
class Rectangle
{
public double Width;
public double Height;
public double Area;
public Rectangle(double w, double h)
{
Width = w;
Height = h;
Area = w * h;
}
}
class Program
{
static void Main()
{
var r = new Rectangle(4, 5);
Console.WriteLine("Area: " + r.Area);
}
}Constructores y datos obligatorios
Incluir los valores obligatorios en el constructor hace que sean realmente necesarios: no puede crear el objeto sin proporcionarlos.
using System;
class User
{
public string Id;
public string Email;
public User(string id, string email)
{
Id = id;
Email = email;
}
}
class Program
{
static void Main()
{
var u = new User("u1", "a@b.com");
Console.WriteLine(u.Id + " / " + u.Email);
}
}Integrarlo todo
Un constructor bien diseñado valida la entrada, asigna los campos y deja el objeto completamente preparado para usarse.
using System;
class Temperature
{
public double Celsius { get; }
public double Fahrenheit { get; }
public Temperature(double celsius)
{
if (celsius < -273.15)
throw new ArgumentException("Below absolute zero");
Celsius = celsius;
Fahrenheit = celsius * 9 / 5 + 32;
}
}
class Program
{
static void Main()
{
var t = new Temperature(25);
Console.WriteLine(t.Celsius + "C = " + t.Fahrenheit + "F");
}
}Comprobación rápida
Compruebe cuánto comprende sobre los constructores.
Recapitulación
Un constructor comparte el nombre de la clase, no tiene tipo de retorno y se ejecuta al usar new. Los constructores parametrizados reciben valores iniciales; this. permite distinguir los campos de los parámetros. Puede sobrecargar constructores y usar valores de parámetro predeterminados. Definir cualquier constructor elimina el constructor predeterminado generado automáticamente.
using System;
class Demo
{
public string Name;
public Demo(string name = "anon")
{
this.Name = name;
}
}
class Program
{
static void Main()
{
Console.WriteLine(new Demo().Name);
Console.WriteLine(new Demo("Kai").Name);
}
}Preguntas frecuentes
¿La lección «Definición de constructores» es gratis?
Sí — el texto completo de «Definición de constructores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Definición de constructores»?
Cree instancias con constructores parametrizados. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C# Academy?
No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Definición de constructores»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C# Academy?
Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Definición de constructores
- Encadenamiento de constructores con this
- Inicializadores de objetos y colecciones
- Constructores estáticos