No existe la sobrecarga de constructores en Dart entonces
Bienvenida e Introducción
Introducción y Bienvenida
Dart vs. Go vs. JavaScript vs. Kotlin
DartPad y qué editores utlizar
Básicos 1: Variables y Operadores
Variables: Números (int,double), String y booleanos
Colecciones
Diccionarios
Constantes (final y const)
Operadores aritméticos, de asignacion y lógicos
Básicos 2: Funciones y Parámetros
Declaración de funciones y la función Main()
Funciones de sintaxis corta (Arrow) y Anónimas (Lambda)
Parámetros requeridos, opcionales, posicionados, nombrados y por defecto
Básicos 3: Flujos de Control
If-Else y Expresiones Condicionales
Switch y Case
For
While y do-while
Break y Continue
Clases
Definición de clases y miembros
Constructores por defecto, por parámetro o nombrados
Métodos Getter y Setter y variables privadas
Herencia
Clases Abstractas
Interfaces implícitas
Utilizar Flutter en Dart
Iniciar y estructurar un proyecto en Flutter
Contenedores
Creando un botón personalizado con el Widget Container
Modelos de datos y peticiones http
Trabajando datos http y Widget Future Builder
Ejecutando el mismo código en Android y iOS
Conclusiones
Dart en el futuro
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
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
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
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 😄
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.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?