Ruby సంపూర్ణ ఆబ్జెక్ట్-ఓరియెంటెడ్ — మీరు classes (బ్లూప్రింట్లు) నిర్వచించి objects (ఇన్స్టెన్సెస్) సృష్టిస్తారు. Classes initialize ను కన్స్ట్రక్టర్గా ఉపయోగిస్తాయి, @variables ఇన్స్టెన్స్ స్టేట్కు, మరియు encapsulation కోసం access modifiers ఉపయోగిస్తాయి. Ruby యొక్క class సింటాక్స్ స్వచ్ఛమైనది మరియు వ్యక్తీకరణాత్మకమైనది.
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 మెథడ్ కన్స్ట్రక్టర్ (.new ద్వారా స్వయంచాలకంగా కాల్ చేయబడుతుంది), మరియు @name ఇన్స్టెన్స్ వేరియబుల్లు ప్రతి-ఆబ్జెక్ట్ స్టేట్ను పట్టుకుంటాయి. మెథడ్లు 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
ఇన్స్టెన్స్ వేరియబుల్లు (@name) డిఫాల్ట్గా ప్రైవేట్ — మీరు వాటిని accessor మెథడ్లతో బహిర్గతం చేస్తారు. attr_accessor/attr_reader/attr_writer ఈ getter/setter మెథడ్లను స్వయంచాలకంగా జెనరేట్ చేస్తాయి (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
మెథడ్లు డిఫాల్ట్గా పబ్లిక్; private/protected యాక్సెస్ను నియంత్రిస్తాయి. def self.method class మెథడ్ నిర్వచిస్తుంది (క్లాస్ కూపై కాల్ చేయబడుతుంది).
క్లాసులు మరియు ఆబ్జెక్టులు Ruby కు ప్రాథమికమైనవి, ఇది సంపూర్ణ ఆబ్జెక్ట్-ఓరియెంటెడ్ భాష, కాబట్టి వాటిని అర్థం చేసుకోవడం ఏదైనా Ruby డెవలప్మెంట్కు అవసరమైనది — Ruby కోడ్ (మరియు Rails లాంటి frameworks) దాదాపు అన్నటికీ క్లాసెస్లో సంఘటితమైనది.
initialize కన్స్ట్రక్టర్ తో క్లాసెస్ నిర్వచించటను, @instance వేరియబుల్లు ఉపయోగించటను ప్రతి-ఆబ్జెక్ట్ స్టేట్కు (మరియు అవి డిఫాల్ట్గా ప్రైవేట్ అని, వాటిని బహిర్గతం చేయడానికి accessor మెథడ్లు అవసరమని), instance మరియు class మెథడ్లు నిర్వచించటను (def self.method), మరియు access control (private/protected) ప్రయోగించటను తెలుసుకోవడం ప్రాథమిక రోజువారీ జ్ఞానం.
ఒక ప్రత్యేకంగా ముఖ్యమైన Ruby సౌకర్యం attr_accessor/attr_reader/attr_writer, ఇది ఇన్స్టెన్స్ వేరియబుల్ల కోసం getter/setter మెథడ్లను స్వయంచాలకంగా జెనరేట్ చేస్తుంది — బయిలర్ప్లేట్ను తొలగిస్తుంది మరియు Ruby యొక్క దయనీయతను ప్రతిబింబిస్తుంది (నిర్దిష్ట getters/setters వ్రాయడానికి బదులుగా అనేక భాషల్లో, మీరు వాటిని ఒక లైన్లో ప్రకటించండి).
Ruby యొక్క స్వచ్ఛ class సింటాక్స్, కన్స్ట్రక్టర్ మరియు instance-variable మోడల్, accessor మెథడ్లు, మరియు class మెథడ్లను అర్థం చేసుకోవడం కోర్, తప్పనిసరిగా-తెలుసుకోవాల్సిన విషయం.
క్లాసెస్ Ruby అప్లికేషన్లలో డేటా మరియు ప్రవర్తనను మోడల్ చేయడానికి, మరియు Ruby యొక్క class features (initialize సంప్రదాయం, @ ఇన్స్టెన్స్ వేరియబుల్లు, attr_* accessors, public/private control) ఆబ్జెక్ట్-ఓరియెంటెడ్ Ruby ఎలా వ్రాయబడుతుందో, వాటిని నైపుణ్యం చేసుకోవడం అవసరమైనది, ప్రాథమిక జ్ఞానం ఇది అన్ని Ruby డెవలప్మెంట్కు భిన్నమైనది మరియు భాష యొక్క ఆబ్జెక్ట్-ఓరియెంటెడ్ స్వభావాన్ని అర్థం చేసుకోవడానికి ఆరంభ సూచన.