Latest web development tutorials

Ruby orientada a objeto

Ruby é uma linguagem orientada a objetos pura, Ruby, tudo é na forma de objetos. Cada valor em Ruby é um objeto, mesmo a coisa mais primitiva: Cordas, números e até mesmo o verdadeiro eo falso são objetos. A classe em si é umobjeto queé uma instânciadaclasseClass.Este capítulo diz-lhe explicar todas as principais funções associadas com o objeto orientada Ruby.

Classe é usada para formar o objeto especificado, que combina representação de dados e métodos para organizar dados em um pacote puro. dados e métodos de classe são chamados os membros da classe.

definição de classe de Ruby

Quando você define uma classe, você realmente definir um modelo para um tipo de dados. Isso realmente não define quaisquer dados, mas a definição do que o nome dos meios de classe, isto é, a definição do que constitui um objeto da classe será, e quais ações podem ser executadas no objeto.

definição de classe começa com a palavra-chaveclass, seguido pelo nomedaclasse,e, finalmente,terminarcom uma representação separada reduzir tais definições. Por exemplo, usamos a palavra-chave class para definir a classe Box, como segue: 

class Box
   code
end

Por convenção, o nome deve começar com uma letra maiúscula, se contiver mais de uma palavra, capitalizar a primeira letra de cada palavra, mas aqui não é delimitador (por exemplo: CamelCase).

definições de objetos de Ruby

Classe fornece o modelo para um objeto, então, basicamente, o objeto é criado de acordo com a classe. Usamos anova palavra-chave para declarar o objeto de classe.A declaração a seguir declara a caixa de classe dois objetos: 

box1 = Box.new
box2 = Box.new

método de inicializar

método deinicializar é um método padrão de classe Ruby é o construtor da classe, similar a outras obras do construtorlinguagens de programação orientada a objeto. Quando você quiser inicializar algumas variáveis ​​na classe para criar um objeto ao mesmo tempo, inicializar método vem a calhar. O método tem uma série de argumentos, assim como outros métodos Ruby, usando este método, deve ser colocada na frenteda chave DEF,como segue: 

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

variáveis ​​de instância

variáveis de instância de classe de propriedade é que eles criam ao usar o objeto de classe vai se tornar propriedade do objeto.propriedades individuais de cada objeto é atribuído, entre outros objetos, e não compartilham valores. Dentro da classe é usar o operador @ para acessar essas propriedades fora da classe, écomum a utilização deum método chamadométodos de acessode acesso. Aqui definimos oBox classe acima como um exemplo, o @largura classe Box e @height como variáveis de instância.

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

Acessores (acessor) & setter método (setter)

Para utilizar variáveis externas da classe, devemos definir essas variáveis nosmétodos de acesso internos,acessor é ogetter equivalente.O seguinte exemplo demonstra o método de acesso: 

#!/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 o código acima é executado, ele irá produzir os seguintes resultados: 

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

Similar aos métodos de acesso usados para acessar os valores das variáveis, Ruby fornece uma maneira de definir o valor externo variável da classe A, também conhecido comométodo setter, definido como 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 o código acima é executado, ele irá produzir os seguintes resultados: 

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

Métodos da instância

Definiros métodos de instância e outros métodos definidos, estão a utilizar a palavra-chave DEF,mas só pode ser usado por uma instância da classe, tal como mostrado nos exemplos seguintes. Sua função não se limita a acessar variáveis ​​de instância, mas também de acordo com suas necessidades de fazer mais outras tarefas. 

#!/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 o código acima é executado, ele irá produzir os seguintes resultados: 

Area of the box is : 200

métodos de classe de classe variáveis ​​&

Variáveis de classe são todas as instâncias de uma classe compartilhada variáveis.Em outras palavras, as variáveis ​​de instância de classe pode ser acessado de todas as instâncias de objetos. variável de classe, com dois caracteres @ (@@) como um prefixo, variáveis ​​de classe deve ser inicializado na definição de classe, como mostrado nos exemplos a seguir.

método de classe def self.methodname ()definição, um método de classe para terminar delimitador. Métodos de classe pode ser utilizada com a forma nome de classeclassname.methodname da chamada, como mostrado nos exemplos seguintes:

#!/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 o código acima é executado, ele irá produzir os seguintes resultados: 

Box count is : 2

método to_s

Qualquer classe tem um método de instânciato_s que você define para retornar uma representação de string do objeto.Aqui está um exemplo simples, de acordo com a largura e altura representam objetos 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}"

Quando o código acima é executado, ele irá produzir os seguintes resultados: 

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

Controle de acesso

Rubi oferece três níveis de métodos de instância de proteção, que sãopública, privada ou protegida.Qualquer aplicação de controle de acesso não está na instância e de classe variáveis ​​Ruby.

  • Método público: métodos públicospode ser chamado de qualquer objeto. Por padrão, os métodos são públicos, exceto para o método initialize é sempre privado.
  • Métodos privados: métodos privadosnão pode ser acessado ou visto de fora da classe. Apenas métodos de classe podem acessar membros privados.
  • Método protegido: Protected método só pode ser chamado de uma classe de objeto e suas subclasses.O acesso apenas pode ser realizada em uma classe interna e suas subclasses.

Aqui está um exemplo simples que demonstra a sintaxe de três modificador: 

#!/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 o código acima é executado, ele irá produzir os seguintes resultados. Aqui, a primeira chamada de método tiver êxito, mas o segundo método terá um problema. 

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

A herança de classe

Herança, programação orientada a objetos é um dos conceitos mais importantes. Herança nos permite definir uma classe com base em outra classe, o que torna a criação e manutenção de aplicações muito mais fácil.

Herança ajuda a reutilização de código e execução rápida, infelizmente, Ruby não suporta herança múltipla, masmixins suporte Ruby.mixin é como uma implementação específica de herança múltipla, herança múltipla, apenas uma parte da interface é hereditária.

Quando você cria uma classe, o programador pode especificar uma nova classe que herda de uma classe existente de membros, por isso não escrever a partir do zero os novos membros de dados e funções de membro. A classe existente é chamada declasse base ou classe pai, a nova classe é chamado as classes derivadas ou subclasses.

Rubi também fornece uma subclasse conceito subclasse que é herdada, o seguinte exemplo ilustra esse conceito. Estendendo uma sintaxe classe é muito simples. Basta adicionar um <nome do personagem e da classe pai para a lata declaração de classe. Por exemplo, a seguir define uma classeBigBoxBox é uma subclasse: 

#!/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 o código acima é executado, ele irá produzir os seguintes resultados: 

Big box area is : 200

sobrecarga de método

Embora seja possível adicionar novos recursos em uma classe derivada, mas às vezes você pode querer mudar o comportamento foi definido nos métodos da classe pai. Em seguida, é possível manter o mesmo nome de método, a função pode ser sobrecarregado métodos, como mostrado nos exemplos seguintes: 

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

Execute o exemplo acima saída é: 

Big box area is : 200

sobrecarga de operadores

Queremos usar o operador + realiza a adição do vetor de dois objetos da caixa, use o operador * para a largura e altura da caixa multiplicado usando operador unário - a largura e altura da caixa negada. Aqui está uma versão da aula de matemática com a definição 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

objeto congelado

Às vezes, queremos evitar que um objeto é alterado. No objeto, método de congelamento pode conseguir isso, ele pode efetivamente colocar um objeto em uma constante. Qualquer objeto pode ser congelado chamandoObject.freeze.objeto congelado não pode ser modificada, ou seja, você não pode mudar suas variáveis ​​de instância.

Você pode usarObject.frozen? Método para verificar se um determinado objeto foi congelado.Se o objeto foi congelada, o método retorna true, caso contrário, ele retorna um valor falso. O exemplo a seguir ilustra esse conceito: 

#!/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 o código acima é executado, ele irá produzir os seguintes resultados: 

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

constantes de classe

Você pode definir uma classe interna constante, por um valor numérico ou string directo a uma definição de variável, que não requer o uso @ constante ou @@. Por convenção, o nome do maiúsculas uso constante.

Uma vez que uma constante é definida, você não pode mudar o seu valor, você pode acessar diretamente as constantes internas na classe, assim como o acesso à mesma variável, mas se você quiser acessar constante de classe externo, então você deve usar onome da classe :: constante, como mostrado nos exemplos seguintes. 

#!/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 o código acima é executado, ele irá produzir os seguintes resultados: 

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

constantes de classe pode ser herdada, mas também o mesmo que o método de instância está sobrecarregado.

Use alocar criar objetos

Pode haver um caso, você quer criar um objeto sem chamar o construtorinicializar o objeto, esse objeto é criado usando o novo método, neste caso, você pode chamar alocar para criar um objeto não inicializado, como os exemplos a seguir como se 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 o código acima é executado, ele irá produzir os seguintes resultados: 

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

Informações classe

auto e Java Ruby isso são semelhantes, mas diferentes. métodos Java são referenciados em um método de instância, de modo que este geralmente se refere ao objeto atual. A linha de código Ruby por linha, por isso em um contexto (contexto) auto diferente ter um significado diferente. Vamos dar uma olhada nos seguintes exemplos: 

#!/usr/bin/ruby -w

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

Quando o código acima é executado, ele irá produzir os seguintes resultados: 

Class of self = Class
Name of self = Box

Isto significa que a classe pode ser definido pela classe como o objeto atual de executar, mas também significa que meta-classe e a definição do método da classe pai durante a execução do processo está disponível.