Cuando decimos programación orientada a objetos, queremos decir que nuestro código está centrado en objetos. Los objetos son instancias de la vida real que se clasifican en varios tipos.
Pongamos un ejemplo para entender esto mejor. Si consideramos una rosa como un objeto, entonces la clase de la rosa será flor. Una clase es como el modelo de un objeto y describe los atributos y el comportamiento de un objeto. los atributos de una flor pueden ser el color, la fragancia o incluso si tiene espinas. estas características son parte de la clase y cada instancia de la clase, es decir, cada objeto de la clase compartiría estos atributos. aunque el valor del atributo puede variar entre diferentes objetos. Tomemos como ejemplo: un lirio. Entonces, si el color de los pétalos del objeto rosa es rojo, entonces para el lirio podría ser blanco. esta es la base de la programación orientada a objetos donde podemos tomar situaciones de la vida real y crear diferentes instancias a partir de ellas.
Ahora veamos cómo podemos definir una clase en Ruby
Sintaxis de la clase:
class classname end
Implementando conceptos de programación orientada a objetos con Ruby
Ruby admite el paradigma OOP al permitir la creación de clases y sus objetos. Como dijimos antes, los objetos son las instancias de una clase y una clase es como los planos del objeto. Una clase enumera los atributos y define el comportamiento del objeto, mientras que el objeto es la representación del mundo real.
Una clase tiene dos partes: datos y métodos.
Entonces, ahora que tenemos una clase Idioma, definamos los atributos como
1) LanguageName
2) TopicName
Ahora tenemos nuestros datos, pero necesitamos una forma de acceder a ellos. Aquí es donde entran nuestros métodos. Los métodos de clase son métodos definidos en la clase que se utilizan para acceder a los diversos datos de nuestra clase. Para implementar en el código, usamos un constructor, que toma los valores de los atributos y los asigna al espacio almacenado para el objeto en particular.
Sintaxis del constructor:
def initialize(x, y)
@x = x
@y = y
end
La función de inicialización se define dentro de la clase y su sintaxis es como una función ordinaria. Puede tomar cualquier cantidad de argumentos. El símbolo @ representa los atributos reales del objeto.
Ejemplos:
class Language
def initialize(language_name, topic_name)
@language_name = language_name
@topic_name = topic_name
end
end
Para crear una instancia de una clase, usamos una función familiar, que podríamos haber usado antes para hacer hashes o arreglos. Usamos la nueva función.
Sintaxis:
object_name = Class_name.new()
Si tenemos algún parámetro, generalmente se pasa entre paréntesis de new, al igual que en los métodos ordinarios.
Ejemplos:
class Language
def initialize(language_name, topic_name)
@language_name = language_name
@topic_name = topic_name
end
end
object1 = Language.new('Ruby','method')
Entonces tenemos un objeto llamado object1. Usamos Language.new() para crear una nueva instancia, esto llama a la función de inicialización. Así que object1.language_name es Ruby. Y object1.topic_name es método
Vamos a crear un segundo objeto también.
Ejemplos:
class Language
def initialize(language_name, topic_name)
@language_name = language_name
@topic_name = topic_name
end
end
object1 = Language.new('Ruby','method')
object2 = Language.new('Scala','string')
Entonces, object2.language_name es Scala y object2.topic_name es una string.
Métodos de acceso
Ahora que hemos definido nuestra clase y creado objetos, necesitamos poder cambiar o ver los atributos de nuestro objeto. Aquí es donde entra la segunda parte de nuestra clase: Métodos. Los métodos de clase son muy parecidos a nuestros métodos regulares definidos dentro de una clase.
Usamos métodos para cambiar el valor de algunos de nuestros atributos y también para ver los valores. Para llamar al método de un método en particular, debemos mencionar object_name.method_name . Esto se entiende mejor con un ejemplo.
Ejemplos:
# Ruby program to understand the concept of
# Access Method
class Language
def initialize(language_name, topic_name)
@language_name = language_name
@topic_name = topic_name
end
# Defining Methods
def return_name
return @language_name
end
def return_topic
return @topic_name
end
end
# Creating objects
object1 = Language.new('Ruby','method')
object2 = Language.new('Scala','string')
puts 'Language name for object1: ' + object1.return_name
puts 'Topic Name for object1: ' + object1.return_topic
puts 'Language name for object2: ' + object2.return_name
puts 'Topic Name for object2: ' + object2.return_topic
Producción :
Language name for object1: Ruby Topic Name for object1: method Language name for object2: Scala Topic Name for object2: string
Hemos creado dos objetos en el ejemplo anterior. object1.return_name llama al método return_name para object1, este devuelve el resultado ‘Ruby’. Si llamamos a object2.return_topic, llama al método return_topic para object2. Esto devuelve el resultado ‘método’ a la instrucción puts.
Normalmente, en Ruby, los métodos devuelven el último resultado de la computadora del método, por lo que no tenemos que escribir explícitamente return.
Entonces, en lugar de escribir el código a continuación
def return_name
return @vehicle_name
end
Podemos escribir el código de la siguiente manera.
def return_name
@vehicle_name
end
Alcance variable
Cuando decimos alcance variable, nos referimos a las áreas en las que se puede utilizar una determinada variable. El alcance puede ser global o local Cuando decimos global queremos decir que a lo largo de nuestro código, podemos usar la variable global en cualquier lugar. Para definir variables globales usamos el símbolo ‘$’ .
Ejemplos:
# Ruby program to understand the concept of
# Variable Scope
class Language
# Creating global variable
$reader = 'ABCD'
def initialize(language_name, topic_name)
@language_name = language_name
@topic_name = topic_name
end
# Defining Methods
def return_name
return @language_name
end
def return_topic
return @topic_name
end
end
# Creating objects
object1 = Language.new('Ruby','method')
object2 = Language.new('Scala','string')
puts 'Language name for object1: ' + object1.return_name
puts 'Topic Name for object1: ' + object1.return_topic
puts 'Language name for object2: ' + object2.return_name
puts 'Topic Name for object2: ' + object2.return_topic
# Printing global variable
puts 'The reader is '+ $reader
Producción :
Language name for object1: Ruby Topic Name for object1: method Language name for object2: Scala Topic Name for object2: string The reader is ABCD
En el ejemplo anterior, declaramos una variable global. Dado que esta variable es global, podemos usarla en cualquier parte del programa. $lector responsable de ABCD . Probemos esto con una de las variables de instancia object1.language_name . Esto habría dado un error porque esta variable es de alcance local, es decir, solo dentro de la clase. entonces necesitamos usar métodos de acceso o usar attr_reader que se explica a continuación.
Modificación de atributos
Entendámoslo con un ejemplo.
Ejemplos:
# Ruby program to understand the concept of
# Modifying attributes
class Language
def initialize(language_name, topic_name)
@language_name = language_name
@topic_name = topic_name
end
# Defining Method
def return_name
return @language_name
end
def return_topic
return @topic_name
end
def modify_topic(value)
@topic_name = value
end
end
# Creating object
object = Language.new('Ruby','method')
puts 'Language name for object: '+object.return_name
puts 'Topic name is '+object.return_topic
# Modifying attribute
object.modify_topic('string')
puts 'New Topic Name is '+object.return_topic
Producción :
Language name for object: Ruby Topic name is method New Topic Name is string
En el ejemplo anterior, vemos un nuevo método modify_topic. Este método se utiliza para cambiar el valor del atributo topic_name. Dado que no se puede acceder a los atributos directamente fuera de la función, recurrimos al uso de métodos para acceder a ellos. Como podemos ver en el ejemplo, pasamos el tema nuevo como argumento al método modificar_topic. Dentro del método, el atributo de tema del objeto se restablece al nuevo tema.
Variables de clase
Las variables de clase se diferencian de las variables de instancia en el sentido de que pertenecen a la clase y no al objeto. Para las variables de instancia como language_name y topic_name, tenemos una copia para cada objeto, pero para las variables de clase, una copia se comparte entre todos los objetos normalmente, la variable pertenece a la clase, no a las instancias de la clase, pero aún se puede acceder a ella. las instancias de la clase. Las variables de clase generalmente se identifican usando ‘@@’ . La sintaxis es @@class_variable = 0 . Puede tener un valor predeterminado y puede ser cualquier cosa, desde una string hasta un número entero.
Ejemplo :
# Ruby program to understand the concept of
# Class Variables
class Language
$reader = 'ABCD'
# Creating class variable
@@count = 0
def initialize(language_name, topic_name)
@language_name = language_name
@topic_name = topic_name
@@count += 1
end
# Defining method
def return_name
@language_name
end
def return_topic
@topic_name
end
# Returning class variable
def return_count
@@count
end
end
# Creating object
object1 = Language.new('Ruby', 'method')
object2 = Language.new('Scala', 'string')
puts 'Language name for object1: '+object1.return_name
puts 'Topic name for object1: '+object1.return_topic
puts 'Language name for object2: '+object2.return_name
puts 'Topic name for object2: '+object2.return_topic
puts 'The reader is '+ $reader
puts 'The number of objects created is ' + object1.return_count.to_s
puts 'The number of objects created is ' + object2.return_count.to_s
Producción :
Language name for object1: Ruby Topic name for object1: method Language name for object2: Scala Topic name for object2: string The reader is ABCD The number of objects created is 2 The number of objects created is 2
En el ejemplo anterior, hemos utilizado una variable de clase count para realizar un seguimiento de la cantidad de objetos que se crean. Este es uno de los usos más comunes de las variables de clase en el ejemplo anterior, inicializamos count con 0. También agregamos una función para devolver el valor a medida que se llama. cada vez que se crea un objeto, se llama al método de inicialización cada vez que se llama a la función de inicialización, el conteo se incrementa en uno, es decir , @@contar += 1 , independientemente de si llamamos al método volver_contar usando el objeto1 o el objeto2, imprime el mismo resultado. Al igual que las variables de instancia, su alcance está solo dentro de la clase y no se puede acceder directamente fuera de la clase. Usamos .to_s para convertir el número en una string.
En lugar de métodos de acceso
En los ejemplos anteriores, hemos introducido métodos para devolver los atributos. Tenemos una solución más fácil para eso. Aquí es donde entra en juego attr_reader, attr_writer, attr_accessor, considere la siguiente porción de código.
Ejemplo :
# Ruby program to understand the concept of
# Modifying attributes
class Language
attr_reader :language_name
attr_writer :topic_name
attr_reader :topic_name
def initialize(language_name, topic_name)
@language_name = language_name
@topic_name = topic_name
end
end
object = Language.new('Ruby', 'method')
puts 'The name of the language is ' + object.language_name
puts 'The topic of the language is ' + object.topic_name
# changing the topic name
object.topic_name = 'array'
puts 'The new topic of the language is ' + object.topic_name
Producción :
The name of the language is Ruby The topic of the language is method The new topic of the language is array
Publicación traducida automáticamente
Artículo escrito por SoniaBenny y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA