Un construtor permite dar os valores iniciais a un obxecto cando o creamos. Escribímolo co nome da clase e sen tipo de retorno, nin sequera void.

🔹 Construtor por defecto

Se non declaras ningún construtor nunha clase, Dart proporciona automaticamente un construtor por defecto, sen nome e sen argumentos. Isto permite crear un obxecto escribindo o nome da clase seguido de parénteses baleiras.

class Profesor {
  String nome = '';
  int idade = 0;
}

void main() {
  var p = Profesor(); // Chamamos ao construtor por defecto.

  print(p.nome);  // '' (texto baleiro)
  print(p.idade); // 0

  // Despois de crear o obxecto, modificamos os seus atributos.
  p.nome = 'Diego';
  p.idade = 22;
}

🔹 Construtor sen nome personalizado e this

Ademais de utilizar o construtor por defecto, podemos escribir o noso propio construtor sen nome. Isto permite recibir argumentos para inicializar os atributos ao crear o obxecto.

Ao declarar un construtor, Dart deixa de proporcionar automaticamente o construtor por defecto.

Un construtor sen nome escríbese co nome da clase, sen ningún identificador adicional despois dun punto.

class Profesor {
    final String nome;
    
    // this.nome garda o argumento directamente no atributo.
    Profesor(this.nome);
}

void main() {
    var profesor = Profesor('Diego Rodicio');
    print(profesor.nome);
    // Profesor(); // Agora temos que pasar o nome
}

final indica que o atributo só se pode asignar unha vez. Neste caso recibe o valor no construtor.

🏷️ Construtor con parámetros nomeados: a forma habitual en Flutter

No Tema 2.1 vimos parámetros nomeados nas funcións. Nos construtores funcionan igual: usamos {} e indicamos os nomes ao chamar.

class Profesor {
  final String nome;
  final String centro;

  Profesor({
    required this.nome, // É obrigatorio pasalo
    this.centro = 'IES San Mamede', // Podemos omitilo: ten un valor por defecto
  });
}

void main() {
  var profesor = Profesor(nome: 'Diego Rodicio');
  print('${profesor.nome}: ${profesor.centro}');
}

required obriga a pasar o argumento. Os parámetros nomeados opcionais necesitan un valor por defecto ou un tipo que admita null.

📌 As chaves {} da declaración agrupan os parámetros nomeados. Na chamada usamos nome: valor, sen esas chaves.

🔸 Construtores nomeados: outra maneira de crear o obxecto

Un construtor nomeado leva un nome despois do punto, como Profesor.senDatos(). É útil para ofrecer outra forma de inicialización.

Non o confundas cos parámetros nomeados:

Un construtor nomeado tamén pode recibir parámetros nomeados. Son dúas decisións distintas.

class Profesor {
  // Os atributos xa teñen valor antes de entrar no corpo do construtor.
  String nome = '';
  int idade = 0;

  // Sen nome: recibe os argumentos por orde.
  Profesor(this.nome, this.idade);

  // Nomeado sen argumentos: usa valores fixos.
  Profesor.desconecido() {
    nome = 'Descoñecido';
    idade = 0;
  }

  // Nomeado con parámetros nomeados obrigatorios.
  Profesor.conDatos({required this.nome, required this.idade});

  void saudar() {
    print('Ola! Son $nome e teño $idade anos.');
  }
}

void main() {
  var p1 = Profesor('Janeiro', 30);
  var p2 = Profesor.desconecido();
  var p3 = Profesor.conDatos(nome: 'Julia', idade: 25);

  p1.saudar(); // Ola! Son Janeiro e teño 30 anos.
  p2.saudar(); // Ola! Son Descoñecido e teño 0 anos.
  p3.saudar(); // Ola! Son Julia e teño 25 anos.
}

🧮 Lista de inicialización

Os dous puntos : permiten darlles un valor inicial aos atributos antes de executar o código entre {}. Se non precisamos ese código, rematamos o construtor cun punto e coma (;).

class Profesor {
  String nome;
  int idade;

  // Inicializamos os atributos despois dos dous puntos.
  Profesor.desconecido() : nome = 'Descoñecido', idade = 0;
}

void main() {
  var profesor = Profesor.desconecido();

  print(profesor.nome);  // Descoñecido
  print(profesor.idade); // 0
}

As asignacións sepáranse con comas. Esta forma de inicializar os atributos tamén se pode empregar cando son final.

📌 Construtores const

Un construtor const permite crear obxectos constantes, que non cambian.

Un construtor const tamén se pode chamar sen crear un obxecto constante, como veremos no exemplo completo.

Os atributos de instancia deben ser final e a inicialización debe ser compatible con const.

• final: o atributo non se pode reasignar.
• const na creación: o obxecto é constante e os argumentos deben ser constantes.

class Profesor {
  final String nome;

  const Profesor(this.nome);
}

void main() {
  const profesor = Profesor('Toni');
}

En Flutter veremos construtores const con frecuencia: permiten reutilizar widgets (partes da interface) que non cambian.

🧪 Exemplo completo: ficha dun profesor

🔗 Ver o código en DartPad — https://dartpad.dev/?id=341dd5e98c01dad0e36d3b19ea5ecea8

🕓 Recordatorio: cando usar late

Como vimos no Tema 2.1, late permite deixar a asignación dun valor para máis tarde, pero debemos asignalo antes de usalo.

class Sesion {
  late String profesor; // Recibirá o valor nun paso posterior

  void iniciar(String nome) {
    profesor = nome;
  }

  void mostrarProfesor() {
    print(profesor);
  }
}

void main() {
  var sesion = Sesion();
  sesion.iniciar('Diego Rodicio'); // Primeiro inicializamos
  sesion.mostrarProfesor(); // Despois lemos
}

Se chamamos a mostrarProfesor() antes de iniciar(), o programa dará un erro. Usa late só se sabes que asignarás o valor antes de usalo.

Vemos isto porque en Flutter usarémolo con certa frecuencia, como veremos na seguinte unidade.

🔗 Construtores na documentación de Dart — https://dart.dev/language/constructors