Ruby orienté objet

définition de classe Ruby

Lorsque vous définissez une classe, vous définissez en fait un modèle pour un type de données. Cela ne définit pas réellement toutes les données, mais la définition de ce que le nom des moyens de classe, qui est-à-dire la définition de ce qui constitue un objet de classe sera, et quelles actions peut être effectuée sur l'objet.

définition de classe commence par laclasse de mot - clé,suivi dunom delaclasse,et enfin seterminerpar une représentation séparée limiter ces définitions. Par exemple, nous utilisons le mot-clé class pour définir la classe Box, comme suit:

class Box
   code
end

Par convention, le nom doit commencer par une lettre majuscule, si elle contient plus d'un mot, en majuscule la première lettre de chaque mot, mais voici pas delimiter (par exemple: CamelCase).

définitions d'objets Ruby

Classe fournit le modèle pour un objet, donc en gros, l'objet est créé conformément à la classe. Nous utilisons lenouveau mot - clé pour déclarer l'objet de classe.La déclaration suivante déclare la boîte de classe deux objets:

box1 = Box.new
box2 = Box.new

méthode initialiser

initialiser la méthode est une méthode standard de classe Ruby est le constructeur de la classe, semblable à d' autres langages de programmation orientés objet des travaux du constructeur.Lorsque vous voulez initialiser certaines variables dans la classe pour créer un objet en même temps, initialiser la méthode est très pratique. La méthode prend une série d'arguments, comme d' autres méthodes Ruby, en utilisant cette méthode, il doit être placé en face du mot - clédef, comme suit:

class Box
   def initialize(w,h)
      @width, @height = w, h
   end
end

Les variables d'instance

variables d'instance de classe Property est qu'ils créent lorsque vous utilisez l'objet de classe deviendra propriété de l'objet.Les propriétés individuelles de chaque objet est attribué, entre autres objets, et ne partagent pas les valeurs. Au sein de la classe est d'utiliser l'opérateur @ pour accéder à ces propriétés en dehors de la classe, il estcourant d'utiliser une méthode appelée méthodesd'accèsaccesseurs.Ici , nous définissons laboîte de classe ci - dessus à titre d'exemple, la @width Boîte de classe et @height comme variables d'instance.

class Box
   def initialize(w,h)
      # 给实例变量赋值
      @width, @height = w, h
   end
end

Accesseurs (accesseur) et setter méthode (setter)

Pour utiliser des variables externes de la classe, nous devons définir ces variables dans lesméthodes d'accès internes,accesseur est legetter équivalent.L'exemple suivant illustre la méthode accesseur:

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造函数
   def initialize(w,h)
      @width, @height = w, h
   end

   # 访问器方法
   def printWidth
      @width
   end

   def printHeight
      @height
   end
end

# 创建对象
box = Box.new(10, 20)

# 使用访问器方法
x = box.printWidth()
y = box.printHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Width of the box is : 10
Height of the box is : 20

Comme pour les méthodes d'accès utilisées pour accéder aux valeurs des variables, Ruby fournit un moyen de définir la valeur externe variable de la classe A, aussi connu commeméthode setter, définie comme suit:

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end

   # 访问器方法
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # 设置器方法
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# 创建对象
box = Box.new(10, 20)

# 使用设置器方法
box.setWidth = 30
box.setHeight = 50

# 使用访问器方法
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Width of the box is : 30
Height of the box is : 50

Méthodes d'instance

Définir lesméthodes d'instance et d' autres méthodes définies, ils utilisent le mot - clé def,mais ils ne peuvent être utilisés par une instance de classe, comme le montrent les exemples suivants. Leur fonction ne se limite pas à accéder à des variables d'instance, mais aussi en fonction de vos besoins pour faire plus d'autres tâches.

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end

# 创建对象
box = Box.new(10, 20)

# 调用实例方法
a = box.getArea()
puts "Area of the box is : #{a}"

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Area of the box is : 200

méthodes de classe de classe variables &

Lesvariables de classe sont toutes les instances d'une des variables de classe partagée.En d'autres termes, les variables d'instance de classe sont accessibles à toutes les instances d'objet. variable classe avec deux @ caractères (@@) comme préfixe, les variables de classe doivent être initialisés dans la définition de la classe, comme le montrent les exemples suivants.

Méthode de classe def self.methodname ()définition, une méthode de classe pour mettre fin à delimiter. Les méthodes de classe peuvent être utilisés avec la forme nom de classeclassname.methodname d'appel, comme le montrent les exemples suivants:

#!/usr/bin/ruby -w

class Box
   # 初始化类变量
   @@count = 0
   def initialize(w,h)
      # 给实例变量赋值
      @width, @height = w, h

      @@count += 1
   end

   def self.printCount()
      puts "Box count is : #@@count"
   end
end

# 创建两个对象
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)

# 调用类方法来输出盒子计数
Box.printCount()

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Box count is : 2

méthode to_s

Toute classe a une méthode d'instanceto_s que vous définissez pour retourner une représentation de chaîne de l'objet.Voici un exemple simple, en fonction de la largeur et la hauteur représentent des objets Box:

#!/usr/bin/ruby -w

class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 定义 to_s 方法
   def to_s
      "(w:#@width,h:#@height)"  # 对象的字符串格式
   end
end

# 创建对象
box = Box.new(10, 20)

# 自动调用 to_s 方法
puts "String representation of box is : #{box}"

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

String representation of box is : (w:10,h:20)

Contrôle d'accès

Ruby vous offre trois niveaux de méthodes d'instance de protection, qui sontpublics, privés ou protégés.Toute demande de contrôle d'accès ne sont pas sur instance et classe les variables Ruby.

• Méthode publique: Méthodes publiquespeut être appelé tout objet. Par défaut, les méthodes sont publiques, sauf pour la méthode d'initialisation est toujours privé.
• Méthodes privées: Les méthodes privéesne sont pas accessibles ou vus de l' extérieur de la classe. méthodes de classe ne peut accéder aux membres privés.
• Méthode protégée: Méthode protégéene peut être appelée une classe d'objet et de ses sous - classes. L'accès ne peut être réalisée dans une classe interne et ses sous-classes.

Voici un exemple simple qui illustre la syntaxe trois modificateur:

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end

   # 实例方法默认是 public 的
   def getArea
      getWidth() * getHeight
   end

   # 定义 private 的访问器方法
   def getWidth
      @width
   end
   def getHeight
      @height
   end
   # make them private
   private :getWidth, :getHeight

   # 用于输出面积的实例方法
   def printArea
      @area = getWidth() * getHeight
      puts "Big box area is : #@area"
   end
   # 让实例方法是 protected 的
   protected :printArea
end

# 创建对象
box = Box.new(10, 20)

# 调用实例方法
a = box.getArea()
puts "Area of the box is : #{a}"

# 尝试调用 protected 的实例方法
box.printArea()

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants. Ici, le premier appel de méthode réussit, mais la seconde méthode aura un problème.

Area of the box is : 200
test.rb:42: protected method `printArea' called for #
<Box:0xb7f11280 @height=20, @width=10> (NoMethodError)

l'héritage de classe

Héritage, la programmation orientée objet est l'un des concepts les plus importants. L'héritage permet de définir une classe basée sur une autre classe, ce qui permet de créer et de maintenir des applications beaucoup plus facile.

L' héritage permet de réutiliser le code et l' exécution rapide, malheureusement, Ruby ne supporte pas l' héritage multiple, maismixins de soutien Ruby.mixin est comme une mise en oeuvre particulière de l'héritage multiple, héritage multiple, seule une partie de l'interface est héritable.

Lorsque vous créez une classe, le programmeur peut spécifier une nouvelle classe qui hérite d'une classe existante de membres, afin de ne pas écrire à partir de zéro les nouveaux membres de données et les fonctions membres. La classe existante est appelée laclasse de base ou de classe parent,la nouvelle classe est appelée lesclasses ou sous-classes dérivées.

Ruby fournit également une sous-classe concept de sous-classe qui est héritée, l'exemple suivant illustre ce concept. L'extension d'une syntaxe de classe est très simple. Il suffit d'ajouter un <nom du personnage et de la classe parent à la déclaration de classe peut. Par exemple, ce qui suit définit une classeBigBoxBox est une sous - classe:

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end

# 定义子类
class BigBox < Box

   # 添加一个新的实例方法
   def printArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# 创建对象
box = BigBox.new(10, 20)

# 输出面积
box.printArea()

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Big box area is : 200

Méthode surcharge

Bien que vous puissiez ajouter de nouvelles fonctionnalités dans une classe dérivée, mais parfois, vous voudrez peut-être changer le comportement a été défini dans les méthodes de la classe parent. Ensuite, vous pouvez garder le même nom de la méthode, la fonction peut être surchargé méthodes, comme le montrent les exemples suivants:

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end

# 定义子类
class BigBox < Box

   # 改变已有的 getArea 方法
   def getArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

# 创建对象
box = BigBox.new(10, 20)

# 使用重载的方法输出面积
box.getArea()

Essayez »

Exécutez l'exemple ci-dessus est sortie:

Big box area is : 200

Surcharge de l'opérateur

Nous voulons utiliser l'opérateur + effectue une addition vectorielle de deux objets Box, utilisez l'opérateur * à la largeur et la hauteur de la boîte multipliée en utilisant l'opérateur unaire - la largeur et la hauteur de la case niés. Voici une version de la classe de mathématiques avec définition Box Operator:

class Box
  def initialize(w,h) # 初始化 width 和 height
    @width,@height = w, h
  end

  def +(other)         # 定义 + 来执行向量加法
    Box.new(@width + other.width, @height + other.height)
  end

  def -@               # 定义一元运算符 - 来对 width 和 height 求反
    Box.new(-@width, -@height)
  end

  def *(scalar)        # 执行标量乘法
    Box.new(@width*scalar, @height*scalar)
  end
end

objet Frozen

Parfois, nous voulons éviter un objet est modifié. Dans l'objet, la méthode de gel peut atteindre cet objectif, il peut effectivement mettre un objet dans une constante. Tout objet peut être congelé en appelantObject.freeze.objet congelé ne peut pas être modifié, qui est, vous ne pouvez pas modifier ses variables d'instance.

Vous pouvez utiliserObject.frozen? Méthode pour vérifier si un objet donné a été congelé.Si l'objet a été gelé, la méthode renvoie true, sinon il renvoie la valeur false. L'exemple suivant illustre ce concept:

#!/usr/bin/ruby -w

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end

   # 访问器方法
   def getWidth
      @width
   end
   def getHeight
      @height
   end

   # 设置器方法
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end

# 创建对象
box = Box.new(10, 20)

# 让我们冻结该对象
box.freeze
if( box.frozen? )
   puts "Box object is frozen object"
else
   puts "Box object is normal object"
end

# 现在尝试使用设置器方法
box.setWidth = 30
box.setHeight = 50

# 使用访问器方法
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Box object is frozen object
test.rb:20:in `setWidth=': can't modify frozen object (TypeError)
        from test.rb:39

constantes de classe

Vous pouvez définir une classe interne constante, par une valeur numérique ou une chaîne directe à une définition de variable, qui ne nécessite pas l'utilisation @ constante ou @@. Par convention, le nom de l'utilisation des majuscules constante.

Une fois une constante est définie, vous ne pouvez pas modifier sa valeur, vous pouvez directement accéder aux constantes internes dans la classe, comme l'accès à la même variable, mais si vous souhaitez accéder à la classe externe constant, alors vous devez utiliser leclassname :: constant , comme illustré dans les exemples suivants.

#!/usr/bin/ruby -w

# 定义类
class Box
   BOX_COMPANY = "TATA Inc"
   BOXWEIGHT = 10
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end

# 创建对象
box = Box.new(10, 20)

# 调用实例方法
a = box.getArea()
puts "Area of the box is : #{a}"
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Area of the box is : 200
TATA Inc
Box weight is: 10

Les constantes de classe peuvent être héréditaires, mais aussi la même que la méthode d'instance est surchargé.

Utilisez créer des objets répartir les produits

Il peut y avoir un cas, vous souhaitez créer un objet sans appeler le constructeurinitialise l'objet, cet objet est créé en utilisant la nouvelle méthode, dans ce cas, vous pouvez appeler allouer à créer un objet non initialisée, comme les exemples suivants comme suit:

#!/usr/bin/ruby -w

# 定义类
class Box
   attr_accessor :width, :height

   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end

   # 实例方法
   def getArea
      @width * @height
   end
end

# 使用 new 创建对象
box1 = Box.new(10, 20)

# 使用 allocate 创建两一个对象
box2 = Box.allocate

# 使用 box1 调用实例方法
a = box1.getArea()
puts "Area of the box is : #{a}"

# 使用 box2 调用实例方法
a = box2.getArea()
puts "Area of the box is : #{a}"

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Area of the box is : 200
test.rb:14: warning: instance variable @width not initialized
test.rb:14: warning: instance variable @height not initialized
test.rb:14:in `getArea': undefined method `*' 
   for nil:NilClass (NoMethodError) from test.rb:29

Informations de classe

soi et Java de Ruby ce sont semblables, mais différentes. Les méthodes Java sont référencées dans une méthode d'instance, donc cela fait habituellement référence à l'objet courant. La ligne de code Ruby par ligne, dans un contexte (contexte) auto différente ont une signification différente. Jetons un regard sur les exemples suivants:

#!/usr/bin/ruby -w

class Box
   # 输出类信息
   puts "Class of self = #{self.class}"
   puts "Name of self = #{self.name}"
end

Essayez »

Lorsque le code ci-dessus est exécuté, il va produire les résultats suivants:

Class of self = Class
Name of self = Box

Cela veut dire que la classe peut être définie par la classe de l'objet en cours d'exécution, mais signifie également que les méta-classes et la définition de la méthode de la classe parent au cours de l'exécution du processus est disponible.