Interfaces implícitas

Resumen

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.

Facundo Nicolás García Martoni

teacher•

++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.

Sebastián Pineda Duque

student•

Excelente definición de una interfaz. Muchas gracias por el aporte.

Marco Alexander Mateo Mateo

student•

¡Gracias! :)

David Galicia

student•

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

Diego Daniel Pedroza Perez

student•

Gracias por este recurso!

Carlos Nassif Trejo Garcia

student•

**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}');
  }
  
}```

Sergio Armando Medina Chaparro

student•

¡Muchas gracias por los apuntes! Me sirvió harto :)

David Gonzalez

student•

Pero al crear interfaces implícitas con <implements>, no se rompe con el principio de Herencia que sería no repetir código??????

Luis Diego Aguilar Ruiz

student•

Piensa que podria ser util si necesitas utilizar los atributos de más de una clase, en vez de crear una nueva clase con todos los atributos puedes crear esta nueva clase y reutilizarla en un futuro :)

Leonardo Antonio Sánchez López

student•

la diferencia netre interfaces y clase abstracta es que en la clase abstracta no se deben utilizar todos los atributos?

Cristian Antonio García González

student•

Hola @leonardo-sanchez.

Una clase abstracta puede heredar de una sola clase (abstracta o no) mientras que una interfaz puede extender varias interfaces de una misma vez.

Una clase abstracta puede tener métodos que sean abstractos o que no lo sean, mientras que las interfaces sólo y exclusivamente pueden definir métodos abstractos.

Y hay muchas mas diferencia entre interfaces y clase abstracta aparte de las ya citadas por eso te dejo aquí el link en donde saque la información y las respuestas que han hecho a alguien que pregunto lo mismo que tú, para que puedas profundizar un poco mas sobre esto de las diferencia de las interfaces y clases abstractas.

Espero que mi comentario te sea de utilidad y recuerda "Nunca pares de aprender."

Juan Pablo Rodríguez Morales

student•

¿Para que sirve definir el método en la interfaz si igual va a ser necesario el override después?

Roger Manuel Serrano Ayala

student•

Yo también me pregunto lo mismo.....

Luis Salas

student•

Hola La utilidad de las interfaces es indicar/recordar qué métodos debe obligatoriamente implementar una Clase (aunque no tienen por qué comportarse del mismo modo). En el caso de esta clase, el método calcularSalario() perfectamente podría variar según el tipo de empleado y variables adicionales (horas extras, bonos, propinas) , por eso POO nos permite declarar nuevamente el mismo método para adaptarlo a las características de cada objeto, y a su vez, funcionando como "recordatorio" acerca de los métodos que sí o sí deben de estar dentro de las clases hijas que hereden de una interfaz o clase abstracta específica. Dejo por acá un link que me resultó bastante útil para comprender las diferencias entre clases abstractas e interfaces: https://es.stackoverflow.com/questions/107742/cu%c3%a1l-es-la-diferencia-entre-interfaz-y-clase-abstracta-en-java Saludos

Francisco Peñalo Feliz

student•

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

Sebastian Garcia Ospina

student•

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");
}

Christopher Chirino

student•

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

Jhon Carlos Romo Ramirez

student•

Gracias!

Juan Pablo Fernandez

student•

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');
  }
}```

Carlos Alex Becerra Chavita

student•

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

Elias Ojeda Medina

student•

Indica la sobre-escritura de un método heredado por una clase abstracta o una interfaz. Esto significa que su implementación puede ser distinta en cada clase donde está herede.

Espero haberme explicado. Saludos!

Félix Alejandro Zelaya Orellana

student•

Te permitirá sobreescribir los metodos de la clase padre con lo que desees implementar en la hija

Agustin Aníbal Ducca Pantaleón

student•

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.

Angel Mambel

student•

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}');
  }
}

Edisson Castro

student•

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?). :-P

Sebastián Pineda Duque

student•

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

Mariandrea Cruz

student•

hola, el nombre correcto es "implícitas", ya corregimos el slide. Gracias por avisarnos.

Francisco Peñalo Feliz

student•

Ya corrigieron el error del slide pero el profesor aun dice hablará de interfaces EXPLICITAS.

Christian Ricardo Conchari Cabrera

student•

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:

Oier Solabarrieta Egues

student•

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:

Alain Noda Sanchez

student•

Hola, aun no me queda claro la utilizacion del "@override" en la clase "Chofer". Podria alguien explicarmelo por favor?. Gracias

Pedro Lumbre Cama

student•

@verride es un decorador que te dice que puedes sobreescribir ese metodo que viene del padre. lo vez cuando implementas una interface o aplicando herencia.

Jorge Hernandez

student•

Te dice que estas sobre escribiendo un método , a mi me gusta explicarlo mas sencillo que tecnicamente, por ejemplo: Si en tu clase padre tienes

class A {
  void miMetodo(){
   	print("si ñor")
   }
}
class B:A{
//Sobre escribimos el método del padre A
 @override
  void miMetodo{
    print("ño ñor");	
   }
}

Joshua Daniel Rios Cervantes

student•

Por que le pone valores a Los atributos

Oscar Téllez

student•

Creo que no es necesario, si intentas quitarlos igual va a funcionar correctamente, puede que haya sido un despiste del profesor

Hassan Hammad

student•

Hola, alguien podria aclarar las diferecias y cuando es mejor usar clases abstractas e interfaces?

Gracias

Santiago Colusso

student•

Hola! eso se explica bien a detalle en el curso de Programacion Orientada a Objetos. Te dejo el link aca, te lo recomiendo mucho! Curso POO

Interfaces implícitas

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