El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Constructores

Siguiente ►
►

En Dart, los constructores son métodos especiales que se utilizan para inicializar objetos de una clase. Los constructores permiten establecer el estado inicial de un objeto cuando se crea. En esta sección, aprenderemos sobre los diferentes tipos de constructores en Dart, cómo definirlos y cómo utilizarlos.

Tipos de Constructores

  1. Constructor por Defecto
  2. Constructores Nombrados
  3. Constructores Constantes
  4. Constructores de Redirección

  1. Constructor por Defecto

El constructor por defecto es un constructor sin parámetros que se llama automáticamente cuando se crea una instancia de una clase. Si no defines ningún constructor en una clase, Dart proporciona un constructor por defecto implícito.

Ejemplo:

class Persona {
  String nombre;
  int edad;

  // Constructor por defecto
  Persona() {
    nombre = 'Desconocido';
    edad = 0;
  }
}

void main() {
  Persona p = Persona();
  print('Nombre: ${p.nombre}, Edad: ${p.edad}');
}

  1. Constructores Nombrados

Los constructores nombrados permiten definir múltiples constructores para una clase, cada uno con un nombre diferente. Esto es útil cuando necesitas diferentes formas de inicializar un objeto.

Ejemplo:

class Persona {
  String nombre;
  int edad;

  // Constructor por defecto
  Persona() {
    nombre = 'Desconocido';
    edad = 0;
  }

  // Constructor nombrado
  Persona.conNombre(this.nombre) {
    edad = 0;
  }

  // Otro constructor nombrado
  Persona.conEdad(this.edad) {
    nombre = 'Desconocido';
  }
}

void main() {
  Persona p1 = Persona();
  Persona p2 = Persona.conNombre('Juan');
  Persona p3 = Persona.conEdad(25);

  print('p1 - Nombre: ${p1.nombre}, Edad: ${p1.edad}');
  print('p2 - Nombre: ${p2.nombre}, Edad: ${p2.edad}');
  print('p3 - Nombre: ${p3.nombre}, Edad: ${p3.edad}');
}

  1. Constructores Constantes

Los constructores constantes se utilizan para crear objetos inmutables. Para definir un constructor constante, se utiliza la palabra clave const.

Ejemplo:

class Punto {
  final int x;
  final int y;

  // Constructor constante
  const Punto(this.x, this.y);
}

void main() {
  const Punto p1 = Punto(2, 3);
  const Punto p2 = Punto(2, 3);

  print(p1 == p2); // true, porque ambos puntos son constantes e iguales
}

  1. Constructores de Redirección

Los constructores de redirección permiten que un constructor llame a otro constructor de la misma clase. Esto es útil para evitar la duplicación de código.

Ejemplo:

class Cuadrado {
  double lado;

  // Constructor principal
  Cuadrado(this.lado);

  // Constructor de redirección
  Cuadrado.unidad() : this(1.0);
}

void main() {
  Cuadrado c1 = Cuadrado(2.0);
  Cuadrado c2 = Cuadrado.unidad();

  print('c1 - Lado: ${c1.lado}');
  print('c2 - Lado: ${c2.lado}');
}

Ejercicios Prácticos

Ejercicio 1: Constructor por Defecto

Define una clase Animal con un constructor por defecto que inicialice el nombre del animal a "Desconocido" y la edad a 0. Luego, crea una instancia de Animal y muestra sus propiedades.

Solución:

class Animal {
  String nombre;
  int edad;

  // Constructor por defecto
  Animal() {
    nombre = 'Desconocido';
    edad = 0;
  }
}

void main() {
  Animal a = Animal();
  print('Nombre: ${a.nombre}, Edad: ${a.edad}');
}

Ejercicio 2: Constructores Nombrados

Define una clase Vehiculo con un constructor por defecto y dos constructores nombrados: uno que inicialice solo la marca y otro que inicialice solo el modelo. Crea instancias de Vehiculo utilizando cada constructor y muestra sus propiedades.

Solución:

class Vehiculo {
  String marca;
  String modelo;

  // Constructor por defecto
  Vehiculo() {
    marca = 'Desconocido';
    modelo = 'Desconocido';
  }

  // Constructor nombrado
  Vehiculo.conMarca(this.marca) {
    modelo = 'Desconocido';
  }

  // Otro constructor nombrado
  Vehiculo.conModelo(this.modelo) {
    marca = 'Desconocido';
  }
}

void main() {
  Vehiculo v1 = Vehiculo();
  Vehiculo v2 = Vehiculo.conMarca('Toyota');
  Vehiculo v3 = Vehiculo.conModelo('Corolla');

  print('v1 - Marca: ${v1.marca}, Modelo: ${v1.modelo}');
  print('v2 - Marca: ${v2.marca}, Modelo: ${v2.modelo}');
  print('v3 - Marca: ${v3.marca}, Modelo: ${v3.modelo}');
}

Conclusión

En esta sección, hemos aprendido sobre los diferentes tipos de constructores en Dart y cómo utilizarlos para inicializar objetos de una clase. Los constructores son una parte fundamental de la programación orientada a objetos y permiten establecer el estado inicial de los objetos de manera flexible y eficiente. En la próxima sección, exploraremos la herencia en Dart y cómo se puede utilizar para crear jerarquías de clases.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados