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

Julia en ejemplos no. 3: Creando "clases"

Retomando los ejemplos de código en Julia en esta ocasión conoceremos como crear estructuras Type. Semejantes  a las clases de lenguajes como C, Python y Java.

 ¿Cómo creo una "clase"?
Con la siguiente sintaxis:

type Nombre_Tipo
  ...
  ...
end

Ejemplo. Crear una "clase" en Julia introduciendo valores  y mostrarlas en pantalla.

Definiremos entonces:

• Una estructura Type con el nombre de "Objeto"
• Un método llamado "propiedades"
• Un método para mostrar las "propiedades"
• Una función externa que nos permita introducir datos

 #la "clase" Objeto
type Objeto
    propiedades::Function
 
#constructor
    function Objeto()
        this = new()
 #método para imprimir valores
        function ObtenerDatos(altura::Int64,ancho::Int64,grosor::Int64)
            println("Objeto{alto:",altura,"ancho:",ancho,"grosor:",grosor,"}")
        end

        this.propiedades = ObtenerDatos

        return this
    end
end

#función externa para introducir datos
function entrada(prompt::String="")
   print(prompt)
   chomp(readline())
end

#bloque principal del programa
begin
    objeto = Objeto()#instancia
    altura = int(entrada("Introduce altura:"))
    ancho = int(entrada("Introduce ancho:"))
    grosor = int(entrada("Introduce grosor:"))
    objeto.propiedades(altura,ancho,grosor)
end

Ejecución del código: julia Clase.jl

Links
http://chrisvoncsefalvay.com/2015/02/14/types-and-inheritance.html
https://thenewphalls.wordpress.com/2014/02/19/understanding-object-oriented-programming-in-julia-part-1/

Programando en Perl no. 2

1. Uso de clases: En este ejemplo se va crear dos archivos: Alumno.pm (esta es la clase) y usoAlumno.pl. Se definen 7 atributos:

• nombre
• apellidos
• edad
• dirección
• ciudad
• teléfono y
• email

Se crea una función para mostrar los datos.

Alumno.pm

1. Creamos la clase Alumno:

package Alumno;
use strict; 

sub new{
 my $this=shift; 
     my $class = ref($this) || $this; 

     my $self={}; 
     $self ->{NOMBRE} =undef ; 
     $self ->{APELLIDOS} =undef ;
     $self ->{EDAD}   =0 ; 
     $self ->{DIRECCION}   =undef ; 
     $self ->{CIUDAD}   =undef ; 
     $self ->{TELEFONO}   =undef ; 
     $self ->{EMAIL}   =undef ;    

     bless $self, $class; 
     return ($self);
}

sub nombre{
       my $self=shift;
       $self->{NOMBRE}=shift if (@_);
       return $self->{NOMBRE};
  }

  sub apellidos{
       my $self=shift;
       $self->{APELLIDOS}=shift if (@_);
       return $self->{APELLIDOS};
  }

  sub edad{
       my $self=shift; 
       $self->{EDAD}=shift if (@_);
       return $self->{EDAD};
  }

  sub direccion{
       my $self=shift;
       $self->{DIRECCION}=shift if (@_);
       return $self->{DIRECCION};
  }

  sub telefono{
       my $self=shift; 
       $self->{TELEFONO}=shift if (@_);
       return $self->{TELEFONO};
  }

  sub email{
       my $self=shift; 
       $self->{EMAIL}=shift if (@_);
       return $self->{EMAIL};
  }

  sub ciudad{
       my $self=shift; 
       $self->{CIUDAD}=shift if (@_);
       return $self->{CIUDAD};
  }

  sub DESTROY {
        my $self=shift; 
        delete ($self->{NOMBRE});  
        delete ($self->{EDAD}); 
        delete ($self->{APELLIDOS});  
        delete ($self->{EMAIL});
        delete ($self->{DIRECCION});  
        delete ($self->{TELEFONO}); 
        delete ($self->{CIUDAD});
  }

1;

2. El archivo "usoAlumno.pl" que emplea la clase Alumno:

usoAlumno.pl

use Alumno;

$alumno=Alumno->new();
$alumno->nombre("horacio");
$alumno->apellidos("Sanchez");
$alumno->edad(31);
$alumno->direccion("aldama 34");
$alumno->ciudad("San Luis");
$alumno->email("alguien@gommail.com");
$alumno->telefono("722156444");

print "Hola: ".$alumno->nombre." ".$alumno->apellidos."  tienes: ".$alumno->edad."  de edad, vives en ".$alumno->direccion."  ".$alumno->ciudad." \n ";
print "tu email es: ".$alumno->email."  tu telefono es: ".$alumno->telefono."  \n";

Para ejecutar: perl usoAlumno.pl