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

Interfaces implícitas

22/29
Recursos

Una clase normal puede funcionar como una interfaz a esto de le llama interfaces implícitas, éstas se harán implementando múltiples clases utilizando las clases como una interfaz.

Para que la interfaz implícita sea descrita correctamente, la clase deberá de definir todos los miembros de las clases de las que va a implementar.

En Dart a esto se le conoce como mixings.

Aportes 31

Preguntas 9

Ordenar por:

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

RESUMEN DE LA CLASE

Interfaces: Son un elemento crucial de la programación orientada a objetos. Es un contrato que se forma entre ella y una clase, en la que se promete utilizar todos los métodos y atributos que la interfaz define. Así, por ejemplo, si creamos una interfaz Empleado que contenga los atributos id y nombre, una clase Chofer que la implemente deberá tener obligatoriamente estos atributos.

Interfaces Implícitas: Son las clases normales que actúan como interfaces, ya que en Dart no existen las interfaces propiamente dichas como en otros lenguajes (java, por ejemplo).

//Ejemplo de interfaz

class Empleado{
	var id;
	var nombre;
}

//Ejemplo de clase que implementa la interfaz

class Chofer implements Empleado{
	var id;
	var nombre; 
}

Diferencia con clases abstractas: Las interfaces permiten que las clases puedan implementar muchas de ellas, en cambio, estas últimas solo pueden heredar de una clase abstracta.

Una ve que entiendes como es que maneja la herencia e interfaces Dart el comprender los mixin es sencillo ademas de que tienen mucha utilidad a la hora de reutilizar código para hacer algo así como una “herencia múltiple”. Dejo el enlace a algunos ejemplos por si alguien quiere ir viendo de que tratan los Mixin:

https://www.stacksecrets.com/flutter/implements-v-s-extends-v-s-with-keywords-in-dart

**Extends **es agarrar algo que ya existe y crear en base a ello
**Implements **es como un blue print, agarras piezas o ‘protocolos’ para que tu lo implementes a tu manera

Solo puedes extender una cosa, pero puedes implementar las que quieras.
Algo curioso que vi es que puedes extender e implementar a la vez:

void main(List<String> args) {
  var chofi = Chofer()
  ..id = 1
  ..nombre = 'Roberto'
  ..salario = 100
  ;

  var caji = Cajero()
  ..id = 2
  ..nombre = 'Carlos'
  ..salario = 1500
  ;
  
  chofi.buenaConducta();
  chofi.calcularSalario();
  chofi.comer();

  print('');

  caji.buenaConducta();
  caji.calcularSalario();

}

//Permite multiples implementaciones

class Empleado {
  var id;
  var nombre;
  var salario;

  void calcularSalario() {
    print('Salario de $nombre es ${salario * 5.5}');
  }

}

class Conducta {
  void buenaConducta() {
    print('El empleado se comporto correctamente');
  }
}

abstract class Comer {
  void comer();
}

class Chofer extends Conducta implements Empleado, Comer{
  var id;
  var nombre;
  var salario;

  @override
  void calcularSalario() {
    print('Salario de $nombre es ${salario * 5.5}');
  }

  @override
  void comer() {
    print('Comiendo pan...');
  }
  
}

class Cajero implements Empleado, Conducta {
  var id;
  var nombre;
  var salario;

  @override
  void buenaConducta() {
    print('Este tiene mala conducta');
  }

  @override
  void calcularSalario() {
    print('Salario de $nombre es ${salario * 5.5}');
  }
  
}```

Este es un ejemplo mas facil de entender para las Interfaces Implícitas.

void main() {
  Presidente pte = new Presidente();
  pte.nombre = 'Frank';
  pte.edad = 30;
  pte.horasTrabajadasSemana = 35;
  print(pte.informacion());

  // uso de notacion en cascada
  Director dir = Director()
    ..nombre = 'Jordan'
    ..edad = 56
    ..horasTrabajadasSemana = 40;

  print(dir.informacion());

  Gerente ger = Gerente();
  ger.nombre = 'Lebron';
  ger.horasTrabajadasSemana = 40;
  ger.edad = 34;
  print(ger.informacion());
}

class Persona {
  String nombre;
  int edad;
}

class Empleado {
  String puesto;
  int horasTrabajadasSemana = 0;

  String informacion() => '';
}

// Esta clase implementa todos los miembros de las clases: Persona y Empleado
class Presidente implements Persona, Empleado {
  String nombre;
  int edad;
  String puesto = 'Presidente';
  int horasTrabajadasSemana;

  String informacion() {
    return '''$nombre es $puesto, tiene $edad años y trabaja $horasTrabajadasSemana horas a la semana
    ''';
  }
}

// Esta clase implementa todos los miembros de las clases: Persona y Empleado
class Director implements Persona, Empleado {
  String nombre;
  int edad;
  String puesto = 'Director';
  int horasTrabajadasSemana;

  String informacion() {
    return '''
    Nombre: $nombre
    Edad  : $edad años
    Posición: $puesto
    Trabaja: $horasTrabajadasSemana horas a la semana
    ''';
  }
}

// Esta clase implementa todos los miembros de las clases: Persona y Empleado
class Gerente implements Persona, Empleado {
  String nombre;
  int edad;
  String puesto = 'Gerente';
  int horasTrabajadasSemana;

  String informacion() {
    return '''El $puesto $nombre tiene $edad años y trabaja $horasTrabajadasSemana horas a la semana
    ''';
  }
}

La salida en la consola:

Frank es Presidente, tiene 30 años y trabaja 35 horas a la semana
    
    Nombre: Jordan
    Edad  : 56 años
    Posición: Director
    Trabaja: 40 horas a la semana
    
El Gerente Lebron tiene 34 años y trabaja 40 horas a la semana

Apuntes:

// Interfaces: la palabra reservada implements se encarga de hacer uso de lo que en otros lenguajes es Interface
main(List<String> args) {
  Cajero cajero = Cajero(1, "Sebastián", 900);
  cajero.buenaConducta();
  cajero.calcSal();
}

class Empleado {
  int id;
  String nombre;
  int salario;

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

  void calcSal() => print("El empleado $nombre gana ${salario * 5} cada mes.");
}

class Conducta {
  void buenaConducta() => print("El empleado tiene un buen comportamiento");
}

// Una clase en Dart puede extender de una sola clase o clase abstracta
// Una clase en Dart puede implementar más de una clase, las cuales actuan como Interfaces y no necesitan una palabra reservada como las clases abstractas.
class Cajero implements Empleado, Conducta {
  int id;
  String nombre;
  int salario;

  Cajero(int this.id, String this.nombre, int this.salario);

  @override
  void calcSal() => print("El empleado $nombre gana ${salario * 10} cada mes.");

  @override
  void buenaConducta() => print("El empleado no tiene un buen comportamiento");
}

Codigo Completo de La Clase

// Interfaces Implicitas
main(List<String> args) {
  Chofer chofer = Chofer();
  chofer.id =1;
  chofer.nombre = "Roberto";
  chofer.salario = 150;
  chofer.CalcularSalario();
  chofer.buenaConducta();

  Cajero cajero = Cajero();
  cajero.id = 2;
  cajero.nombre = "Jose";
  cajero.salario = 200;
  cajero.CalcularSalario();
  cajero.buenaConducta();
  
}
class Empleado{
  var id;
  var nombre;
  var salario;

  void CalcularSalario(){
    print('Salario del Empleado es ${salario * 5.5}');
  }
}

class Conducta{
  void buenaConducta(){
    print('El empleado se comporto correctamente');
  }
}
// Con la funcion extends solo podemos heredar de un padre
// Mientras con el implements podemos heredar la n cantidad que deseemos
// Tenemos que colocar todas las funciones a las que estamos llamando
// En este Caso Empleado y Conducta que son las clases que componen 2 funciones mas las respectivas variables
class Chofer implements Empleado, Conducta{
  var id =1;
  var nombre = "Roberto";
  var salario = 150;

  @override
  void CalcularSalario() {
    //TODO: implement CalcularSalario
    print('Salario del Empleado es ${salario * 5.5}');
  }

  @override
  void buenaConducta() => print('El empleado se comporto incorrectamente');
  
}

class Cajero implements Empleado, Conducta{
  var id =2;
  var nombre = "Jose";
  var salario = 200;

  @override
  void CalcularSalario() {
    // TODO: implement CalcularSalario
    print('Salario del Empleado es ${salario * 5.5}');
  }

  @override
  void buenaConducta() {
    // TODO: implement buenaConducta
    print('El empleado se comporto correctamente');
  }
}

Salida :
Salario del Empleado es 825.0
El empleado se comporto incorrectamente
Salario del Empleado es 1100.0
El empleado se comporto correctamente

aca va mi ejemplo de interfaces implicitas:


void main() {
  Persona yo = new Persona(
      34, 'cosme', 'fulanito', 1996, 5, 4);
  print('mi nombre es ${yo.nombre}');
  print('Tengo ${yo.edad} años');
  if (!yo.esCumpleanios()) {
    print('todavia falta!');
  }
    yo.existo();
  
}

class Ser{
  
  String alma;
  void existo() => '';
}

class Persona implements Ser{
  int edad;
  String nombre;
  String apellido;
  int anioNac;
  int mesNac;
  int diaNac;
  String alma;

  //constructor por defecto
  Persona(edad, nombre, apellido, anioNac, mesNac, diaNac) {
    this.edad = edad;
    this.nombre = nombre;
    this.apellido = apellido;
    this.anioNac = anioNac;
    this.mesNac = mesNac;
    this.diaNac = diaNac;
  }

  int getEdad() => this.edad;
  String getNombre() => this.nombre;
  String getApellido() => this.apellido;
  int getAnioNac() => this.anioNac;
  int getMesNac() => this.mesNac;
  int getDiaNac() => this.diaNac;
  String getAlma() => this.alma;
  
  void setAlma(String alma) => this.alma = alma;

  bool esCumpleanios() {
    if ((this.diaNac == 22) && (this.mesNac == 5)) {
      return true;
    }

    return false;
  }
  
  @override
  void existo(){
    print('yo existo');
  }
}```

No acabo de entender que hace el @override???

Al igual que otros lenguajes de programación como Java o C#, Dart solo permite herencia múltiple a través de interfaces. Es decir, nuestras clases no pueden heredar de más de una clase padre, pero si pueden implementar varias interfaces.

Codigo del desafio. Me gusta usar los dos puntos … para acortar codigo.

main(List<String> arguments) {
  Chofer chofer = Chofer()
  ..id=1
  ..nombre='roberto'
  ..salario=100
  ..calcularSalario()
  ..buenaConducta();

  Cajero cajero = Cajero()
  ..id=2
  ..nombre='Angel'
  ..salario=100
  ..calcularSalario()
  ..buenaConducta();
}

class Empleado{
  var id;
  var nombre;
  var salario;

  void calcularSalario(){
    print('salario del empleado es ${salario * 5.5}');
  }
}
class Conducta{
  void buenaConducta(){
    print('el empleado se comporto correctamente');
  }
}
class Chofer implements Empleado,Conducta{
  var id;
  var nombre;
  var salario;

  @override
  void buenaConducta() {
    print('El empleado se comporto inadecuadamente');
  }

  @override
  void calcularSalario() {
    print('el salario del empleado es ${salario*5.5}');
  }

}
class Cajero implements Empleado,Conducta{
  var id;
  var nombre;
  var salario;

  @override
  void buenaConducta() {
    print('El empleado se comporto adecuadamente');
  }

  @override
  void calcularSalario() {
    print('el salario del empleado es ${salario*5.5}');
  }
}

Me encanta que las interfaces sean implícitas en Dart. Aunque también opino que puede generar cierta confusión para las personas que venimos del mundo Java, porque vamos a ver que las clases implementan a otras clases (WTF?). 😛

El título de la clase dice “interfaces implícitas”, pero en el slide dice “interfaces explícitas”. ¿Cuál es el correcto?

main(List <String> arguments) {
  Chofer chofer = Chofer();
  chofer.id = 1;
  chofer.nombre = "Roberto";
  chofer.salario = 100;
  chofer.calcularSalario();
  chofer.buenaConducta();
  
  Cajero cajero = Cajero();
  cajero.id = 2;
  cajero.nombre = "Carlos";
  cajero.salario = 100;
  cajero.calcularSalario();
  cajero.buenaConducta(); 
}

class Empleado{
  var id;
  var nombre;
  var salario;
  
  calcularSalario(){
    print('Salario del empleado es: ${salario * 5.5}');
  }
    
}

class Conducta{
  void buenaConducta(){
    print("El empleado se comportó correctamente");
  }
}

class Chofer implements Empleado, Conducta{
  var id;
  var nombre;
  var salario;
  
  @override
  void calcularSalario(){
    print('Salario del chofer es ${salario * 5.5}');
  }
  
  @override
  void buenaConducta(){
    print('El chofer se comportó inadecuadamente');
  }
  
}

class Cajero implements Empleado, Conducta{
  var id;
  var nombre;
  var salario;
  
  @override
  void calcularSalario(){
    print('Salario del cajero empleado es ${salario * 5.5 + 10} ');
  }
  
  @override
  void buenaConducta(){
    print('El cajero se comportó adecuadamente');
  }
}

Salida:

La clase Empleado debería ser heredad como una clase padre y la clase conducta implementada como una interfaz. Sino cada vez que implementemos en otra clase la clase Empleado debemos estar declarando su variables e implementando sus métodos, algo que en programación orientada a objetos se debe evitar, ya que una de sus funciones es la reutilización del código. Espero haberme explicado, les dejo el ejemplo:

Aqui mi aporte del reto

<code> 
main(){
 Barco velero= new Barco()
     ..velocidad=150
     ..ancho=30
     ..largo=40
     ..consumo=30;
 Anfibio tanque= new Anfibio()
   ..velocidad=100
   ..ancho=20
   ..largo=10
   ..consumo=60;
 velero.calcularConsumo();
 velero.valorEficiencia(velero.consumo);
 print(' ');
 tanque.calcularConsumo();
 tanque.valorEficiencia(tanque.consumo);
}
class Basicos{
 var velocidad;
 var largo;
 var ancho;
 var consumo;

 void calcularConsumo(){
 }
}

class Eficiencia{
  void valorEficiencia(int consumo){
  }

}
 //la palabra clave implements, permite "heredar" varias clases al tiempo, envés de la palabra "extends".
class Anfibio implements Eficiencia, Basicos{
   //en la clase interfaz, deben usarse todos atributos y metodos de las variables
  //implementadas, de modo que no marque error. En el caso de los metodos, deben
  // sobrescribirse usando override, y los atributos, definirse.

  //lo anterior se conoce como mixings, y es usar todas las estructuras de las clases que se estan implementando
  // en la clase implementadora.
  var velocidad;
  var largo;
  var ancho;
  var consumo;
  @override
  void calcularConsumo() {
    print('Consumo de la maquina es ${((consumo*velocidad)-largo-ancho)/100} %');
  }
  @override
  void valorEficiencia(int consumo) {
    if(consumo>50) print('mala eficiencia');
    else print('eficiencia promedio');
  }

}

class Barco implements Basicos,Eficiencia{
  var velocidad;
  var ancho;
  var largo;
  var consumo;

  @override
  void calcularConsumo() {
    print('Consumo de la maquina es ${((consumo*velocidad)-largo-ancho)/100} %');
  }
  @override
  void valorEficiencia(int consumo) {
    if(consumo>50) print('mala eficiencia');
    else print('eficiencia promedio');
  }

}

Excelente ejemplo

Diferencia de extends con implements

Genial!

Codigo del desafio

import 'dart:io';

main(List<String> args) {
  Chofer chofer = Chofer();
  chofer.id = 1;
  chofer.nombre = 'Roberto';
  chofer.salario=100;
  chofer.calcularSalario();
  chofer.buenaConducta();
  
  Cajero cajero = Cajero();
  cajero.id = 1;
  cajero.nombre = 'Roberto';
  cajero.salario=100;
  cajero.calcularSalario();
  cajero.buenaConducta();
}

class Empleado {
  var id;
  var nombre;
  var salario;

  void calcularSalario()
  {
    print('El salario del empleado es ${salario*5.5}');
  }
}

class Conducta {
    void buenaConducta()
    {
      print('El empleado se comporto correctamente');
    }
}

class Chofer implements Empleado, Conducta {
  var id =1;
  var nombre = "Roberto";
  var salario = 100;

  @override
  void calcularSalario()
  {
    print('Salario del empleado es ${salario*5.5}');
  }
  
  @override
  void buenaConducta()
  {
    print('El empleado se comporto inadecuadamente');
  }
}

class Cajero implements Empleado,Conducta{
  var id =2;
  var nombre = "Juan";
  var salario = 100;

  @override
  void calcularSalario()
  {
    print('Salario del empleado es ${(salario*5.5)+100}');
  }
  
  @override
  void buenaConducta()
  {
    print('El empleado se comporto adecuadamente');
  }
}```

Perfecto para complementar con las dos clases anteriores

reto
ya teniamos informacion implementada

main(){
  Chofer chofer=Chofer();
  chofer.id=1;
  chofer.nombre="Cami";
  chofer.salario=500000;
  chofer.calcularSalario();
  chofer.buenoConducta();

  Cajero cajero=Cajero();
  cajero.calcularSalario();
  cajero.buenoConducta();
}

class Empleado{
  var id;
  var nombre;
  var salario;
  void calcularSalario(){
    print('Salario del empleado es ${salario*5.5}');
  }
}

class Conducta{
  void buenoConducta(){
    print('El empleado se comporto correctamente');
  }
}

class Chofer implements Empleado, Conducta{
  var id=1;
  var nombre="Cami";
  var salario=500000;

  @override
  void calcularSalario() {
    print('Salario del empleado es ${salario*5.5}');
  }

  @override
  void buenoConducta() {
    print('El empleado se comporto correctamente');
  }
}

class Cajero implements Empleado,Conducta{
  var id=2;
  var nombre="Rafa";
  var salario=500000;

  @override
  void calcularSalario() {
    print('Salario del empleado es ${salario*5.5}');
  }

  @override
  void buenoConducta() {
    print('El empleado se comporto adecuadamente');
  }

}```

cuando solo hereda una clase es herencia y si hereda de dos o mas clases se llama mixins

Aqui les dejo lo que faltaba implementar del codigo

  Recaudador recaudador = Recaudador();
  piloto.idd = 2;
  piloto.nombre = 'Joseph';
  piloto.salario = 120;
  piloto.CalcularSalario();
  piloto.buenaConducta();```

Estas son todas las clases

main(List<String> argumentos){
  Chofer chofer = Chofer(); //esto es un objeto
  //estos son sus atributos
  chofer.idd = 1;
  chofer.nombre = 'Roberto';
  chofer.salario = 100.0;
  chofer.vehiculoAsignado = 'de trabajo';
  chofer.CalcularSalario();

  Vendedor vendedor = Vendedor();
  vendedor.idd = 2;
  vendedor.nombre = 'Moises';
  vendedor.salario = 500.0;
  vendedor.idCliente = 'a una persona.';
  vendedor.CalcularSalario();

  Conductor conductor = Conductor();
  conductor.idd = 1;
  conductor.nombre = 'Luis';
  conductor.salario = 100;
  conductor.CalcularSalario();
  conductor.actividad();

  Cajero cajero = Cajero();
  cajero.idd = 2;
  cajero.nombre = 'Jesus';
  cajero.salario = 100;
  cajero.CalcularSalario();
  cajero.actividad();

  Piloto piloto = Piloto();
  piloto.idd = 1;
  piloto.nombre = 'Jesus';
  piloto.salario = 100;
  piloto.CalcularSalario();
  piloto.buenaConducta();

  Recaudador recaudador = Recaudador();
  piloto.idd = 2;
  piloto.nombre = 'Joseph';
  piloto.salario = 120;
  piloto.CalcularSalario();
  piloto.buenaConducta();

}

  class Trabajador{
    var idd;
    var nombre;
    double salario;

    void CalcularSalario(){
      print('El trabajador tiene un salario de: ${salario*5.5}');
    }
  }
//la palabra reservada extends se coloca cuando quieres heredar otra clase
  class Chofer extends Trabajador{
    String vehiculoAsignado;
    void manejarVehiculo(){
      print('Manejando...');
    }

  }
  class Vendedor extends Trabajador{
    String idCliente;
    void venderAcliente(){
      print('Vender...');
    }
  }


  //CLASES ABSTRACTAS
  abstract class Abstracta{
    var idd;
    var nombre;
    double salario;

    void CalcularSalario(){
      print('El trabajador tiene un salario de: ${salario*5.5}');
    }
    void actividad();
  }

  class Conductor extends Abstracta{
    var vehiculo;
    void manejar(){
      print('manejando...');
    }
    @override //esto te permite implementar el metodo de la clase padre en la clase hija
    void actividad(){
      print('pasear por la ciudad');
    }
  }

  class Cajero extends Abstracta{
    var cajaAsignada;
    void cobra(){
      print('esta cobrando');
    }
    @override
    void actividad() {
      print('cobrar a los clientes');
    }
    @override
    void CalcularSalario() {
      print('El trabajador tiene un salario de: ${(salario * 5.5) + 100}');
    }
  }



  //INTERFACES IMPLICITAS
class Emprededor{
  var idd;
  var nombre;
  double salario;

  void CalcularSalario(){
    print('El trabajador tiene un salario de: ${salario*5.5}');
  }
}
class Conducta{
  void buenaConducta(){
    print('El empleado se comporto bien');
  }
}
//implements nos permite tomar los atributos de todas las otras clases
class Piloto implements Emprededor, Conducta{
  var idd = 1;
  var nombre = 'Charlie';
  var salario = 100;
  @override
  void CalcularSalario() {
    print('El trabajador tiene un salario de: ${salario*5.5}');
  }
  @override
  void buenaConducta() {
    print('El empleado se comporto bien');
  }
}
class Recaudador implements Emprededor, Conducta{
  var idd = 2;
  var nombre = 'Diego';
  var salario = 120;
  @override
  void CalcularSalario() {
    print('El trabajador tiene un salario de: ${salario*5.5}');
  }
  @override
  void buenaConducta() {
    print('El empleado se comporto bien');
  }
}





class Ciriaco{
  String nombre;
  double _horas; //esta es una variable privada

  /*//set sirve para asignar un valor
    void set horasLaboradas(double horas){
      _horas = horas / 8;
    }

    //get es para tomar el valor
    double get horasLaboradas{
      return _horas;
    }*/

  //esta es una manera mas facil de utilizar set y get
  void set horasLaboradas (double horas)=> _horas = horas / 8;

  double get horasLaboradas => _horas;
}
//Dart no tiene sintaxis de interfaces como en otros lenguajes
//Una clase normal puede funcionar como una interfaz a esto se le llama interfaz implicita
//Puedes implementar multiples clases utilizando clases como interfaz
main(List<String> args) {
  Chofer chofer = Chofer(1, 'Roberto', 100.0);
  chofer.buenaConducta();
  chofer.calcularSalario();

  Cajero cajero = Cajero(2, 'Juan', 120.0);
  cajero.buenaConducta();
  cajero.calcularSalario();
}

class Empleado {
  var id;
  var nombre;
  var salario;

  void calcularSalario() {
    print('EL salario de el empleado es ${salario * 5.5}');
  }
}

class Conducta {
  void buenaConducta() {
    print('El empleado se comporto correctamente');
  }
}

//Con implements nos ayudara a poder ocupar lo de las otras clases en este caso dos
//Si se ocupa extends solo se puede heredar de una clase
class Chofer implements Empleado, Conducta {
  @override
  var id;

  @override
  var nombre;

  @override
  var salario;

  Chofer(this.id, this.nombre, this.salario);

  @override
  void buenaConducta() {
    print('El empleado se comporto inadecuadamente');
  }

  @override
  void calcularSalario() {
    print('EL salario de el empleado es ${salario * 5.5}');
  }
  
}

class Cajero implements Empleado, Conducta {
  @override
  var id;

  @override
  var nombre;

  @override
  var salario;

  Cajero(this.id, this.nombre, this.salario);

  @override
  void buenaConducta() {
    print('El empleado se comporto correctamente con los clientes');
  }

  @override
  void calcularSalario() {
    print('EL salario de el empleado es ${salario * 5.5}');
  }
  
}

Es necesario utilizar todos los atributos en una interfaz y se utiliza con la palabra implement

Ejercicio de la clase con el objeto que faltaba.

void main() {
  //Interfaces implicitas
  /** Una clase normal puede funcional como una interfaz, a esto se le llama interfaz implicita.
   * Para que la interfaz implicita sea descrita correctamente, la clase debera de definir todos los miembros de las clases que va    a impletamentar. En dart a esto se lo llama Mixings y en otros lenguages se lo conoce como multiherencia 
   * **/
  
  //Instanciamos clases hijas
  Chofer chofer = Chofer()
    ..id = 1
    ..nombre = "Pepe"
    ..salario = 100;
  chofer.calcularSalario();
  chofer.buenaConducta();
  
  Cajero cajero = Cajero()
    ..id = 2
    ..nombre = "Pepa"
    ..salario = 100;
  cajero.calcularSalario();
  cajero.buenaConducta();
  
}



class Empleado {
  //Variables de instancia
  int id;
  String nombre;
  double salario;
  
  //Metodo regular
  void calcularSalario() {
    print("El salario del empleado $nombre es: ${salario * 5.5}");
  }
}


class Conducta {
  
  //Metodo regular
  void buenaConducta() {
    print("El empleado se comporto correctamente");
  }
}



class Chofer implements Empleado, Conducta {
  //Se debe implementar los miembros de las demas clases que estoy implementado
  
  int id;
  String nombre;
  double salario;
  
  //Sobrescribimos los metodos de las clases que implemento
  
  @override
  void calcularSalario() {
    print("El salario del empleado $nombre es: ${salario * 5.5}");
  }
  
  @override
  void buenaConducta() {
    print("El empleado $nombre se comporto inadecuadamente");
  }
  
}


class Cajero implements Empleado, Conducta {
  //Se debe implementar los miembros de las demas clases que estoy implementado
  
  int id;
  String nombre;
  double salario;
  
  @override
  void calcularSalario() {
    print("El salario del empleado $nombre es: ${salario * 5.5 + 100}");
  }
  
  @override
  void buenaConducta() {
    print("El empleado $nombre se comporto adecuadamente");
  }
}

Al usar interfaces implicitas debemos reutilizar todas los atributos y metodos especificados en las interfaces implicitas(no tiene una palabra reservada que las identifique son clases comunes o abstractas)

Buenas noches chicos/as!
Les aclaro que el tema de Mixings es un poquito diferente a lo que tiene que ver con las Interfaces Implícitas ya que estas nos permiten hacer que nuestras clases hijas (clase implícita), tome obligatoriamente el valor de las clases a las que la estoy implementando.

Los mixings por su parte, son una forma de reutilizar código de una clase en múltiples clases con la genialidad del uso de herencia única.

Les envío los enlaces en donde podrán ver toda esta información acerca de los Mixings en Dart y a su vez el código que pude hacer con el tema de Herencia y Mixings.

Enlaces:
En: (https://medium.com/flutter-community/dart-what-are-mixins-3a72344011f3)
Es: https://medium.com/comunidad-flutter/dart-qué-son-los-mixins-5f2ab880a4ce

Código del ejercicio de mixings con uso de Mixings (valga la redundancia):

void main() {
  //Ejercicio sober mixings
  //Link de referencia: https://medium.com/flutter-community/dart-what-are-mixins-3a72344011f3
  //Los mixings son una forma de reutilizar codigo de una clase en multiples clases, no existe la herencia multiple con este uso

  //Instancias
  Duck pato1 = new Duck();
  pato1.fly();
  pato1.swim();
  pato1.walk();
  pato1.action();

  //Murcielago
  Bat batman = new Bat();
  batman.fly();
  batman.walk();
  batman.action();

  //Gato
  Cat gatito = new Cat();
  gatito.walk();
  gatito.action();
}

//El abstract no permitira clases de la instancia Animal
abstract class Animal {} //Superclase

//Clase mamifero
abstract class Mammal extends Animal {
  String nombre;
}

//Clase ave
abstract class Bird extends Animal {}

//Clase pez
abstract class Fish extends Animal {}

//Definimos clases que permitiran mezclar a cada animal con su unica o varias acciones
abstract class Flying {
  //Metodo regular
  void fly() => print("I'm flying...");
}

abstract class Walking {
  //Metodo regular
  void walk() => print("I'm walking...");
}

abstract class Swimming {
  //Metodo regular
  void swim() => print("I'm swimming...");
}

//Creamos los animales y mezclamos las clases que comparten
class Dolpin extends Mammal with Swimming {
  String nombre = "Delfin";

  void action() => print('Soy un $nombre y como plancton!');
}

class Bat extends Mammal with Walking, Flying {
  String nombre = "Batman";

  void action() => print('Soy un $nombre y como guasones!');
}

class Cat extends Mammal with Walking {
  String nombre = "Gato";

  void action() => print('Soy un $nombre y como atun!');
}

class Dove extends Bird with Walking, Flying {
  String nombre = "Paloma";

  void action() => print('Soy un $nombre y como trigo!');
}

class Duck extends Bird with Flying, Walking, Swimming {
  String nombre = "Pato";

  void action() => print('Soy un $nombre y como semillas!');
}

class Shark extends Fish with Swimming {
  String nombre = "Tiburon";

  void action() => print('Soy un $nombre y como peces!');
}

class FlyingFish extends Fish with Swimming, Flying {
  String nombre = "Pez volador";

  void action() => print('Soy un $nombre y como calamares!');
}

Código del ejercicio de mixings con herencia “normal”:

void main() {
  //Ejercicio sober mixings
  //Link de referencia: https://medium.com/flutter-community/dart-what-are-mixins-3a72344011f3
  //Los mixings son una forma de reutilizar codigo de una clase en multiples clases, no existe la herencia multiple con este uso

  //Instanciamos clases hijas
  Murcielago batman = Murcielago()
    ..id = 1
    ..apodo = "Batman"
    ..numeroPatas = 2;
  batman.caminar();
  batman.volar();
    
  
}

abstract class Animal {
  //Variables de instancia
  int id;
  String apodo;
  
}

abstract class Mamifero extends Animal {
  //En comun
  int id;
  String apodo;
  
  //Propiedades unicas
  int numeroPatas;
  
  //Metodo regular para caminar
  void caminar() {
    print("El animal $apodo puede Caminar...");
  }
  
  //Metodo regular para nadar
  void nadar() {
    print("El animal $apodo Nadar...");
  }
  
  //Metodo regular para volar
  void volar() {
    print("El animal $apodo Volar...");
  }
  
  
}

class Murcielago extends Mamifero {
  //Se debe implementar los miembros de las demas clases que estoy implementado
  int id;
  String nombre;
  
  int numeroPatas;
  
  //Metodo que heredo de la clase Mamifero para Muercielago
  void caminar() {
    print("El animal $apodo puede Caminar...");
  }
  
  //Metodo regular para volar
  void volar() {
    print("El animal $apodo Volar...");
  }
    
}

Listo, logre implementarlo a los dos tipos de empleados

void main() {
 Chofer chofer = new Chofer();
  chofer.id = 1;
  chofer.nombre = 'Roberto';
  chofer.salario = 100;
  chofer.buenaConducta();
  chofer.calcularSalario();
  
 Cajero cajero = new Cajero();
  cajero.id = 2;
  cajero.nombre = 'David';
  cajero.salario = 120;
  cajero.buenaConducta();
  cajero.calcularSalario();
}

class Empleado {
  var id;
  var nombre;
  var salario;
  
  void calcularSalario() {
    print('El salario del empleado es ${salario * 5.5}');
  }
}

class Conducta {
  void buenaConducta() {
    print('El empleado se comporto correctamente');
  }
}

class Chofer implements Empleado, Conducta {
  var id = 1;
  var nombre = 'Roberto';
  var salario = 100;
  
  @override
  void calcularSalario() {
    print('El salario del empleado ${nombre} es ${salario * 5.5}');
  }
  
  @override
  buenaConducta() {
    print('El empleado se comporto inadecuadamente');
  }
  
}

class Cajero implements Empleado, Conducta {
  var id = 2;
  var nombre = 'David';
  var salario = 120;
  
  @override
  void calcularSalario() {
    print('El salario del empleado ${nombre} es ${salario * 5.5}');
  }
  
  @override
  buenaConducta() {
    print('El empleado se comporto adecuadamente');
  }
}

Dart incluye una forma de herencia adicional es super poderosa, se conoce como mixins, consiste en poder ‘extender’ desde varias clases. Si utilizan extend solo pueden extender de una clase, si utilizan implement deben de declarar todos los metodos de la super clase, con mixins no, funciona más parecido a extend pero con la posibilidad de incluir varias super clases
class Chofer with Empleado, Conducta { ... }