¿Cómo hacemos las clases en Julia?

Puede que se de el caso de que encuentres algún error en tu código o trabajo, recuerda probar siempre en un entorno de testing antes aplicar el código al proyecto final.

Solución:

Julia no tiene clases. En su lugar, definimos nuevos tipos y luego definimos métodos en esos tipos. Los métodos no son “propiedad” de los tipos en los que operan. En cambio, se puede decir que un método pertenece a una función genérica del mismo nombre que el método. Por ejemplo, hay muchas versiones (“métodos”) del length función; juntos forman la función genérica length.

Aquí hay un ejemplo extendido del enfoque “Julian” para programar con tipos y métodos. Los nuevos tipos se declaran utilizando el struct palabra clave:

struct Person
    name::String
    age::Int64
end

Ahora podemos definir métodos en el Person escribe:

name(p::Person) = p.name
age(p::Person) = p.age

bio(p::Person) = println("My name is ", name(p)," and I am ", age(p), " years old.")

Los métodos se pueden definir para diferentes combinaciones de tipos de argumentos. Para ilustrar esto, primero definamos algunos tipos nuevos:

abstract type Pet end

struct Cat <: Pet
    name::String
    color::String
end

name(c::Cat) = c.name
color(c::Cat) = c.color
species(::Cat) = "cat"

struct Dog <: Pet
    name::String
    color::String
end

name(d::Dog) = d.name
color(d::Dog) = d.color
species(::Dog) = "dog"

bio(p::Pet) = println("I have a ", color(p), " ", species(p), " named ", name(p), ".")

struct Plant
    type::String
end

type(p::Plant) = p.type
bio(p::Plant) = println("I have a ", type(p), " house plant.")

En este punto, podemos ver que hemos definido tres métodos diferentes de un argumento para bio:

julia> methods(bio)
# 3 methods for generic function "bio":
[1] bio(p::Plant) in Main at REPL[17]:1
[2] bio(p::Person) in Main at REPL[4]:1
[3] bio(p::Pet) in Main at REPL[14]:1

Tenga en cuenta el comentario en la salida de methods(bio): "3 métodos para la función genérica 'bio'". Vemos eso bio es un función genérica que actualmente tiene 3 métodos definidos para diferentes firmas de funciones. Ahora agreguemos un método de dos argumentos para bio:

function bio(person::Person, possession)
    bio(person)
    bio(possession)
end

Nótese que esta función es genérica en el possession argumento, ya que la llamada interna a bio(possession) funcionará si el possession es una planta, un gato o un perro! Así que ahora tenemos cuatro métodos totales para bio:

julia> methods(bio)
# 4 methods for generic function "bio":
[1] bio(p::Plant) in Main at REPL[17]:1
[2] bio(p::Person) in Main at REPL[4]:1
[3] bio(p::Pet) in Main at REPL[14]:1
[4] bio(person::Person, possession) in Main at REPL[18]:1

Ahora vamos a crear algunas instancias de nuestros tipos:

alice = Person("Alice", 37)
cat = Cat("Socks", "black")
dog = Dog("Roger", "brown")
plant = Plant("Boston Fern")

Así que finalmente podemos probar nuestro bio métodos:

julia> bio(alice, cat)
My name is Alice and I am 37 years old.
I have a black cat named Socks.

julia> bio(alice, dog)
My name is Alice and I am 37 years old.
I have a brown dog named Roger.

julia> bio(alice, plant)
My name is Alice and I am 37 years old.
I have a Boston Fern house plant.

Nota al margen: los módulos se utilizan principalmente para la gestión de espacios de nombres. Un solo módulo puede contener las definiciones de múltiples tipos y múltiples métodos.

Lo más cercano que se puede llegar a las clases con métodos en Julia es el módulo:

module DogClass

export Dog, bark

struct Dog
    name::String
end

function bark(d::Dog)
    println(d.name, " says woof!")
end

end #MODULE

using .DogClass  # note the . here, means look locally for module, not library

mydog = Dog("Fido")

bark(mydog)

---

---

Utiliza Nuestro Buscador