1: Méthode 2: Classe 3: méthode d'instance 4: méthode de classe est.
Une méthode est une méthode qui combine plusieurs processus.
greet.rb
def greet(name)
puts "#{name}, HELLO!"
end
greet('Alice')
> "Alice, HELLO"
** greet (nom) ** correspond à la méthode. La méthode n'est pas chargée dans la partie définie (def ~ end), mais uniquement lorsqu'elle est exécutée (greet ('Alice')).
La méthode est 1: vous pouvez passer la valeur 2: la valeur d'évaluation est renvoyée à la fin 3: Les variables définies dans la méthode ne sont pas accessibles en externe Il a la fonctionnalité.
Si le nom de la méthode est long, il est d'usage de l'écrire dans un cas de serpent,
** greet_her ** au lieu de greetHer ** send_mail ** au lieu de sendMail **
Il est nécessaire d'écrire sous la forme de.
1: Le traitement défini par la méthode peut être réutilisé 2: La modification du code devient plus facile
Par exemple, supposons que vous ayez un code comme celui-ci.
number.rb
puts 1
puts 2
puts 3
puts 4
puts 1
puts 2
puts 3
puts 4
Il est très difficile d'écrire les met 1 un par un, alors essayez de réécrire en utilisant une méthode
number.rb
def number
puts 1
puts 2
puts 3
puts 4
end
number #1 en une fois,2,3,4 sorties à la fois
> 1
> 2
> 3
> 4
De plus, si vous n'avez plus besoin de met 3, vous pouvez simplement supprimer les met 3 dans la méthode.
number.rb
def number
puts 1
puts 2
#Supprimer
puts 4
end
number #1 en une fois,2,4 sorties à la fois
> 1
> 2
> 4
En créant une méthode pour qu'elle puisse être facilement réutilisée de cette manière, il sera plus facile de modifier l'ensemble.
La source à utiliser lors de la création d'une instance. Cela pourrait être plus facile à imaginer si vous le considérez comme un moule pour faire des biscuits.
cookie.rb
Class Cookie #nom de la classe=Cookie
def cookie #Nom de la méthode=cookie
end
end
#Créez en fait une instance à partir d'un type appelé Classe Cookie ↓
cookie = Cookie.new
cookie
#C'était fait ↓
=> #<Cookie:0x00007ff34c847fa0>
<Cookie:0x00007ff34c847fa0> Est une instance créée par la classe Cookie. Une instance peut être créée en définissant le nom de la classe sur .new. Une instance fait référence à l'entité elle-même créée à partir de la source. En termes simples, un vrai cookie fabriqué à partir d'un moule.
En utilisant la méthode initialize, il est possible d'avoir des informations lors de la création d'une instance. Cette fois, donnons à l'instance de cookie deux informations, la taille et le goût.
cookie.rb
class Cookie
def initialize(size, taste)
@size = size
@taste = taste
end
end
cookie = Cookie.new('Large', 'Sweet')
cookie
=> #<Cookie:0x00007ff34d2a7108 @size="Large", @taste="Sweet">
Cela nous a permis de générer de grandes instances de cookies au goût sucré. Soudainement sorti,
@size @taste
Ces types commençant par @ sont appelés ** variables d'instance **, et vous pouvez modifier les données détenues pour chaque instance (pour chaque cookie). Cette fois, la taille est le premier argument et le goût est le deuxième argument, qui correspondent respectivement à «Grand» et «Doux». En appliquant ceci,
cookie.rb
cookie1 = Cookie.new('Medium', 'Bitter')
cookie1
=> #<Cookie:0x00007ff34d2cdd30 @size="Medium", @taste="Bitter">
cookie2 = Cookie.new('Small', 'Salty')
cookie2
=> #<Cookie:0x00007ff34d2cdd30 @size="Small", @taste="Salty">
Et vous pouvez créer des instances de cookies avec plusieurs tailles et goûts.
Une méthode qui peut être exécutée à l'aide de l'instance créée (cookie). Pour le moment, il existe trois types de cookies: petit salé, moyennement amer et grand sucré. Ceux-ci sont uniquement fabriqués à partir de la classe Cookie ** et ne sont pas utilisés. ** ** Les méthodes d'instance sont destinées à faire quelque chose avec ces types.
cookie.rb
cookie2
=> #<Cookie:0x00007ff34d2cdd30 @size="Small", @taste="Salty">
def cookie_taste
puts "#{@taste}"
end
=> :cookie_taste
cookie.cookie_taste
> Salty
Les données de la méthode d'instance @taste du cookie ont réussi à transmettre les données à @taste de cookie_taste. De cette manière, la méthode d'instance peut faire référence aux données basées sur les données de l'instance.
Auparavant, c'était via une instance, mais vous pouvez faire de même via une classe. À utiliser lorsque vous n'avez pas besoin de faire référence aux données d'instance.
cookie.rb
class Cookie
# @@Ceux avec deux sont appelés variables de classe et peuvent être partagés par toutes les instances.
@@my_cookie_is = 0
def initialize(size, taste)
@size = size
@taste = taste
@@my_cookie_is += 1
end
#Méthode d'instance
def show_info
puts "#{@taste}Biscuits#{@size}Il n'y a que la taille."
end
#Méthode de classe
def self.show_all_cookie
puts "je suis#{@@my_cookie_is}Je vais manger un morceau de biscuit."
end
end
Après avoir fait cela
cookie.rb
#Exécution de la méthode de classe
cookie4 = Cookie.new('Medium','Bitter')
cookie4
=> #<Cookie:0x00007ff34d1ae440 @size="Medium", @taste="Bitter">
Cookie.show_all_cookie
Je mange un cookie.
#Exécution de la méthode de classe
cookie5 = Cookie.new('Large','Salty')
cookie5
=> #<Cookie:0x00007ff34c851c30 @size="Large", @taste="Salty">
Cookie.show_all_cookie
Je mange deux biscuits.
#Exécution de la méthode d'instance
cookie4.show_info
Les cookies amers ne sont que de taille moyenne.
#Exécution de la méthode d'instance
cookie5.show_info
Les cookies salés ne sont disponibles qu'en grande taille.
Sera.
[Ruby] Concept de classe orienté objet compris par Taiyaki https://pikawaka.com/ruby/class#%E3%82%AF%E3%83%A9%E3%82%B9%E3%81%AE%E4%BD%9C%E3%82%8A%E6%96%B9 J'ai été très utile. Je l'ai écrit presque comme une version concise de cet article. En faisant un article, j'ai pu couvrir ce qui était une connaissance superficielle.
Recommended Posts