Latest web development tutorials

Rubino object-oriented

Ruby è un linguaggio orientato agli oggetti puro, Ruby, tutto è in forma di oggetti. Ogni valore in Ruby è un oggetto, anche la cosa più primitiva: stringhe, numeri, e anche vero e falso sono oggetti. La classe è di per sé unoggetto cheè un'istanzadellaclassedi classe.Questo capitolo spiega spiegare tutte le principali funzioni associate con l'oggetto-oriented Ruby.

Classe viene utilizzata per formare l'oggetto specificato, che combina la rappresentazione di dati e metodi per organizzare i dati in un pacchetto accurato. i dati di classe e metodi sono chiamati i membri della classe.

definizione di classe Rubino

Quando si definisce una classe, in effetti si definisce un modello per un tipo di dati. Questo in realtà non definisce alcun dato, ma la definizione di ciò che il nome del mezzo di classe, vale a dire, la definizione di ciò che costituisce un oggetto della classe sarà, e quali azioni possono essere eseguite sull'oggetto.

Definizione della classe inizia con la parola chiaveclass, seguita dal nomedellaclasse,e, infine,terminacon una rappresentazione separata limitare tali definizioni. Ad esempio, si usa la parola chiave class per definire la classe di sicurezza, come segue: 

class Box
   code
end

Per convenzione, il nome deve iniziare con una lettera maiuscola, se contiene più di una parola, in maiuscolo la prima lettera di ogni parola, ma qui non è delimitatore (ad esempio: CamelCase).

definizioni degli oggetti di Ruby

Class fornisce il modello per un oggetto, in modo sostanzialmente, l'oggetto viene creato in conformità con la classe. Usiamo lanuova parola chiave per dichiarare l'oggetto della classe.La seguente dichiarazione dichiara casella Classe due oggetti: 

box1 = Box.new
box2 = Box.new

metodo di inizializzazione

metodo diinizializzazione è un metodo di classe standard di Ruby è il costruttore della classe, simile ad altri linguaggi di programmazione orientati agli oggetti opere di costruzione.Quando si desidera inizializzare alcune variabili nella classe per creare un oggetto, allo stesso tempo, l'inizializzazione metodo è utile. Il metodo richiede una serie di argomenti, come altri metodi rubino, con questo metodo, deve essere posto davantialla parola chiave def,come segue: 

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

Le variabili di istanza

variabili di proprietà di istanzadi classe è che essi creano quando si utilizza l'oggetto di classe diventerà proprietà dell'oggetto. le proprietà individuali di ogni oggetto è assegnato, tra gli altri oggetti, e non condividono i valori. All'interno della classe è di utilizzare l'operatore @ per accedere a tali proprietà all'esterno della classe, ècomune utilizzare un metodo chiamato metodi di accessodi accesso. Qui si definisce ilBox classe superiore come esempio, il @width classe Box e @height come variabili di istanza.

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

Metodo di accesso (di accesso) e setter (setter)

Per poter utilizzare le variabili esterne della classe, dobbiamo definire queste variabili neimetodi di accesso interni,di accesso è ilgetter equivalente.L'esempio seguente dimostra il metodo di accesso: 

#!/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}"

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

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

Analogamente ai metodi di accesso utilizzate per accedere ai valori delle variabili, Ruby fornisce un modo per impostare il valore esterno variabile della classe A, noto anche comemetodo setter, definita come segue:

#!/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}"

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

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

Metodi di istanza

Definiremetodi di istanza e altri metodi definiti, che stanno utilizzando la parola chiave def,ma possono essere utilizzati solo da un'istanza di classe, come illustrato negli esempi seguenti. La loro funzione non è limitata per accedere variabili di istanza, ma anche in base alle proprie esigenze di fare di più altri compiti. 

#!/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}"

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

Area of the box is : 200

I metodi di classe di classe variabili &

le variabili di classe sono tutte le istanze di un variabili di classe condivisa.In altre parole, le variabili di istanza classe sono accessibili tutte le istanze di oggetti. variabile di classe con due @ caratteri (@@) come prefisso, variabili di classe devono essere inizializzate nella definizione della classe, come illustrato negli esempi che seguono.

metodo di classe def self.methodname ()definizione, un metodo di classe alla fine delimitatore. I metodi di classe possono essere utilizzati con il modulo nome della classeclassname.methodname di chiamata, come illustrato nei seguenti esempi:

#!/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()

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

Box count is : 2

metodo to_s

Ogni classe ha un metodo di istanzato_s che si definisce per restituire una rappresentazione in formato stringa dell'oggetto.Ecco un semplice esempio, in base alla larghezza e altezza rappresentano oggetti di sicurezza: 

#!/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}"

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

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

Access Control

Rubino vi offre tre livelli di protezione metodi di istanza, che sonopubblici, privati o protetti.Qualsiasi applicazione di controllo di accesso non è su Ruby istanza e di classe variabili.

  • Metodo pubblico: metodi pubblicipuò essere chiamato qualsiasi oggetto. Per default, i metodi sono pubblici, eccetto per il metodo initialize è sempre privato.
  • Metodi privati: i metodi privatinon sono accessibili o viste dall'esterno della classe. Solo i metodi della classe possono accedere ai membri privati.
  • Metodo protetto: Metodo protettopuò essere chiamato solo una classe di oggetti e le sue sottoclassi. L'accesso può essere effettuato solo in una classe interna e le sue sottoclassi.

Ecco un semplice esempio che dimostra la sintassi tre modificatore: 

#!/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()

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati. Qui, la prima chiamata di metodo riesce, ma il secondo metodo avrà un problema. 

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

eredità di classe

Ereditarietà, programmazione orientata agli oggetti è uno dei concetti più importanti. L'ereditarietà consente di definire una classe basata su un'altra classe, il che rende la creazione e la gestione di applicazioni molto più facile.

L'ereditarietà consente di riutilizzare il codice e l'esecuzione veloce, purtroppo, Ruby non supporta l'ereditarietà multipla, mamixins supporto Ruby.mixin è come una particolare implementazione dell'ereditarietà multipla, l'ereditarietà multipla, solo una parte della interfaccia è ereditabile.

Quando si crea una classe, il programmatore può specificare una nuova classe che eredita da una classe esistente di membri, in modo da non scrivere da zero i nuovi membri di dati e le funzioni membro. La classe esistente è chiamata laclasse di base o classe genitore,la nuova classe si chiama leclassi o sottoclassi derivate.

Rubino offre anche una sottoclasse concetto di sottoclasse che viene ereditata, il seguente esempio illustra questo concetto. Estendendo una sintassi classe è molto semplice. Basta aggiungere un <nome del personaggio e la classe genitore per la lattina dichiarazione di classe. Ad esempio, il seguente definisce una classeBigBoxBox è una sottoclasse: 

#!/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()

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

Big box area is : 200

metodo sovraccarico

Anche se è possibile aggiungere nuove funzionalità in una classe derivata, ma a volte si può decidere di modificare il comportamento è stato definito nei metodi della classe genitore. Quindi è possibile mantenere lo stesso nome del metodo, la funzione può essere sovraccaricato metodi, come illustrato nei seguenti esempi: 

#!/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()

Eseguire l'uscita precedente esempio è il seguente: 

Big box area is : 200

L'overloading degli operatori

Vogliamo usare l'operatore + esegue vettore aggiunta di due oggetti di sicurezza, utilizzare l'operatore * per la larghezza e l'altezza del Box moltiplicato usando operatore unario - la larghezza e l'altezza del Box negati. Ecco una versione della classe di matematica con la definizione 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

oggetto congelata

A volte, si vuole evitare che un oggetto viene modificato. Nel oggetto, metodo di congelamento può raggiungere questo obiettivo, si può effettivamente mettere un oggetto in una costante. Qualsiasi oggetto può essere congelato chiamandoObject.freeze.oggetto congelato non può essere modificato, vale a dire, non è possibile modificare le sue variabili di istanza.

È possibile utilizzareObject.frozen? Metodo per verificare se un determinato oggetto è stato congelato.Se l'oggetto è stato congelato, il metodo restituisce vero, altrimenti restituisce un valore falso. L'esempio seguente illustra questo concetto: 

#!/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}"

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

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

costanti di classe

È possibile definire una classe interna costante, da un valore numerico o una stringa diretto ad una definizione della variabile, che non richiede l'uso costante @ o @@. Per convenzione, il nome del l'uso maiuscolo costante.

Una volta che una costante è definita, non è possibile modificare il suo valore, è possibile accedere direttamente alle costanti interne nella classe, così come l'accesso alla stessa variabile, ma se si desidera accedere costante di classe esterno, quindi è necessario utilizzare ilnome di classe :: costante , come mostrato negli esempi seguenti.

#!/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}"

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

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

Costanti di classe possono essere ereditati, ma anche lo stesso del metodo di istanza è sovraccarico.

Utilizzare allocate creare oggetti

Ci può essere un caso, si desidera creare un oggetto senza chiamare il costruttoreinizializzare l'oggetto, l'oggetto viene creato utilizzando il nuovo metodo, in questo caso, è possibile chiamare allocare per creare un oggetto non inizializzato, come i seguenti esempi come segue:

#!/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}"

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

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

Informazioni Class

auto e Java di Ruby questo sono simili, ma differenti. metodi Java si fa riferimento a un metodo di istanza, quindi questo di solito si riferisce all'oggetto corrente. La linea di codice Ruby per riga, quindi in un diverso contesto (context) auto hanno un significato diverso. Diamo uno sguardo ai seguenti esempi: 

#!/usr/bin/ruby -w

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

Quando viene eseguito il codice di cui sopra, esso produrrà i seguenti risultati: 

Class of self = Class
Name of self = Box

Ciò significa che la classe può essere definita dalla classe come oggetto corrente per eseguire, ma significa anche che meta-classe e la definizione di metodo classe padre durante l'esecuzione del processo è disponibile.