Definint una Ruby Class
Un objecte és una peça autocontinguda, amb funcionalitat, que pot ser fàcilment usada i reusada per a construir blocs d’una aplicació de software.
Els objectes consisteixen en dades, variables i funcions (anomenats mètodes), els quals es oden accedir i ser cridats sobre objectes mitjançant tasques.
Tot en Ruby és un objecte, nombres, arrays, strings, etc.
Les classes en Ruby es defineixen mitjançant la paraula class i cal finalitzar amb la paraula end, així:
class BankAccount
def inicialice ()
end
def test_methode
puts "The class is working"
end
end
Hen definit la classe BankAccount, amb el mètode test_method amb un simple string.
La inicialització del mètode () crida l’objecte basat en aquesta classe, inicialitzant-lo. Es pot inicialitzar el mètode passant arguments a la classe iniciada.
Crearem un objecte des d’una classe.
Com que ja tenim creada la classe BankAccount, simplement creem la instància:
account = BankAccount.new()
Aquest crea un objecte BankAccount anomenat account. Creat l’objecte podem cridar el nostre mètode:
account.test_method
The class is working
Variables d’Instància i Accés a Mètodes
Les variables d’instància sóns variables definides sols per cada instància de la classe. Les variables d’instància poden der definides dins o fora dels mètodes de classe.
Per fer variables disponibles des de fora de la classe, han de ser definides mitjançat mètodes accessibles.
Així definirem les variables mitjançant una @, així esterem definint que són variables associades a mètodes.
class BankAccount
def accountNumber
@accountNumber = "12345"
end
def accountName
@accountName = "John Smith"
end
def inicialize ()
end
def test_method
puts "The class is working"
puts accountNumber
end
end
Ara tenim dues instàncies anomenades @accountNumber i @accountName amb mètodes d’accés associats. Així que, ara podrem accedir a aquestes variables des de fora:
account = BanckAccount.new()
puts account.accontNumber
puts account.accountName
Els dos estaments de dalt ens retornaran les dues variables pels mètods d’accés, en aquest cas: 12345 i John Smith respectivament.
Ara podem aconseguir el valor de la variable d’instància, nosaltres, ara necessitem retornar als mètodes d’accés de manera que configurem el valor de la variable d’instància. Una maera de fer-ho és configurar els mètodes. Netejarem la classe BankAccount, així que establirem les dues variables d’instància així:
class BankAccount
def accountNumber
@accountNumber
end
def accountNumber = (value)
@accountNumber = value
end
def accountName
@accountName
end
def
@accountName = (value)
@accountName = value
end
end
Podem crear ara una instància de la nostra classe, configurar el nom de compte i usar l’accés a ells:
account = BanckAccount.new()
account.accountNumber = "54321"
account.accountName = "Fred Flintstone"
puts account.accountNumber
puts account.accountName
Variables de Classe Ruby
Una variable de classe compartida entre totes les instàncies de classe. En altres paraules, hi ha una instància de variables i accessos mitjançant instàncies d’objectes. Una variable d’instància ha de ser inicialitzada mitjançant una definició. Les variables de classe són prefixades amb dos caracters @, es a dir, @@.
Mostrarem com afegir la variable de classe @@interest_rate:
class BankAccount
def interest_rate
@@interest_rate = 0.2
end
def accountNumber
@accountNumber
end
def accountNumber = (value)
@accountNumber = value
end
def accountName
@accountName
end
def accountName = (value)
@accountNme = value
end
end
Instancies de mètodes
Tot i que hem estudiat breuent els mètodes d’instància, fins ara ens hem centrat en l’emmagatzematge de dades d’una classe.
Els mètodes d’instància són mètodes que es poden cridar a una instància de la classe. Els mètodes d’instància poden accedir a variables de classe per a realitzar tasques i també poden acceptar valors com a arguments. Per exempe, poden afegir un mètode a la nostra classe que pren un saldo de compte nou com a argument i utilitzar la variable de classe @@interest_rate per calcular l’interés degut.
def calc_interest ( balance )
puts balance * interest_rate
end
Ara, és quan creem una instància de la nostra classe, nosaltres podem cridar al nou mètode:
account = BankAccount
acoount.calc_interest( 1000 )
700.0
Herència de les classes de Ruby
Ruby suporta herència simple. Això significa que una subclasse pot ser creada heretant totes les variables i mètodes d’altra classe. La subclasse és llavors una extensió per afegir un nou mètode o variable no disponible en la superclasse.
Una classe heredada d’altra usa el caracter <. Diu, per exemple, que nosaltres volem un nou tipus de classe BankAccount. Aquesta classe necessita tots les mateixes variables i mètoes que la nostra classe original, però també necessita el nombre de telèfon del client. Per fer-ho, simplement heretem de BankAccount i afegim una nova variable d’instància:
class NewBankAccount < BankAccount
def customerPhone
@customerPhone
end
def customerPhone=( value )
@customerPhone = value
end
end
Ara tenim una nova classe, derivada de BankAccount. Aquesta nova subclasse inclou tot el que tenia la superclasse, a més d’una nova propietat: el nombre de telèfon del client.
account.accountNumber = "54321"
account.customerPhone = "555-123-5433"
54321
555-123-5433
Tinguem en compte que l’exemple anterior assumeix que la declaració de la classe BankAccount es troba al mateix fitxer front Ruby que la declaració NewBankAccount.
Si aquest no és el cas, s’ha utilitzat la declaració de requeriment per indicar a Ruby quin fitxer cal incloure per trobar la classe BankAccount.
Si suposem que BankAccount està defint en un fitxer anomenat BankAccount.rb, inclouriem el fitxer de la següent manera:
require 'BankAccount'
class NewBankAccount < BankAccount
def customerPhone
@customerPhone
end
def customerPhone=( value )
@customerPhone = value
end
end
Font: https://www.techotopia.com/index.php/Ruby_Object_Oriented_Programming