No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Dart

Curso de Dart

Argel Franco Bejarano de la Cruz

Argel Franco Bejarano de la Cruz

Constructores por defecto, por parámetro o nombrados

18/29
Recursos

Los constructores se utilizan para inicializar una clase, son el primer método que se visualiza al instanciar un objeto.

Constructores por defecto
El constructor por defecto ya existe cuando se crea una clase y se define creando un método con el mismo nombre de la clase “nombreClase(){…}”

Constructores con parámetros
Los constructores con parámetros son aquellos que pueden definir los miembros mediante el constructor.

No puede existir en la misma clase un constructor por defecto y uno con parámetros.

Constructores nombrados
También podemos definir constructores con un nombre definido por nosotros y ésto hace que puedan existir múltiples constructores.

Aportes 35

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

No existe la sobrecarga de constructores en Dart entonces

RESUMEN DE LA CLASE

Constructores:

Constructor por defecto: ya existe cuando se crea una clase y se define creando un método con el mismo nombre de la clase.

**Sintaxis **

nombreClase(){}

Constructor por parámetro: no puede existir si ya está establecido un constructor por defecto.

Sintaxis

nombreClase(int param1, int param2){
	this.param1 = param1;
	this.param2 = param2;
}

//Puede resumirse de la siguiente manera

nombreClase(this.param1, this.param2);

Constructor nombrado: posee un nombre definido por nosotros. Pueden existir múltiples de ellos.

Sintaxis

nombreClase.constructorNom(this.param1, this.param2);

Nota: La palabra reservada this hace referencia al objeto actual. Por lo tanto, cuando se hace por ejemplo la sentencia this.id = id, debe diferenciarse el primer “id”, ya que este es un atributo del objeto, y el segundo un parametro del constructor. Y es mediante ese parametro del constructor que inicializamos el atributo del objeto, no son las mismas variables (aunque se llamen igual).

Siento que C++ y Python tuvieron un hijo perfecto…

Si quieren profundizar en la documentación => https://dart.dev/guides/language/language-tour#using-constructors

No explica muy claro 😕

Constructor por defecto

Constructores por parámetros

Constructores por nombre o nombrados

Entonces, no hay sobrecarga para el constructor y tampoco para métodos

En Dart no hay sobrecarga de métodos constructores

Código de la clase comentado:

// Clase sobre Constructores

// ? Qué es un constructor
// * Son métodos utilizados para inicializar una clase, es decir,
// * Son lo primero que se ejecuta cuando instanciamos un objeto.

main(List<String> args) {
  Empleado juan = Empleado();
  Gerente jose = Gerente(103, "José");
  Guardia roberto = Guardia.trabajo(303, "Roberto", false);
}

// ! Existen tres tipos de constructores:

class Empleado{
  var id;
  var nombre;

  // ? Constructores por defecto
  // * Ya existe cuando se crea una clase y se define creando un método
  // * con el mismo nombre de la clase "nombreClase(){}"

  Empleado(){
    print("Contratamos a un empleado.");
  }

  bool cumpleHorario(){
    return true;
  }

  void trabajar(){
    print("$nombre realizó su trabajo...");
  }
}

class Gerente {
  var id;
  var nombre;

  // ? Constructores con parámetros
  // * Son constructores que reciben parámetros para ya sea inicializar
  // * sus miembros o para realizar acciones durante la inicializacion
  // * de otras acciones

  Gerente(int id, String nombre){
    this.id = id;
    this.nombre = nombre;
    print("Contratamos a un gerente llamado $nombre y su id es $id");
  }

  // * Otra forma de inicializar parámetros, es:
  // Gerente(this.id, this.nombre);

  bool cumpleHorario(){
    return true;
  }

  void trabajar(){
    print("$nombre realizó su trabajo...");
  }
}

class Guardia{
  var id;
  var nombre;
  var trabajo;

  // ? Constructores nombrados.
  // * Tambien podemos definir constructores con un nombre definido por
  // * nosotros y de estos pueden existir múltiples constructores.

  Guardia.trabajo(this.id, this.nombre, this.trabajo){
    if(trabajo){
      print("Contratamos a un guardia de seguridad llamado $nombre y ya hizo su trabajo.");
    }else{
      print("Contratamos a un guardia de seguridad llamado $nombre, pero aun no ha hecho su trabajo.");
    }
  }

  bool cumpleHorario(){
    return trabajo;
  }

  void trabajar(){
    print("$nombre realizó su trabajo...");
  }
}

**++Mi ejemplo de CONSTRUCTOR NOMBRADO.
Creo que no lo usé nunca en FLUTTER.
El que usé mucho es el CONSTRUCTOR CON PARÁMETROS por eso no lo practiqué esta vez.

No conocía la manera de crear un constructor de la forma

Empleados(this.a, this.b);

Genial!

Una breve explicación en texto de lo explicado en esta clase
La clase que hemos definido en el ejemplo se llama Empleado

class Empleado
{
   var id;
   var nombre;
   bool cumpleHorario()
   {
     return true;
   }


   void trabajar()
   {
     print ('El trabajador con el nombre $nombre trabajó hoy');
   }
}

Por lo tanto el constructor por defecto tiene el mismo nombre de la clase así:

Empleado()
{
print ('Hola me ejecuté al inicio');
}

Al instanciar la clase se ejecutará este constructor por defecto, mostrando el mensaje que querramos colocar.

Luego para usar el constructor por defecto de forma correcta lo hacemos así

Empleado(int id, String nombre)
{
   this.id=id;
   this.nombre=nombre;
}

Y para ser instanciado este constructor se lo hace así:

Empleado emp= Empleado(1,"Roberto");
emp.trabajar();

También se puede simplificar el código de la siguiente manera

Empleado(this.id,this.nombre);

Los **constructores nombrados ** funcionan de la siguiente manera

Se coloca otro nombre al constructor un nombre a nuestra elección

Empleado.trabajo(this.id,this.nombre,this.trabajo);

Y luego cambiamos una función para probar su funcionamiento

bool cumpleHorario()
{
  return trabajo;
}

y se instancia este constructor así

se lo hace así 

emp3.cumpleHorario()? print ("Cumplió horario"): print("No cumplió horario");

¿Cúal es la combinación de teclas para comentar un bloque de código? Por favor.

Cuando se ejecuta el constructor

Genial! Muchas opciones!

Hola estoy en dartpad y no me aparece el menú para crear el nuevo archivo de empleado.

A veces me confundo la sintaxis de Dart cuando estoy haciendo código con C++ y viceversa 😄
Interesante la clase

Una consulta, el uso de cada constructor de que dependerá?

Buenas noches chicos/as! Les comparto un código bastante interesante que simula la obtención de datos que pueden ser proporcionados de una API, etc, y que serán usados para instanciar una clase mediante un constructor nombrado.
Espero y les sirva!

//Importamos el paquete para decodificar informacion
import 'dart:convert';

void main() {
  //Instancia de Empleado

  //Empleado empleado = new Empleado(1, 'Pepa');

  //print(empleado.id);
  //print(empleado.nombre);

  //Creamos la instancia de empleado en base a un json
  final rawJson = '{ "id": 1, "nombre": "Pepa"}'; //Formato json
  Map parsedJson = json.decode(rawJson); //Regresa un Map <dynamic, dynamic>

  //Imprimimos
  //print(parsedJson); //Tenemos el mapa

  //Utilizamos el constructor con nombre
  Empleado empleado = new Empleado.fromJson(parsedJson);

  //Imprimimos el resultado
  print(empleado.id);
  print(empleado.nombre);
}

//Creamos una nueva clase
class Empleado {
  //Variables de instancia
  int id;
  String nombre;

  //Constructor por parametro simplificado
  Empleado(this.id, this.nombre);

  //Constructor con nombre que recibe mi mapa para crear una nueva instancia de Empleado
  Empleado.fromJson(Map parsedJson) {
    id = parsedJson["id"];
    nombre = parsedJson["nombre"];
  }
}

Recapitulando de las clases anteriores, también podemos tener un constructor con valores opcionales nombrados o por posición. Además podriamos asignarles valores por defecto, por ejemplo:

Opcional por posición

class Cuadrado {
  var largo, ancho;
  Cuadrado([this.largo, this.ancho]);
}

Opcional por posición con valor por defecto

class Cuadrado {
  var largo, ancho;
  Cuadrado([this.largo = 1, this.ancho = 1]);
}

Opcional nombrado

class Cuadrado {
  var largo, ancho;
  Cuadrado({this.largo, this.ancho});
}

Opcional nombrado con valor por defecto

class Cuadrado {
  var largo, ancho;
  Cuadrado({this.largo = 1, this.ancho = 1});
}

Función de los constructores

Tipos de constructores

Dart ahorra miles de lineas de codigo 😄

Por qué no se usa los tipos de datos? Cuál de los 2 son una buena práctica?

aca si simplifica algo. muy bueno…

Eso que usas al final lo conozco como operador ternario.

No existen ls sobre carga de constructores como en otros lenguaje, existe el constructor nombrado ejemplo
Named Constructors

Dart provides named constructors to enable a class define multiple constructors. The syntax of named constructors is as given below −
Syntax : Defining the constructor

Class_name.constructor_name(param_list)

Example

The following example shows how you can use named constructors in Dart −
Live Demo

void main() {
Car c1 = new Car.namedConst(‘E1001’);
Car c2 = new Car();
}
class Car {
Car() {
print(“Non-parameterized constructor invoked”);
}
Car.namedConst(String engine) {
print(“The engine is : ${engine}”);
}
}

It should produce the following output −

The engine is : E1001
Non-parameterized constructor invoked

/*
Existen tres tipos
.Por defecto: Existe cuando se crea una clase y se define el metodo con el mismo nombre
.Con parametro: No puede existir un constructor por defecto y uno con parametros
.Nombrados: En este caso pueden existir multiples constructores
*/
main(List<String> args) {
  Empleado empleado = Empleado(1, 'Roberto');

  Empleado empleado2 = Empleado(2, 'Pedro');

  empleado.trabajar();
  empleado2.trabajar();
}

class Empleado {
  var id;
  var nombre;
  var trabajo;

/*   Empleado() {
    print('Hola me ejecute al inicio');
  } */

/*   Empleado(int i, String nombre) {
    this.id = id;
    this.nombre = nombre;
  } */

  Empleado(this.id, this.nombre);

  bool cumpleHorario() {
    return true;
  }

  void trabajar() {
    print('El trabajador $nombre trabajo hoy');
  }
}

una constructor nombrado te permite tener otro constructor pero con otro nombre diferente al de la clase, gracias a esto puedes tener diferentes constructores que reciben diferentes parametros segun la necesidad del problema

Fuente
https://medium.com/jay-tillu/constructors-in-dart-4f972186c372

main(List<String> args) {

//Empleado emp = new Empleado(1,'Roberto');
//emp.trabajar();

Empleado emp3 = Empleado.trabajo(2, 'Fernando', false);

emp3.cumpleHorario() ? print("Cumplio Horario") : print("No cumplio Horario");
}


class Empleado{
  var id;
  var nombre;
  var trabajo;

  //Empleado(){
    //print('Hola me ejecute aqui');
  //}

//Empleado(int id, String nombre){
//this.id=id;
//this.nombre=nombre;

//}


Empleado(this.id,this.nombre);

Empleado.trabajo(this.id,this.nombre,this.trabajo);

bool cumpleHorario(){
  return trabajo;
}

void trabajar(){
  print('El trabajador con el nombre $nombre trabaja hoy');
}

}```

Constructores por defecto
El constructor por defecto ya existe cuando se crea una clase y se define creando un método con el mismo nombre de la clase “nombreClase(){…}”

this es la referencia al objeto actualmente instanciado.