Ruby ਸ਼ੁੱਧ ਆਬਜੈਕਟ-ਅਨੁਕੂਲ ਹੈ — ਤੁਸੀਂ ਕਲਾਸਾਂ (ਨੁਖਸ) ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਅਤੇ ਆਬਜੈਕਟ (ਮਨੋਰਥ) ਬਣਾਉਂਦੇ ਹੋ। ਕਲਾਸਾਂ initialize ਨੂੰ constructor ਵਜੋਂ ਵਰਤਦੀਆਂ ਹਨ, @variables ਨੂੰ instance state ਲਈ ਵਰਤਦੀਆਂ ਹਨ, ਅਤੇ encapsulation ਲਈ access modifiers ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ। Ruby ਦੀ ਕਲਾਸ ਸਿੰਟੈਕਸ ਸਾਫ਼ ਅਤੇ ਪ੍ਰਗਟਾਤਮਕ ਹੈ।
class Person
def initialize(name, age) # the CONSTRUCTOR (called on .new)
@name = name # @ → instance variable (per object)
@age = age
end
def greet # an instance method
"Hi, I'm #{@name}"
end
end
person = Person.new("Ann", 30) # create an instance (calls initialize)
person.greet # "Hi, I'm Ann"
initialize method constructor ਹੈ (.new ਦੁਆਰਾ ਆਪਣੇ ਆਪ ਨੂੰ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ), ਅਤੇ @name instance variables ਪ੍ਰਤੀ-ਆਬਜੈਕਟ state ਨੂੰ ਰੱਖਦੇ ਹਨ। Methods ਨੂੰ def ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
class Person
attr_accessor :name # generates getter AND setter for @name
attr_reader :age # getter only (read-only)
def initialize(name, age)
@name = name
@age = age
end
end
person.name # "Ann" — getter
person.name = "Bob" # setter
Instance variables (@name) ਡਿਫ਼ਾਲਟ ਤੌਰ ਤੇ private ਹਨ — ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ accessor methods ਨਾਲ ਉਜਾਗਰ ਕਰਦੇ ਹੋ। attr_accessor/attr_reader/attr_writer ਇਹਨਾਂ getter/setter methods ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ ਤੇ ਬਣਾਉਂਦੇ ਹਨ (ਇੱਕ Ruby ਸਹੂਲਤ)।
class Account
def deposit(amount) # public by default
update_balance(amount)
end
private # methods below are PRIVATE
def update_balance(amount)
@balance += amount
end
def self.create # CLASS method (self.) — called on the class, not an instance
new(...)
end
end
Account.create # class method
Methods ਡਿਫ਼ਾਲਟ ਤੌਰ ਤੇ public ਹਨ; private/protected access ਨੂੰ ਸਖ਼ਤ ਕਰਦੇ ਹਨ। def self.method ਇੱਕ class method ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ (ਕਲਾਸ ਆਪ ਦੇ ਤੇ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)।
Classes ਅਤੇ objects Ruby ਦੇ ਲਈ ਬੁਨਿਆਦੀ ਹਨ, ਜੋ ਕਿ ਇੱਕ ਸ਼ੁੱਧ object-oriented language ਹੈ, ਇਸ ਲਈ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਕਿਸੇ ਵੀ Ruby development ਲਈ ਜ਼ਰੂਰੀ ਹੈ — ਲਗਭਗ ਸਾਰਾ Ruby code (ਅਤੇ Rails ਵਰਗੇ frameworks) classes ਵਿੱਚ ਸਂਗਠਿਤ ਹੈ।
initialize constructor ਦੇ ਨਾਲ classes ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ, per-object state ਲਈ @instance variables ਦੀ ਵਰਤੋਂ ਕਰਨਾ (ਅਤੇ ਇਹ ਕਿ ਉਹ ਡਿਫ਼ਾਲਟ ਤੌਰ ਤੇ private ਹਨ, ਉਹਨਾਂ ਨੂੰ ਉਜਾਗਰ ਕਰਨ ਲਈ accessor methods ਦੀ ਲੋੜ), instance ਅਤੇ class methods ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ (def self.method), ਅਤੇ access control ਨੂੰ ਲਾਗੂ ਕਰਨਾ (private/protected) ਮੌਲਿਕ ਰੋਜ਼ਮਰਾਂ ਦਾ ਗਿਆਨ ਹੈ।
ਖ਼ਾਸ ਤੌਰ ਤੇ ਮਹੱਤਵਪੂਰਨ Ruby ਸਹੂਲਤ attr_accessor/attr_reader/attr_writer ਹੈ, ਜੋ ਕਿ instance variables ਲਈ getter/setter methods ਨੂੰ ਸਵੈਚਲਿਤ ਤੌਰ ਤੇ ਬਣਾਉਂਦਾ ਹੈ — boilerplate ਨੂੰ ਖ਼ਤਮ ਕਰਦੇ ਹੋਏ ਅਤੇ Ruby ਦੀ ਸ਼ਾਨ ਨੂੰ ਪ੍ਰਤੀਬਿੰਬਿਤ ਕਰਦਾ ਹੈ (ਬਹੁਤ ਸਾਰੀਆਂ languages ਦੀ ਤਰ੍ਹਾਂ ਸਪੱਸ਼ਟ getters/setters ਲਿਖਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਘੋਸ਼ਿਤ ਕਰਦੇ ਹੋ)।
Ruby ਦੀ ਸਾਫ਼ class syntax, constructor ਅਤੇ instance-variable model, accessor methods, ਅਤੇ class methods ਨੂੰ ਸਮਝਣਾ ਮੁੱਖ, ਜ਼ਰੂਰੀ ਸਮਗਰੀ ਹੈ object-oriented Ruby ਲਈ।
Classes ਦੀ ਵਜਾ ਤੁਸੀਂ ਸਾਰੇ Ruby applications ਵਿੱਚ data ਅਤੇ behavior ਨੂੰ ਮਾਡਲ ਕਰਦੇ ਹੋ, ਅਤੇ ਕਿਉਂਕਿ Ruby ਦੀਆਂ class features (initialize convention, @ instance variables, attr_* accessors, public/private control) ਇਹ ਹਨ ਕਿ ਕਿਵੇਂ object-oriented Ruby ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਉਹਨਾਂ ਵਿੱਚ ਮਾਹਿਰ ਹੋਣਾ ਜ਼ਰੂਰੀ, ਬੁਨਿਆਦੀ ਗਿਆਨ ਹੈ ਜੋ ਸਾਰੇ Ruby development ਨੂੰ ਅਧਾਰ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ language ਦੀ object-oriented nature ਨੂੰ ਸਮਝਣ ਲਈ ਅਕਸਰ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਹੈ।