Orientação a Objetos Ruby

definição de classe Ruby

Quando você define uma classe, você realmente define um esboço de tipo de dados. Isso não define nenhum dado, mas define o que significa o nome da classe, ou seja, define do que os objetos da classe serão compostos e quais operações podem ser executadas neles.

A definição da classe começa com a palavra-chave class começa, seguido pornome da classe，e, finalmente, com um end para separar e indicar o fim da definição da classe. Por exemplo, usamos a palavra-chave class para definir a classe Box, conforme mostrado a seguir:

class Box
　　　code
end

Segundo a convenção, o nome deve começar com letra maiúscula, e se contiver várias palavras, cada palavra deve começar com letra maiúscula, sem separadores (por exemplo: CamelCase).

para definir objetos Ruby

A classe fornece o esboço do objeto, então, basicamente, os objetos são criados com base na classe. Usamos new palavras-chave para declarar objetos da classe. As seguintes declarações declaram dois objetos da classe Box:

box1　= Box.new
box2　= Box.new

initialize

initialize método é um método padrão de classe Ruby, que é o construtor da classe, semelhante ao método initialize em outras linguagens de programação orientadas a objetos. constructor O princípio de funcionamento é semelhante. Quando você deseja inicializar algumas variáveis de classe ao criar um objeto, o método initialize é útil. Este método possui uma série de parâmetros, como outros métodos Ruby, e deve ser precedido por def palavras-chave, conforme mostrado a seguir:

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

exemplo de variável

exemplo de variávelSão atributos de classe, que se tornam atributos do objeto ao criar objetos da classe. Cada atributo do objeto é atribuído separadamente, não compartilhando valores entre objetos diferentes. Dentro da classe, esses atributos são acessados usando o operador @, e fora da classe, são usados chamadosMétodos de acessordePúblicoMétodo para acessar. Vamos usar a classe definida acima Box Por exemplo, use @width e @height como variáveis de exemplo da classe Box.

class Box
　　　def initialize(w,h)
　　　　　　# Atribuição de exemplo variável
　　　　　　@width, @height = w, h
　　　end
end

Métodos de acessor (getter) & configurador (setter)

Para ler variáveis definidas dentro da classe externamente, podemos definir métodos de acessor (getter) para acessá-las. O exemplo a seguir demonstra o uso do método de acessor:

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　# Construtor
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　
　　　#　Métodos de acesso
　　　def printWidth
　　　　　　@width
　　　end
　
　　　def printHeight
　　　　　　@height
　　　end
end
　
# Criação de objeto, inicialização da altura e largura da caixa
box = Box.new(10,　20)
　
#　Usar métodos de acesso
x = box.printWidth()
y = box.printHeight()
　
puts "Largura da caixa: #{x}"
puts "Altura da caixa: #{y}"

Quando o código acima for executado, ele produzirá o seguinte resultado:

Largura da caixa:　10
Altura da caixa:　20

Semelhante aos métodos de acessor para acessar valores de variáveis, o Ruby oferece uma maneira de passar parâmetros para dentro da classe já definida, chamadaMétodos de configurador，definido como follows:

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　# Constructor method
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　
　　　#　Métodos de acesso
　　　def　getWidth
　　　　　　@width
　　　end
　　　def　getHeight
　　　　　　@height
　　　end
　
　　　#　Métodos de configuração
　　　def　setWidth=(value)
　　　　　　@width　=　value
　　　end
　　　def　setHeight=(value)
　　　　　　@height　=　value
　　　end
end
　
# Create object
box = Box.new(10,　20)
　
# Uso do método de configurador
box.setWidth　=　30
box.setHeight　=　50
　
#　Usar métodos de acesso
x　=　box.getWidth()
y　=　box.getHeight()
　
puts "Largura da caixa: #{x}"
puts "Altura da caixa: #{y}"

Quando o código acima for executado, ele produzirá o seguinte resultado:

Largura da caixa:　30
Altura da caixa:　50

Devido à alta frequência de uso dos dois métodos, o Ruby definiu attr_accessor :variable_name、attr_reader :variable_name、attr_writer :variable_name Três métodos de declaração de atributos. Entre eles:accessor=reader+writer.

Atenção: o nome da variável deve ser precedido por : e as variáveis devem ser separadas por ,

Métodos de exemplo

Métodos de exemploDefinição é idêntica à definição de outros métodos, todas usam def Palavras-chave, mas podem ser usadas apenas através de instâncias da classe, conforme exemplo a seguir. Suas funcionalidades não se limitam a acessar variáveis de exemplo, mas também podem realizar outras tarefas conforme necessário.

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　# Construtor
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　　　# Example method
　　　def getArea
　　　　　　@width　*　@height
　　　end
end
　
# Create object
box = Box.new(10,　20)
　
# Calling example method
a = box.getArea()
puts "Area of the box is: #{a}"

Quando o código acima for executado, ele produzirá o seguinte resultado:

Area of the box is:　200

Métodos e variáveis de classe

Variáveis de classesão variáveis compartilhadas entre todas as instâncias da classe. Em outras palavras, as instâncias de variáveis de classe podem ser acessadas por todos os objetos de exemplo. As variáveis de classe começam com dois caracteres @ (@@) como prefixo, e as variáveis de classe devem ser inicializadas dentro da definição da classe, conforme exemplo a seguir.

Métodos de classeUso def self.methodname() Definição, métodos de classe terminam com o delimitador end. Os métodos de classe podem usar nomes de classe com classname.methodname Chamada de forma, conforme exemplo a seguir:

Exemplos Online

#!/usr/bin/ruby　-w
　
class Box
　　　# Inicialização da variável de classe
　　　@@count = 0
　　　def initialize(w,h)
　　　　　　# Atribuição de exemplo variável
　　　　　　@width, @height = w, h
　
　　　　　　@@count　+=　1
　　　end
　
　　　def self.printCount()
　　　　　　puts "Contagem da caixa é: #@@count"
　　　end
end
　
#　Cria dois objetos
box1　= Box.new(10,　20)
box2　= Box.new(30,　100)
　
#　Chama método de classe para output de contagem de caixa
Box.printCount()

Quando o código acima for executado, ele produzirá o seguinte resultado:

Contagem de Box é:　2

método to_s

Qualquer classe que você definir tem um to_s Métodos exemplo para retornar a representação string do objeto. A seguir, há um exemplo simples que representa o objeto Box com base em width e height:

Exemplos Online

#!/usr/bin/ruby　-w
　
class Box
　　　# Constructor method
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　　　#　Define método to_s
　　　def to_s
　　　　　　"(w:#@largura,h:#@altura)"　　#　Formatação de string do objeto
　　　end
end
　
# Create object
box = Box.new(10,　20)
　
#　Chama automaticamente o método to_s
puts "Representação string da caixa é: #{caixa}"

Quando o código acima for executado, ele produzirá o seguinte resultado:

Representação string da caixa é: (w:10,h:20)

Controle de acesso

O Ruby oferece três níveis de proteção de métodos de exemplo, respectivamente public, private ou protectedO Ruby não aplica nenhum controle de acesso a exemplos e variáveis de classe.

• Métodos públicos: Métodos públicos podem ser chamados por qualquer objeto. Por padrão, métodos são públicos, exceto o método initialize, que sempre é privado.

• Métodos privados: Métodos privados não podem ser acessados ou vistos de fora da classe. Apenas métodos da classe podem acessar membros privados.

• Métodos protegidos: Métodos protegidos podem ser chamados apenas pelos objetos da classe e suas subclasses. O acesso também pode ser feito dentro da classe e suas subclasses.

A seguir, há um exemplo simples que demonstra a sintaxe desses três modificadores:

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　# Constructor method
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　
　　　#　Métodos exemplo são públicos por padrão
　　　def getArea
　　　　　　getWidth()　*　getHeight
　　　end
　
　　　#　Defina métodos de acesso privados
　　　def　getWidth
　　　　　　@width
　　　end
　　　def　getHeight
　　　　　　@height
　　　end
　　　#　Faça-os privados
　　　privado　:getWidth,　:getHeight
　
　　　#　Método exemplo para saída de área
　　　def printArea
　　　　　　@área　=　getWidth()　*　getHeight
　　　　　　puts "Big box area is: #@area"
　　　end
　　　#　Faça o método exemplo ser protegido
　　　protegido　:printArea
end
　
# Create object
box = Box.new(10,　20)
　
# Calling example method
a = box.getArea()
puts "Area of the box is: #{a}"
　
#　Tentativa de chamar método protegido de exemplo
box.printArea()

Quando o código acima for executado, ele produzirá os seguintes resultados. Aqui, a primeira chamada de método foi bem-sucedida, mas a segunda método causará um problema.

Area of the box is:　200
test.rb:42:　protegido　método　`printArea'　chamado　para　#
<Caixa:0xb7f11280　@altura=20,　@largura=10>　(Não há método)

Class inheritance

inheritance, which is one of the most important concepts in object-oriented programming. Inheritance allows us to define a class based on another class, making it easier to create and maintain applications.

Inheritance helps to reuse code and execute quickly, unfortunately, Ruby does not support multiple inheritance, but Ruby supports mixins.

When creating a class, the programmer can directly specify that the new class inherits from the members of an existing class, so that new data members and member functions do not have to be written from scratch. This existing class is calledbase class or superclass, the new class is calledDerived class or subclass.

Ruby also provides the concept of subclassing, which is inheritance. The following example explains this concept. The syntax for extending a class is very simple. Just add a < character and the name of the superclass to the class statement. For example, the following defines the class BigBox is Box The subclass of

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　# Constructor method
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　　　# Example method
　　　def getArea
　　　　　　@width　*　@height
　　　end
end
　
# Define subclass
class BigBox < Box
　
　　　# Add a new example method
　　　def printArea
　　　　　　@area = @width　*　@height
　　　　　　puts "Big box area is: #@area"
　　　end
end
　
# Create object
box = BigBox.new(10,　20)
　
# Output area
box.printArea()

Quando o código acima for executado, ele produzirá o seguinte resultado:

Big box area is :　200

Method overloading

Although you can add new features in the derived class, sometimes you may want to change the behavior of methods already defined in the superclass. In this case, you can keep the method name unchanged and overload the functionality of the method, as shown in the following example:

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　# Constructor method
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　　　# Example method
　　　def getArea
　　　　　　@width　*　@height
　　　end
end
　
# Define subclass
class BigBox < Box
　
　　　# Modify the existing getArea method
　　　def getArea
　　　　　　@area = @width　*　@height
　　　　　　puts "Big box area is: #@area"
　　　end
end
　
# Create object
box = BigBox.new(10,　20)
　
# Output area using overloaded method
box.getArea()

The output result of the above example is as follows:

Big box area is :　200

operator overloading

We hope to use + An operator to perform vector addition of two Box objects, using * An operator to multiply the width and height of Box, using a unary operator - The following is a version of the Box class with mathematical operator definitions:

class Box
　　def initialize(w,h) # Initialize width and height
　　　　@width, @height = w, h
　　end
　
　　def　+(other) # Define　+　to perform vector addition
　　　　Box.new(@width　+　other.width, @height　+　other.height)
　　end
　
　　def　-# Define a unary operator　-　inverter of width and height
　　　　Box.new(-@width,　-@height)
　　end
　
　　def　*(scalar)　　　　　　　　#　Faz a multiplicação escalar
　　　　Box.new(@width*scalar,　@height*scalar)
　　end
end

congelar objeto

Às vezes, queremos evitar que um objeto seja modificado. No Object, o método freeze pode fazer isso, transformando eficazmente um objeto em uma constante. Qualquer objeto pode ser congelado chamando Object.freeze para congelar. Um objeto congelado não pode ser modificado, o que significa que você não pode mudar suas variáveis de exemplo.

Você pode usar Object.frozen? O método verifica se um objeto específico já foi congelado. Se o objeto já foi congelado, o método retornará true, caso contrário, retornará um valor false. O exemplo a seguir explica esse conceito:

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　# Constructor method
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　
　　　#　Métodos de acesso
　　　def　getWidth
　　　　　　@width
　　　end
　　　def　getHeight
　　　　　　@height
　　　end
　
　　　#　Métodos de configuração
　　　def　setWidth=(value)
　　　　　　@width　=　value
　　　end
　　　def　setHeight=(value)
　　　　　　@height　=　value
　　　end
end
　
# Create object
box = Box.new(10,　20)
　
#　Vamos congelar o objeto
box.freeze
if(　box.frozen?　)
　　　puts　"O objeto caixa é um objeto congelado"
else
　　　puts　"O objeto caixa é um objeto normal"
end
　
#　Tente usar métodos de configuração agora
box.setWidth　=　30
box.setHeight　=　50
　
#　Usar métodos de acesso
x　=　box.getWidth()
y　=　box.getHeight()
　
puts　"Largura da caixa é:　#{x}"
puts　"Altura da caixa é:　#{y}"

Quando o código acima for executado, ele produzirá o seguinte resultado:

O objeto Box é um objeto congelado
test.rb:20:in　`setWidth=':　can't　modify　frozen　object　(TypeError)
　　　　　　　　from　test.rb:39

Constante de classe

Você pode definir uma constante dentro da classe, atribuindo um valor direto ou uma string a uma variável, a definição de constante não requer o uso de @ ou @@. Segundo a convenção, os nomes das constantes são usados em maiúsculas.

Uma vez que um constante for definida, você não pode mudar seu valor, você pode acessar a constante diretamente dentro da classe, como se fosse um variável, mas se você quiser acessar a constante fora da classe, você deve usar classname::constant，as shown in the following example.

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　BOX_COMPANY = "TATA Inc"
　　　BOXWEIGHT =　10
　　　# Constructor method
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　　　# Example method
　　　def getArea
　　　　　　@width　*　@height
　　　end
end
　
# Create object
box = Box.new(10,　20)
　
# Calling example method
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 for executado, ele produzirá o seguinte resultado:

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

Class constants can be inherited and can also be overloaded like example methods.

Using allocate to create an object

There may be a situation where you want to create an object without calling the object constructor initialize In the case of creating an object, that is, using the new method to create an object, in this case, you can call allocate to create an uninitialized object, as shown in the following example:

Exemplos Online

#!/usr/bin/ruby　-w
　
# Define class
class Box
　　　attr_accessor :width, :height
　
　　　# Constructor method
　　　def initialize(w,h)
　　　　　　@width, @height = w, h
　　　end
　
　　　# Example method
　　　def getArea
　　　　　　@width　*　@height
　　　end
end
　
# Using new to create an object
box1　= Box.new(10,　20)
　
# Using allocate to create another object
box2　= Box.allocate
　
# Using box1　Calling example method
a = box1.getArea()
puts "Area of the box is: #{a}"
　
# Using box2　Calling example method
a = box2.getArea()
puts "Area of the box is: #{a}"

Quando o código acima for executado, ele produzirá o seguinte resultado:

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

Class Information

Ruby's self and Java's this have similarities, but they are also quite different. Java methods are always referred to in the context of an example method, so this usually points to the current object. In Ruby, code is executed line by line, so self has different meanings in different contexts. Let's take a look at the following example:.

Exemplos Online

#!/usr/bin/ruby　-w
　
class Box
　　　# Output de informações de classe
　　　puts "Classe do self = #{self.class}"
　　　puts "Nome do self = #{self.name}"
end

Quando o código acima for executado, ele produzirá o seguinte resultado:

Classe do self = Class
Nome do self = Box

Isso significa que a definição da classe pode ser executada atribuindo a classe como o objeto atual, o que também significa que o método na metaclasse e na classe pai está disponível durante a execução da definição do método.