Cómo entender las clases y objetos de Ruby
1. Encapsulación de datos
2. Abstracción de datos
3.
4. Legacy
Estas características ya se han discutido en Ruby orientado a objetos.
Los programas orientados a objetos incluyen clases y objetos. Una clase es un modelo, creado a partir de un único objeto. En términos orientados a objetos, decimos que la bicicleta de Xiao Ming es una instancia de objeto llamada clase de bicicleta.
¿Hay algún ejemplo de vehículos? Incluye ruedas, caballos de fuerza, combustible o capacidad del tanque. Estas características constituyen los miembros de datos de la clase de vehículo. Estas características lo distinguen de otros vehículos.
Los vehículos también tienen determinadas funciones, como frenar, arrancar y acelerar. Incluso estas funciones forman miembros de datos de una clase de vehículo. Por lo tanto, puedes definir las características y funcionalidad de una clase como una combinación.
La clase de vehículo se puede definir como:
Categoría de vehículo
{
Número de ruedas
Número de caballos de fuerza
p>Tipos de tanques
Número de capacidad
Función de aceleración
{
}
Controlador de funciones
{
}
Función suspendida
{
}
}
Al asignar diferentes valores a estos miembros de datos, se pueden formar varias instancias de vehículos similares. Por ejemplo, un avión tiene tres ruedas, 1.000 caballos de fuerza, diferentes tanques de combustible y una capacidad de 100 litros. De igual forma, un automóvil tiene cuatro ruedas, 200 caballos de fuerza y gasolina como tanque de combustible diferente con una capacidad de 25 litros.
Definición de una clase en Ruby:
Para usar Ruby para implementar programación orientada a objetos, necesitas aprender a crear objetos y clases en Ruby.
Las clases en Ruby siempre comienzan con el nombre de la clase de palabra clave. La primera letra del nombre debe estar en mayúscula. Si es así, la clase Cliente podría aparecer como:
Categoría Cliente
Fin
Utilice la palabra clave end para finalizar la definición de clase. Todos los miembros de datos de una clase se definen entre clases, con la palabra clave end como terminador.
Variables en las clases Ruby:
Ruby proporciona cuatro tipos de variables:
Variables locales: Las variables locales son variables definidas en métodos. Las variables locales no están disponibles fuera del método. Se introducirán más detalles en los métodos en capítulos posteriores. Las variables locales generalmente comienzan con una letra minúscula o _.
Variables de instancia: Las variables de instancia son métodos que pueden abarcar cualquier instancia u objeto específico. Esto significa que las variables de instancia varían de un objeto a otro. Las variables de instancia están precedidas por un símbolo arroba (@), seguido del nombre de la variable.
Variables de clase: Las variables de clase están disponibles en varios objetos. Una variable de clase pertenece a una clase, lo cual es una característica de una clase. Los nombres de las variables están precedidos por el símbolo @ @.
Variables globales: Las variables de clase no pueden cruzar clases. Si desea que una sola variable abarque clases, debe definir una variable global. Las variables globales siempre comienzan con un signo de dólar ($).
Ejemplo:
Utilizando la variable de clase @@no_of_customers puedes determinar el número de objetos creados. Esto permite aumentar el número de clientes de exportación.
Clientes de categoría
@ @Customer Count=0
Fin
Utilice el nuevo método para crear un objeto en Ruby:
Un objeto es una instancia de una clase. Ahora aprenderá cómo crear un objeto de clase de objeto en Ruby. Crea objetos en Ruby usando el nuevo método.
El nuevo método es un método único que está predefinido en la biblioteca Ruby. El nuevo método es un método de la clase.
El siguiente ejemplo creará dos clases de objetos cliente1 y cliente2:
cust1=Cliente. nuevo
cust2 = cliente. Nuevo
Aquí, cust1 y cust2 son los nombres de los dos objetos. Después del signo igual (=), el nombre de la clase seguirá al nombre del objeto. Luego, le siguen el operador de punto y la palabra clave nueva.
Personaliza la forma de crear objetos Ruby:
Puedes usar los parámetros de un nuevo método, que se puede usar para inicializar variables de clase.
Cuando un nuevo método a declarar tiene parámetros, el método a declarar se inicializa cuando se crea la clase.
El método Inicializar es un tipo especial de método, y la clase que ejecuta el nuevo método se llama parámetro.
El siguiente ejemplo creará el método de inicialización:
Categoría Clientes
@@NúmeroDeCliente=0
Definición inicializar(id, nombre , Dirección)
@cust_id=id
@cust_name=nombre
@cust_addr=addr
Fin
Fin
En este ejemplo, puede declarar el ID del método de inicialización, el nombre y la dirección de la variable local. Aquí, def end se utiliza para definir la inicialización del método Ruby. Aprenderá más sobre estos en los siguientes capítulos.
En el método de inicialización, los valores de estas variables locales se pasan a las variables de instancia @cust_id, @cust_name y @cust_addr. Aquí el valor mantenido por la variable local se pasa mediante el nuevo método.
Ahora puede crear el objeto de la siguiente manera:
cust 1 = cliente nuevo(" 1 ", " John ", " Smart Apartment, Ludhiya ")
<. p>cust2=Customer.new("2","Poul","New Imperial Road, Khandala")Funciones miembro de clases en Ruby:
En Ruby, el método de llamar a la función. El nombre del método de cada método de la clase comienza con la palabra clave def.
Es mejor utilizar letras minúsculas para los nombres de los métodos. En su método final Ruby, la palabra clave end se usa para indicar el final.
El siguiente ejemplo muestra cómo definir Ruby:
Muestra de clase
Definir función
Declaración 1
Informe 2
Fin
Fin
Aquí, la declaración 1 y la declaración 2 son parte del cuerpo de la función. Estas estadísticas pueden ser cualquier declaración Ruby válida. Por ejemplo, podemos imprimir Hola Ruby de la siguiente manera:
Muestra de clase
Hola
Reemplazar "¡Hola, Ruby!"
Fin
Fin
Ahora, en el siguiente ejemplo, la clase de muestra crea un objeto y llama al método hello para ver el resultado:
#!/usr / bin/ruby
Muestra de clase
Hola
Pon "¡Hola, Ruby!"
Fin
Fin
#Ahora usa la clase anterior para crear el objeto
Objeto = muestra. Nuevo
Objeto.Hola
Esto producirá los siguientes resultados:
¡Hola Ruby!