Herencia en Kotlin

Herencia en Kotlin
En este ejemplo veremos herencia, un concepto base en el paradigma orientado a objetos. En Herencia una clase Base (clase padre o superclase) puede heredar atributos (variables de instancia) y su comportamiento (métodos).

¿Cómo creamos herencia en Kotlin?

open class Electronico{}

data class Computadora: Electronico(){}

Esto parece sencillo, pero ¿qué pasa cuando las clases tienen atributos? Enseguida veremos un ejemplo.

Crearemos dos clases:

• Una clase Padre (Padre.kt) y
• Una clase hija (Estudiante.kt)

Persona.kt

package com.codemonkey.clases;

open class Persona(open val nombre:String, open val apellidos:String, open val edad:Byte){
    init{
        println("objeto Persona creado e inicializado");
    }

    var Color:String = "Blanco";

    constructor(nombre:String, apellidos:String, edad:Byte, color:String): this(nombre,apellidos,edad){
        Color = color;
    }
}

Persona (Superclase) posee tres atributos en el constructor principal: nombre,apellidos y edad. Enel segundo constructor añadimos un nuevo atributo: color.

Estudiante.kt

package com.codemonkey.clases;

data class Estudiante(override val nombre:String,override val apellidos:String,override val edad:Byte, val id:Long):Persona(nombre,apellidos,edad){
    init{
        println("objeto Estudiante creado e inicializado");
    }

    init{
        println("Estudiante ${nombre} ${apellidos}");
    }
}

Como se puede observar no solo hereda sus atributos sino que podemos añadir uno propio. En esta caso es el id del Estudiante. También es importante notar el bloque de código que empieza con init. Este se ejecutará al inicio (parecido al constructor).

main.kt

package com.codemonkey;

import com.codemonkey.clases.*

object Main {
   @JvmStatic
   fun main(args:Array<String>){
var id=10000L
     var nombre = "Carolina"
     var apellidos = "Contreras Lopez"
     var edad:Byte = 10
     var estudiante:Estudiante = Estudiante(nombre,apellidos,edad,id);
     println(estudiante)

     nombre = "Juan"
     apellidos = "Estevez"
     var tuEdad:Byte=33;
     var color = "Castaño"
     var persona = Persona(nombre,apellidos,tuEdad,color);
     println("Nombre compledo ${persona.nombre} ${persona.apellidos}");
     println("Edad ${persona.edad} años, color de cabello: ${persona.Color}");
}
}

Post anteriores:
http://codemonkeyjunior.blogspot.com/2019/01/arreglos-listas-funciones-y-clases-en.html
http://codemonkeyjunior.blogspot.com/2019/01/conociendo-kotlin.html

Programando en Ruby ... no. 6

En esta serie de programación en Ruby hemos visto muchos ejemplos, desde simples códigos para imprimir un valor y programación orientada a objetos.

En este post escribiremos un archivo llamado models.rb dentro de un directorio denominado clases.
models.rb

#clase padre
class Animal 
  attr_accessor :no_patas
   def initialize(no_patas)
       @no_patas=no_patas
        puts "objeto Animal creado"
  end
end

#clase hija
class Aracnido  < Animal
  attr_accessor :especie
   def initialize(no_patas, especie)
       super(no_patas)
       @especie=especie
        puts "objeto Aracnido creado"
  end
end

#clase hija
class Ave   <  Animal
  attr_accessor :color
   def initialize(no_patas, color)
        super(no_patas)
       @color=color
        puts "objeto Ave creado"
  end
end 

Este archivo nos servirá para escribir nuestras clases (Animal, Aracnido y Ave). Donde Animal es la clase padre y las demás son las clases hijo.

Ahora debemos crear un archivo llamado main.rb donde importaremos este archivo.

require_relative 'clases/models'

def main
 begin
  animal = Animal.new(4)
  ave = Ave.new(2,'Verde')
  aracnido = Aracnido.new(8,'Delatore Riebelle')
 rescue Exception => e
  puts "Ha ocurrido una excepcion: #{e}"
 end
end

#main
main

Usamos require_relative para indicar la ruta donde se encuentran las clases con las que queremos trabajar.

Para correr el archivo abrimos una terminal y escribimos:
ruby main.rb

Groovy ... en ejemplos no. 4

Herencia
Al definir clases esperamos que estas cumplan todos los  requisitos necesarios, ni más ni menos. Si creamos una clase llamada Imagen, esta debe tener atributos que la identifiquen: nombre, tamaño, y url.

class Imagen{
     String nombre
     String tamanyo
     String url
}

Ahora una clase llamada TestImage con método main.

class TestImage{
     static main(args){
      def imagen=new Imagen(nombre:"Groovy.jpg",tamanyo:"45kb",url:"http://misimagenes.com.mx")  
   }

  //también podría haber sido así
  def imagen=new Imagen()
   imagen.with{
nombre="Groovy.jpg" 
tamanyo="45kb" 
url="http://misimagenes.com.mx"
   }

}

Al parecer no existe problema alguno, esta clase cumple su objetivo. Ahora ¿qué pasaría si necesitaramos agregarle alguna 'funcionalidad' extra? para ello usaremos la herencia.

Vamos a crear:

• Una clase base (o padre) llamada Heroe
• Dos clases hijas llamadas Superman y Batman 
• Dos interfaces llamadas Superpoderes y Habilidades
• Una clase llamada TestHeroe

//clase base
class Heroe{}
//clase hija hereda de clase padre
class SuperHeroe extends Heroe{}
//hace uso de los métodos de la interface Superpoderes
class Superman extends SuperHeroe implements Superpoderes{
    @Override
    public void vuelo(){
        println "Superman vuela"
    }

    @Override
    public void velocidad(){
        println "Superman corre a gran velocidad"
    }

    @Override
    public void fuerza(){
        println "Superman posee gran fuerza"
    }
}

//hace uso de la interface Habilidades
class Batman extends SuperHeroe implements Habilidades{
    @Override
    public void karate(){
        println "Batman sabe karate"
    }
}

interface Superpoderes{
    public abstract void vuelo()
    public abstract void velocidad()
    public abstract void fuerza()
}

interface Habilidades{
    public abstract void karate()
}

class TestHeroe{
    static main(args) {
        Superman superman=new Superman()
        Batman batman=new Batman()

        superman.vuelo()
        superman.velocidad()
        superman.fuerza()

        batman.karate()
    }
}

Salida:
Superman vuela
Superman corre a gran velocidad
Superman posee gran fuerza
Batman sabe karate
 
Ejecutamos: groovy TestHeroe.groovy

Código:http://www.pasteall.org/53722/groovy

Scala ... ejemplos sencillos no. 6

Tipado dinámico de Scala
Scala es un lenguaje que combina la programación orientada a objetos y la funcional,además es de tipado estático, esto quiere decir que se debe tener cuidado a la hora de definir variables (su tipo).

Si defines una variable es necesario hacer uso de var y val.

var nombre:String="Alfonso"
val nombre_estatico:String="Mariana"

Si tratamos de reasignar valores obtendremos:

nombre="Alfonso Quaron" //es válido,por que usamos var
nombre_estatico="Mariana Alcantara" //no es válido, usamos val

Ahora creamos dos clases:

• Base
• Subclase

class Base(val nombre:String=null){}

class SubClase(override val nombre:String=null) extends Base(nombre){}

object Scalar{
    def main(args:Array[String]):Unit={
       val base=new Base() //se puede tomar como null
       val sub=new SubClase()
       //si trato de de reasignarl valor al miembro nombre ocurrirá un error
       base.nombre="Base"
      sub.nombre="SubClase"
   }
} 

Entonces lo correcto sería:

val base=new Base("Base")
 val sub=new SubClase("SubClase")

Console.println(base.nombre)
Console.println(sub.nombre)

Resultado:
Base
SubClase

Lenguajes como Python ,  Ruby y  Groovy permiten reasignar valores a las variables.

En Python:
dato="Las serpientes se arrastran por el piso"
print type(dato)

#ahora cambiamos su 'tipo' y valor
dato=12.90
print type(dato)

En Ruby:
dato="Un diamante en bruto"
print dato.class

#ahora cambiamos su 'tipo' y valor
dato=23.0
print dato.class

 En Groovy:
dato="Es un ambiente muy Groovy"
dato instanceof String  //nos da true

dato=123
dato instanceof Integer //nos da true

En conclusión tenemos:

Tipado dinámico

• Se permite reasignar valores
• El tipo de dato no es fijo 

Tipado estático

• No se permite reasignar valores
• El tipo de dato no debe cambiar

Programando en Ruby ... no. 4

Herencia en Ruby

En esta ocasión crearemos una clase base llamada Persona y dos clases hijas:

• Alumno y
• Profesor

Empezamos creando la clase Persona, con dos propiedades:

• nombre y
• edad

class Persona
  attr_accessor :nombre , :edad


  def initialize(nombre,edad)
    @nombre, @edad=nombre, edad
  end

#setters y getters

#setter
  def nombre=(nombre)
    @nombre=nombre
  end

#getter
  def nombre
    @nombre
  end

#setter
  def edad=(edad)
    @edad=edad
  end

#getter
  def edad
    @edad
  end

end

¿Cómo se puede heredar en Ruby?
Se debe seguir esta síntaxis:
claseBase < claseHija
      ...
      ...
end

Ahora las clases hijas:Alumno y Profesor:

class Alumno < Persona
  attr_accessor  :no_cta

  def initialize(no_cta)
    @no_cta=no_cta
  end

 #setter
  def no_cta=(no_cta)
    @no_cta=no_cta
  end

#getter
  def no_cta
    @no_cta
  end

end

class Profesor < Persona
  attr_accessor :materias

  def initialize(materias)
    @materias=materias
  end

#setter
  def materias=(materias)
    @materias=materias
  end

#getter
  def materias
    @materias
  end

end

#main
begin
  alumno=Alumno.new(2132)
  alumno.nombre=("Andrea Landa")
  alumno.edad=(18)

  profesor=Profesor.new(["matematicas","fisica"])
  profesor.nombre=("Mario Pedrosa")
  profesor.edad=(45)

  puts "Alumno:"
  puts "\tno. cta: #{alumno.no_cta}"
  puts "\tnombre: #{alumno.nombre}"
  puts "\tedad: #{alumno.edad}"

  puts "Profesor:"
  puts "\tmaterias: #{profesor.materias}"
  puts "\tnombre: #{profesor.nombre}"
  puts "\tedad: #{profesor.edad}"

  
rescue Exception => e
  puts "Error: #{e}"
end

Puedes guardar el archivo como diamante.rb

Links
http://www.cristalab.com/blog/por-que-aprender-ruby-on-rails-c109181l/