El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

La Programación Orientada a Objetos (POO) es un paradigma de programación que utiliza "objetos" y sus interacciones para diseñar aplicaciones y programas. Dart, el lenguaje de programación utilizado en Flutter, es un lenguaje orientado a objetos que permite a los desarrolladores crear aplicaciones robustas y escalables.

Conceptos Clave de la POO

Antes de profundizar en la POO en Dart, es importante entender algunos conceptos clave:

Clases y Objetos:
- Clase: Es una plantilla o blueprint para crear objetos. Define las propiedades y comportamientos que los objetos creados a partir de la clase tendrán.
- Objeto: Es una instancia de una clase. Es la entidad real que se crea en la memoria.
Herencia:
- Permite crear una nueva clase a partir de una clase existente. La nueva clase (subclase) hereda las propiedades y métodos de la clase existente (superclase).
Encapsulamiento:
- Esconder los detalles internos de un objeto y exponer solo lo necesario. Esto se logra mediante modificadores de acceso como private y public.
Polimorfismo:
- Permite que una entidad (como una función o un objeto) tome múltiples formas. En Dart, esto se logra mediante la sobrecarga de métodos y la herencia.
Abstracción:
- Permite definir clases abstractas que no pueden ser instanciadas directamente. Estas clases pueden contener métodos abstractos que deben ser implementados por las subclases.

Clases y Objetos en Dart

Definición de una Clase

En Dart, una clase se define utilizando la palabra clave class. Aquí hay un ejemplo básico:

class Persona {
  // Propiedades
  String nombre;
  int edad;

  // Constructor
  Persona(this.nombre, this.edad);

  // Método
  void mostrarInfo() {
    print('Nombre: $nombre, Edad: $edad');
  }
}

Creación de Objetos

Para crear un objeto de la clase Persona, utilizamos el constructor definido en la clase:

void main() {
  // Creando un objeto de la clase Persona
  Persona persona1 = Persona('Juan', 30);
  persona1.mostrarInfo(); // Salida: Nombre: Juan, Edad: 30
}

Herencia en Dart

La herencia se implementa utilizando la palabra clave extends. Aquí hay un ejemplo:

class Empleado extends Persona {
  // Propiedad adicional
  String puesto;

  // Constructor
  Empleado(String nombre, int edad, this.puesto) : super(nombre, edad);

  // Método adicional
  void mostrarPuesto() {
    print('Puesto: $puesto');
  }
}

void main() {
  // Creando un objeto de la clase Empleado
  Empleado empleado1 = Empleado('Ana', 25, 'Desarrolladora');
  empleado1.mostrarInfo(); // Salida: Nombre: Ana, Edad: 25
  empleado1.mostrarPuesto(); // Salida: Puesto: Desarrolladora
}

Encapsulamiento en Dart

En Dart, las propiedades y métodos privados se definen utilizando un guion bajo (_) al inicio del nombre. Aquí hay un ejemplo:

class CuentaBancaria {
  // Propiedad privada
  double _saldo;

  // Constructor
  CuentaBancaria(this._saldo);

  // Método para obtener el saldo
  double obtenerSaldo() {
    return _saldo;
  }

  // Método para depositar dinero
  void depositar(double cantidad) {
    _saldo += cantidad;
  }

  // Método para retirar dinero
  void retirar(double cantidad) {
    if (cantidad <= _saldo) {
      _saldo -= cantidad;
    } else {
      print('Fondos insuficientes');
    }
  }
}

void main() {
  // Creando un objeto de la clase CuentaBancaria
  CuentaBancaria cuenta = CuentaBancaria(1000.0);
  cuenta.depositar(500.0);
  print('Saldo: ${cuenta.obtenerSaldo()}'); // Salida: Saldo: 1500.0
  cuenta.retirar(200.0);
  print('Saldo: ${cuenta.obtenerSaldo()}'); // Salida: Saldo: 1300.0
}

Polimorfismo en Dart

El polimorfismo se puede lograr mediante la herencia y la implementación de interfaces. Aquí hay un ejemplo de polimorfismo mediante la herencia:

class Animal {
  void hacerSonido() {
    print('El animal hace un sonido');
  }
}

class Perro extends Animal {
  @override
  void hacerSonido() {
    print('El perro ladra');
  }
}

class Gato extends Animal {
  @override
  void hacerSonido() {
    print('El gato maúlla');
  }
}

void main() {
  Animal animal1 = Perro();
  Animal animal2 = Gato();

  animal1.hacerSonido(); // Salida: El perro ladra
  animal2.hacerSonido(); // Salida: El gato maúlla
}

Abstracción en Dart

Las clases abstractas se definen utilizando la palabra clave abstract. Aquí hay un ejemplo:

abstract class Figura {
  // Método abstracto
  double calcularArea();
}

class Circulo extends Figura {
  double radio;

  Circulo(this.radio);

  @override
  double calcularArea() {
    return 3.14 * radio * radio;
  }
}

class Rectangulo extends Figura {
  double largo;
  double ancho;

  Rectangulo(this.largo, this.ancho);

  @override
  double calcularArea() {
    return largo * ancho;
  }
}

void main() {
  Figura circulo = Circulo(5.0);
  Figura rectangulo = Rectangulo(4.0, 6.0);

  print('Área del círculo: ${circulo.calcularArea()}'); // Salida: Área del círculo: 78.5
  print('Área del rectángulo: ${rectangulo.calcularArea()}'); // Salida: Área del rectángulo: 24.0
}

Ejercicios Prácticos

Ejercicio 1: Crear una Clase Vehículo

Define una clase Vehiculo con las propiedades marca, modelo y año.
Crea un constructor para inicializar estas propiedades.
Define un método mostrarInfo que imprima la información del vehículo.

class Vehiculo {
  String marca;
  String modelo;
  int año;

  Vehiculo(this.marca, this.modelo, this.año);

  void mostrarInfo() {
    print('Marca: $marca, Modelo: $modelo, Año: $año');
  }
}

void main() {
  Vehiculo vehiculo1 = Vehiculo('Toyota', 'Corolla', 2020);
  vehiculo1.mostrarInfo(); // Salida: Marca: Toyota, Modelo: Corolla, Año: 2020
}

Ejercicio 2: Herencia y Polimorfismo

Define una clase Coche que herede de Vehiculo y añada la propiedad tipoCombustible.
Sobrescribe el método mostrarInfo para incluir la información del tipo de combustible.
Crea una instancia de Coche y llama al método mostrarInfo.

class Coche extends Vehiculo {
  String tipoCombustible;

  Coche(String marca, String modelo, int año, this.tipoCombustible) : super(marca, modelo, año);

  @override
  void mostrarInfo() {
    super.mostrarInfo();
    print('Tipo de Combustible: $tipoCombustible');
  }
}

void main() {
  Coche coche1 = Coche('Honda', 'Civic', 2018, 'Gasolina');
  coche1.mostrarInfo(); // Salida: Marca: Honda, Modelo: Civic, Año: 2018, Tipo de Combustible: Gasolina
}

Conclusión

En esta sección, hemos cubierto los conceptos básicos de la Programación Orientada a Objetos en Dart, incluyendo clases y objetos, herencia, encapsulamiento, polimorfismo y abstracción. Estos conceptos son fundamentales para desarrollar aplicaciones robustas y escalables en Flutter. En el próximo módulo, exploraremos los widgets en Flutter, que son los bloques de construcción esenciales para cualquier aplicación Flutter.

Programación Orientada a Objetos en Dart

Conceptos Clave de la POO

Clases y Objetos en Dart

Definición de una Clase

Creación de Objetos

Herencia en Dart

Encapsulamiento en Dart

Polimorfismo en Dart

Abstracción en Dart

Ejercicios Prácticos

Ejercicio 1: Crear una Clase Vehículo

Ejercicio 2: Herencia y Polimorfismo

Conclusión

Curso de Desarrollo con Flutter

Módulo 1: Introducción a Flutter

Módulo 2: Conceptos Básicos de Programación en Dart

Módulo 3: Widgets en Flutter

Módulo 4: Gestión de Estado

Módulo 5: Navegación y Enrutamiento

Módulo 6: Redes y APIs

Módulo 7: Persistencia y Almacenamiento

Módulo 8: Conceptos Avanzados de Flutter

Módulo 9: Pruebas y Depuración

Módulo 10: Despliegue y Mantenimiento

Módulo 11: Flutter para Web y Escritorio