Ruby 中的面向对象编程

原文： https://zetcode.com/lang/rubytutorial/oop/

在 Ruby 教程的这一部分中，我们将讨论 Ruby 中的面向对象编程。

编程语言具有过程编程，函数式编程和面向对象的编程范例。 Ruby 是一种具有某些函数式和过程特性的面向对象的语言。

面向对象编程（OOP）是一种使用对象及其相互作用设计应用和计算机程序的编程范例。

OOP 中的基本编程概念是：

抽象
多态
封装
继承

抽象通过建模适合该问题的类来简化复杂的现实。多态是将运算符或函数以不同方式用于不同数据输入的过程。封装对其他对象隐藏了类的实现细节。继承是一种使用已经定义的类形成新类的方法。

Ruby 对象

对象是 Ruby OOP 程序的基本构建块。对象是数据和方法的组合。在 OOP 程序中，我们创建对象。这些对象通过方法进行通信。每个对象都可以接收消息，发送消息和处理数据。

创建对象有两个步骤。首先，我们定义一个类。类是对象的模板。它是一个蓝图，描述了类对象共享的状态和行为。一个类可以用来创建许多对象。在运行时从类创建的对象称为该特定类的实例。

#!/usr/bin/ruby

class Being

end

b = Being.new
puts b

在第一个示例中，我们创建一个简单的对象。

class Being

end

这是一个简单的类定义。模板的主体为空。它没有任何数据或方法。

b = Being.new

我们创建Being类的新实例。为此，我们有new方法。 b变量存储新创建的对象。

puts b

我们将对象打印到控制台以获取该对象的一些基本描述。实际上，当我们打印对象时，我们将其称为to_s方法。但是我们还没有定义任何方法。这是因为创建的每个对象都继承自基本Object。它具有一些基本功能，这些功能在所有创建的对象之间共享。其中之一是to_s方法。

$ ./simple.rb
#<Being:0x9f3c290>

我们得到对象类名。

Ruby 构造器

构造器是一种特殊的方法。创建对象时会自动调用它。构造器不返回值。构造器的目的是初始化对象的状态。 Ruby 中的构造器称为initialize。构造器不返回任何值。

使用super方法调用父对象的构造器。它们按继承顺序被调用。

#!/usr/bin/ruby

class Being

    def initialize
        puts "Being is created"
    end

end

Being.new

我们有一个存在类。

class Being

    def initialize
        puts "Being is created"
    end

end

Betweening类具有一个名为initialize的构造方法。它将消息打印到控制台。 Ruby 方法的定义位于def和end关键字之间。

Being.new

创建Being类的实例。创建对象时，将调用构造方法。

$ ./constructor.rb
Being is created

这是程序的输出。

对象的属性是捆绑在该对象内部的数据项。这些项目也称为实例变量或成员字段。实例变量是在类中定义的变量，该类中的每个对象都有一个单独的副本。

在下一个示例中，我们初始化类的数据成员。变量的初始化是构造器的典型工作。

#!/usr/bin/ruby

class Person

    def initialize name
        @name = name
    end

    def get_name
        @name
    end

end

p1 = Person.new "Jane"
p2 = Person.new "Beky"

puts p1.get_name
puts p2.get_name

在上面的 Ruby 代码中，我们有一个带有一个成员字段的Person类。

class Person

    def initialize name
        @name = name
    end

在Person类的构造器中，我们将一个member字段设置为一个值名称。名称参数在创建时传递给构造器。构造器是称为initialize的方法，该方法在创建实例对象时被调用。 @name是一个实例变量。实例变量在 Ruby 中以@字符开头。

def get_name
    @name
end

get_name方法返回成员字段。在 Ruby 中，成员字段只能通过方法访问。

p1 = Person.new "Jane"
p2 = Person.new "Beky"

我们创建Person类的两个对象。字符串参数传递给每个对象构造器。名称存储在每个对象唯一的实例变量中。

puts p1.get_name
puts p2.get_name

我们通过在每个对象上调用get_name来打印成员字段。

$ ./person.rb
Jane
Beky

我们看到了程序的输出。 Person类的每个实例都有其自己的名称成员字段。

我们可以创建对象而无需调用构造器。 Ruby 为此有一种特殊的allocate方法。 allocate方法为类的新对象分配空间，并且不会在新实例上调用initialize。

#!/usr/bin/ruby

class Being

   def initialize
       puts "Being created"
   end   
end

b1 = Being.new
b2 = Being.allocate
puts b2

在示例中，我们创建两个对象。第一个对象使用new方法，第二个对象使用allocate方法。

b1 = Being.new

在这里，我们使用new关键字创建对象的实例。调用构造器方法initialize，并将消息打印到控制台。

b2 = Being.allocate
puts b2

在allocate方法的情况下，不调用构造器。我们使用puts关键字调用to_s方法以显示该对象已创建。

$ ./allocate.rb
Being created
#<Being:0x8ea0044>

在这里，我们看到了程序的输出。

Ruby 构造器重载

构造器重载是在一个类中具有多种类型的构造器的能力。这样，我们可以创建具有不同数量或不同类型参数的对象。

Ruby 没有我们从某些编程语言中知道的构造器重载。可以使用 Ruby 中的默认参数值在某种程度上模拟此行为。

#!/usr/bin/ruby

class Person

    def initialize name="unknown", age=0
        @name = name
        @age = age        
    end

    def to_s
        "Name: #{@name}, Age: #{@age}"
    end

end

p1 = Person.new
p2 = Person.new "unknown", 17
p3 = Person.new "Becky", 19
p4 = Person.new "Robert"

p p1, p2, p3, p4

本示例说明了如何在具有两个成员字段的Person类上模拟构造器重载。如果未指定name参数，则使用字符串"unknown"。对于未指定的年龄，我们为 0。

def initialize name="unknown", age=0
    @name = name
    @age = age        
end

构造器有两个参数。它们具有默认值。如果在创建对象时未指定自己的值，则使用默认值。请注意，必须保留参数的顺序。首先是名字，然后是年龄。

p1 = Person.new
p2 = Person.new "unknown", 17
p3 = Person.new "Becky", 19
p4 = Person.new "Robert"

p p1, p2, p3, p4

我们创建四个对象。构造器采用不同数量的参数。

$ ./consover.rb
Name: unknown, Age: 0
Name: unknown, Age: 17
Name: Becky, Age: 19
Name: Robert, Age: 0

这是示例的输出。

Ruby 方法

方法是在类主体内定义的函数。它们用于通过对象的属性执行操作。在 OOP 范式的封装概念中，方法至关重要。例如，我们的AccessDatabase类中可能有一个connect方法。我们无需告知该方法如何准确地连接到数据库。我们只需要知道它用于连接数据库。这对于划分编程中的职责至关重要，尤其是在大型应用中。

在 Ruby 中，只能通过方法访问数据。

#!/usr/bin/ruby

class Person

    def initialize name
        @name = name
    end

    def get_name
        @name
    end

end

per = Person.new "Jane"

puts per.get_name
puts per.send :get_name

该示例显示了两种调用方法的基本方法。

puts per.get_name

常见的方法是在对象上使用点运算符，后跟方法名称。

puts per.send :get_name

替代方法是使用内置的send方法。它以方法的符号作为参数。

方法通常对对象的数据执行某些操作。

#!/usr/bin/ruby

class Circle

    @@PI = 3.141592

    def initialize
        @radius = 0
    end

    def set_radius radius
        @radius = radius
    end

    def area
        @radius * @radius * @@PI
    end

end

c = Circle.new
c.set_radius 5
puts c.area

在代码示例中，我们有一个Circle类。我们定义了两种方法。

@@PI = 3.141592

我们在Circle类中定义了@@PI变量。它是一个类变量。类变量以 Ruby 中的@@信号开头。类变量属于类，而不属于对象。每个对象都可以访问其类变量。我们使用@@PI计算圆的面积。

def initialize
    @radius = 0
end

我们只有一个成员字段。它是圆的半径。如果要从外部修改此变量，则必须使用公共可用的set_radius方法。数据受到保护。

def set_radius radius
    @radius = radius
end

这是set_radius方法。它为@radius实例变量提供了一个新值。

def area
    @radius * @radius * @@PI
end

area方法返回圆的面积。这是方法的典型任务。它可以处理数据并为我们带来一些价值。

c = Circle.new
c.set_radius 5
puts c.area

我们创建Circle类的实例，并通过在圆对象上调用set_radius方法来设置其半径。我们使用点运算符来调用该方法。

$ ./circle.rb
78.5398

运行示例，我们得到此输出。

Ruby 访问修饰符

访问修饰符设置方法和成员字段的可见性。 Ruby 具有三个访问修饰符：public，protected和private。在 Ruby 中，所有数据成员都是私有的。访问修饰符只能在方法上使用。除非我们另有说明，否则 Ruby 方法是公共的。

可以从类的定义内部以及从类的外部访问public方法。 protected和private方法之间的区别很细微。在类的定义之外都无法访问它们。只能在类本身内部以及继承的或父类访问它们。

请注意，与其他面向对象的编程语言不同，继承在 Ruby 访问修饰符中不扮演的角色。只有两件事很重要。首先，如果我们在类定义的内部或外部调用方法。其次，如果我们使用或不使用指向当前接收器的self关键字。

访问修饰符可防止意外修改数据。它们使程序更强大。某些方法的实现可能会发生变化。这些方法是很好的私有方法。公开给用户的接口仅应在确实必要时更改。多年来，用户习惯于使用特定的方法，并且通常不赞成向后兼容。

#!/usr/bin/ruby

class Some

     def method1
         puts "public method1 called"
     end

    public

     def method2
         puts "public method2 called"  
     end

     def method3
         puts "public method3 called"
         method1
         self.method1
     end          
end

s = Some.new
s.method1
s.method2
s.method3

该示例说明了公共 Ruby 方法的用法。

def method1
    puts "public method1 called"
end

即使我们未指定public访问修饰符，method1也是公共的。这是因为如果没有另外指定，默认情况下方法是公共的。

public

  def method2
      puts "public method2 called"  
  end

  ...

public关键字后面的方法是公共的。

def method3
    puts "public method3 called"
    method1
    self.method1
end

从公共method3内部，我们调用带有和不带有self关键字的其他公共方法。

s = Some.new
s.method1
s.method2
s.method3

公共方法是唯一可以在类定义之外调用的方法，如下所示。

$ ./public_methods.rb
public method1 called
public method2 called
public method3 called
public method1 called
public method1 called

运行示例，我们将获得以下输出。

下一个示例着眼于私有方法。

#!/usr/bin/ruby

class Some

    def initialize
        method1
        # self.method1
    end

    private

     def method1
         puts "private method1 called"  
     end

end

s = Some.new
# s.method1

私有方法是 Ruby 中最严格的方法。只能在类定义内调用它们，而不能使用self关键字。

def initialize
    method1
    # self.method1
end

在方法的构造器中，我们称为私有method1。带有self的方法被注释。接收者无法指定私有方法。

private

  def method1
      puts "private method1 called"  
  end

关键字private之后的方法在 Ruby 中是私有的。

s = Some.new
# s.method1

我们创建Some类的实例。禁止在类定义之外调用该方法。如果我们取消注释该行，则 Ruby 解释器将给出错误。

$ ./private_methods.rb
private method called

示例代码的输出。

最后，我们将使用受保护的方法。 Ruby 中的保护方法和私有方法之间的区别非常微妙。受保护的方法就像私有的。只有一个小差异。可以使用指定的self关键字来调用它们。

#!/usr/bin/ruby

class Some

    def initialize
        method1
        self.method1
    end

    protected

     def method1
         puts "protected method1 called"  
     end

end

s = Some.new
# s.method1

上面的示例显示了使用中的受保护方法。

def initialize
    method1
    self.method1
end

可以使用self关键字来调用受保护的方法。

protected

  def method1
      puts "protected method1 called"  
  end

受保护的方法前面带有protected关键字。

s = Some.new
# s.method1

不能在类定义之外调用受保护的方法。取消注释该行将导致错误。

Ruby 继承

继承是一种使用已经定义的类形成新类的方法。新形成的类称为派生的类，我们派生的类称为基类。继承的重要好处是代码重用和降低程序的复杂性。派生类（后代）将覆盖或扩展基类（祖先）的功能。

#!/usr/bin/ruby

class Being

    def initialize
        puts "Being class created"
    end
end

class Human < Being

   def initialize
       super
       puts "Human class created"
   end
end

Being.new
Human.new

在此程序中，我们有两个类：基础Being类和派生的Human类。派生类继承自基类。

class Human < Being

在 Ruby 中，我们使用<运算符创建继承关系。 Human类继承自Being类。

def initialize
    super
    puts "Human class created"
end

super方法调用父类的构造器。

Being.new
Human.new

我们实例化Being和Human类。

$ ./inheritance.rb 
Being class created
Being class created
Human class created

首先创建Being类。派生的Human类还调用其父级的构造器。

对象可能涉及复杂的关系。一个对象可以有多个祖先。 Ruby 有一个方法ancestors，它提供了特定类的祖先列表。

每个 Ruby 对象自动是Object和BasicObject类以及Kernel模块的后代。它们内置在 Ruby 语言的核心中。

#!/usr/bin/ruby

class Being 
end

class Living < Being 
end

class Mammal < Living 
end

class Human < Mammal 
end

p Human.ancestors

在此示例中，我们有四个类：Human是Mammal，Living和Being。

p Human.ancestors

我们打印人类类的祖先。

$ ./ancestors.rb 
[Human, Mammal, Living, Being, Object, Kernel, BasicObject]

人类类具有三个习俗和三个内置祖先。

接下来是一个更复杂的示例。

#!/usr/bin/ruby

class Being

    @@count = 0

    def initialize
        @@count += 1
        puts "Being class created"
    end

    def show_count
        "There are #{@@count} beings"
    end

end

class Human < Being

   def initialize
       super
       puts "Human is created"
   end
end

class Animal < Being

   def initialize
       super
       puts "Animal is created"
   end
end

class Dog < Animal

   def initialize
       super
       puts "Dog is created"
   end
end

Human.new
d = Dog.new
puts d.show_count

我们有四个类。继承层次更加复杂。 Human和Animal类继承自Being类。 Dog类直接继承自Animal类，并且进一步继承自Being类。我们还使用一个类变量来计算创建的生物的数量。

@@count = 0

我们定义一个类变量。类变量以@@信号开头，并且它属于该类，而不是该类的实例。我们用它来计算创造的生物数量。

def initialize
    @@count += 1
    puts "Being class created"
end

每次实例化Being类时，我们都会将@@count变量加 1。这样，我们就可以跟踪创建的实例数。

class Animal < Being
...

class Dog < Animal
...

Animal继承自Being，Dog继承自Animal。另外，Dog也继承自Being。

Human.new
d = Dog.new
puts d.show_count

我们从Human和Dog类创建实例。我们在Dog对象上调用show_count方法。 Dog类没有这种方法。然后调用祖父级Being的方法。

$ ./inheritance2.rb
Being class created
Human is created
Being class created
Animal is created
Dog is created
There are 2 beings

Human对象调用两个构造器。 Dog对象调用三个构造器。有两个实例化的存在。

继承在方法和数据成员的可见性中不起作用。与许多常见的面向对象的编程语言相比，这是一个明显的区别。

在 C# 或 Java 中，公共和受保护的数据成员和方法是继承的。私有数据成员和方法不是。与此相反，私有数据成员和方法也在 Ruby 中继承。数据成员和方法的可见性不受 Ruby 中继承的影响。

#!/usr/bin/ruby

class Base

    def initialize
        @name = "Base"
    end

    private

     def private_method
         puts "private method called"
     end

    protected

     def protected_method
         puts "protected_method called"
     end

    public

     def get_name
         return @name
     end
end

class Derived < Base

    def public_method
        private_method
        protected_method
    end
end

d = Derived.new
d.public_method
puts d.get_name

在示例中，我们有两个类。 Derived类继承自Base类。它继承了所有三种方法和一个数据字段。

def public_method
    private_method
    protected_method
end

在Derived类的public_method中，我们调用一种私有方法和一种受保护方法。它们在父类中定义。

d = Derived.new
d.public_method
puts d.get_name

我们创建Derived类的实例。我们称为public_method，也称为get_name，它返回私有@name变量。请记住，所有实例变量在 Ruby 中都是私有的。无论@name是私有的还是在父类中定义的，get_name方法都会返回该变量。

$ ./inheritance3.rb
private method called
protected_method called
Base

该示例的输出确认，在 Ruby 语言中，子对象从其父级继承了public，protected，private方法和private成员字段。

Ruby `super`方法

super方法在父类的类中调用相同名称的方法。如果该方法没有参数，它将自动传递其所有参数。如果我们写super()，则不会将任何参数传递给父方法。

#!/usr/bin/ruby

class Base

    def show x=0, y=0
        p "Base class, x: #{x}, y: #{y}"
    end
end

class Derived < Base

    def show x, y
        super
        super x
        super x, y
        super()
    end
end

d = Derived.new
d.show 3, 3

在示例中，我们在层次结构中有两个类。它们都有显示方法。派生类中的show方法使用super方法调用基类中的show方法。

def show x, y
    super
    super x
    super x, y
    super()
end

不带任何参数的super方法使用传递给Derived类的show方法的参数调用父级的show方法：此处，x = 3和y = 3。 super()方法不将任何参数传递给父级的show方法。

$ ./super.rb
"Base class, x: 3, y: 3"
"Base class, x: 3, y: 0"
"Base class, x: 3, y: 3"
"Base class, x: 0, y: 0"

这是示例的输出。

这是 Ruby 中 OOP 描述的第一部分。

我们一直在努力

apachecn/AiLearning