POSTS

第十三章、ruby中的面向对象编程2

February 13, 2019

Ruby的面向对象编程2

在这章的教程我们继续讨论Ruby的面向对象编程。

我们以属性修饰符开始。将会包涵类常量、类方法和操作符重载。我们将定义多态，并展示在Ruby中如何使用它。我们也会提及模块和异常。

属性修饰符

Ruby的所有变量都是私有的。它只能通过方法来访问。这些方法通常称为设值函数(setters)和获得者(getters)。创建一个setter和getter方法是很平常的事情。加些Ruby有便利的方法来创建这两种方法。它们是attr_reader、attr_writer和attr_accessor。

attr_reader用于创建getter方法。attr_writer用于setter方法。attr_accessor用于创建两种方法。

#!/usr/bin/ruby

class Car
    
    attr_reader :name, :price
    attr_writer :name, :price  
    
    def to_s
        "#{@name}: #{@price}"
    end

end


c1 = Car.new
c2 = Car.new

c1.name = "Porsche"
c1.price = 23500

c2.name = "Volkswagen"
c2.price = 9500

puts "The #{c1.name} costs #{c1.price}"

p c1
p c2

定义了一个Car类，在类内部我们使用了attr_reader和attr_writer创建了两个getter和setter方法。

attr_reader :name, :price

这里我们创建了两个实例方法名为：name和price。注意attr_reader将方法名符号作为参数。

attr_writer :name, :price

attr_writer创建了两个setter方法name、price和两个实例变量@name、 @price。

c1.name = "Porsche"
c1.price = 23500

这里的上下文中调用了两个setter方法，为实例变量填充数据。

puts "The #{c1.name} costs #{c1.price}"

这里调用了两个getter方法获取数据。

$ ./arw.rb
The Porsche costs 23500
Porsche: 23500
Volkswagen: 9500

例子的输出结果。

正如上面阐述的，attr_accessor方法会创建getter、setter方法和它们的实例变量。

#!/usr/bin/ruby

class Book
   attr_accessor :title, :pages    
end

b1 = Book.new
b1.title = "Hidden motives"
b1.pages = 255

p "The book #{b1.title} has #{b1.pages} pages"

定义了一个Book类，它使用attr_accessor创建了两对方法和两个实例变量。

class Book
   attr_accessor :title, :pages    
end

attr_accessor方法设置了title、pages 方法以及@title、@pages实例变量。

b1 = Book.new
b1.title = "Hidden motives"
b1.pages = 255

创建了一个Book对象。调用两个setter方法为对象的实例变量填充数据。

p "The book #{b1.title} has #{b1.pages} pages"

这行的代码我们调用getter方法读取实例变量的值。

$ ./accessor.rb
"The book Hidden motives has 255 pages"

例子的输出结果。

类的常量

Ruby允许创建类常量。这些常量不属于特定的对象，它们是属于类的。作为约定，常量以大写字母开头。

#!/usr/bin/ruby

class MMath

    PI = 3.141592
end


puts MMath::PI

创建一个MMath类，包含了一个PI常量。

PI = 3.141592

我们创建了一个PI常量。记住在Ruby中常量不是强制的。

puts MMath::PI

使用::操作符访问PI常量。

$ ./classconstant.rb
3.141592

例子输出结果。

to_s方法

每个对象都有一个to_s方法，它返回该对象的一个字符串描述。注意puts方法将一个对象作为参数时，该对象的to_s方法将被调用。

#!/usr/bin/ruby

class Being

    def to_s
        "This is Being class"
    end
end

b = Being.new
puts b.to_s
puts b

定义一个Being类并重载了to_s方法。

def to_s
    "This is Being class"
end

每个创建的类都继承自基类Object。to_s方法属于这个类。我们重载了to_s方法，使得描述信息更加可读。

b = Being.new
puts b.to_s
puts b

创建一个Being的对象，调用两次to_s方法。第一次是显式调用，第二次是隐式调用。

$ ./tostring.rb
This is Being class
This is Being class

例子的运行结果。

操作符重载

操作符重载是基本参数的不同进行的操作也不同。

Ruby中操作符和方法仅有一点区别。

#!/usr/bin/ruby

class Circle
   
    attr_accessor :radius
    
    def initialize r
        @radius = r
    end

    def +(other)
        Circle.new @radius + other.radius
    end
    
    def to_s
        "Circle with radius: #{@radius}"
    end
end


c1 = Circle.new 5
c2 = Circle.new 6
c3 = c1 + c2

p c3

这个例子中，我们创建了一个Circle类，并重载了+操作符，用于将两个circle对象相加。

def +(other)
    Circle.new @radius + other.radius
end

我们定义了一个名为+的方法，这个方法将两个circle对象的半径相加。

c1 = Circle.new 5
c2 = Circle.new 6
c3 = c1 + c2

创建两个circle对象。在第三行我们将这两个对象相加生成一个新的对象。

$ ./operatoroverloading.rb
Circle with radius: 11

这两个对象相加生成的第三个对象半径为11。

类方法

Ruby方法分为类方法和实例方法。类方法只能被类调用，不能被实例调用。

类方法不能访问实例变量。

#!/usr/bin/ruby

class Circle
    
    def initialize x
        @r = x
    end
   
    def self.info
       "This is a Circle class" 
    end
    
    def area
        @r * @r * 3.141592
    end

end


p Circle.info
c = Circle.new 3
p c.area

上面的例子展示了一个Circle类。除了构造函数之外，还有一个类方法和一个实例方法。

def self.info
    "This is a Circle class" 
end

以self关键字开头的是类方法。

def area
    "Circle, radius: #{@r}"
end

实例方法不以self关键字开头。

p Circle.info

调用类方法。注意我们是通过类来调用这个方法。

c = Circle.new 3
p c.area

为了调用实例方法我们必须得先创建一个对象。实例方法总是被对象调用。这里c变量保存了该对象，我们利用点操作符调用area方法。

$ ./classmethods.rb
"This is a Circle class"
28.274328

例子的输出描述了Ruby的类方法。

在Ruby中有三种方式创建类方法。

#!/usr/bin/ruby

class Wood
     
    def self.info
       "This is a Wood class" 
    end
end

class Brick
     
    class << self
        def info
           "This is a Brick class" 
        end
    end
end

class Rock
     
end

def Rock.info
   "This is a Rock class" 
end


p Wood.info
p Brick.info
p Rock.info

这个例子创建了三个类，每个都有一个类方法。

def self.info
    "This is a Wood class" 
end

类方法可以以self关键字开头。

class << self
    def info
        "This is a Brick class" 
    end
end

另一个方式是将方法定义放在class << self结构之后。

def Rock.info
   "This is a Rock class" 
end

这是第三种定义类方法的方式。

$ ./classmethods2.rb
"This is a Wood class"
"This is a Brick class"
"This is a Rock class"

调用Wood、Brick和Rock这三个类的类方法的输出结果。

创建实例方法的三种方式

Ruby有三种基本的方式创建实例方法。实例方法是属于实例对象的。它们是通过对象使用点操作符调用。

#!/usr/bin/ruby

class Wood
     
    def info
       "This is a wood object"        
    end
end

wood = Wood.new
p wood.info

class Brick
     
    attr_accessor :info
end

brick = Brick.new
brick.info = "This is a brick object"
p brick.info

class Rock
     
end

rock = Rock.new

def rock.info
    "This is a rock object"
end

p rock.info

这个例子我们创建了三个实例对象Wood、Brick和Rock。每个对象都有一个实例方法。

class Wood
     
    def info
       "This is a wood object"        
    end
end

wood = Wood.new
p wood.info

这可能是最常用的一种方式。info方法定义在Wood类的内部。稍后创建一个对象并调用它的info方法。

class Brick
     
    attr_accessor :info
end

brick = Brick.new
brick.info = "This is a brick object"
p brick.info

另一种创建实例方法的方式是使用属性修饰符。这是一种方便的方式可以减少程序员的按键输入。attr_accessor创建两个方法getter和setter，同样也创建一个实例变量用于存储数据。创建一个brick对象，数据使用setter方法保存在@info变量中。最后使用getter方法读取消息。

class Rock
     
end

rock = Rock.new

def rock.info
    "This is a rock object"
end

p rock.info

第三种方法我们创建了一个空的Rock类。稍后实例化一个对象，动态的为这个对外创建一个方法。

$ ./threeways.rb
"This is a wood object"
"This is a brick object"
"This is a rock object"

例子的输出结果。

多态性

多态是使用一个操作符或者函数对不同的数据进行不同的处理。实践中多态意味着如果类B继承自类A，它没有必要将类A的所有都继承；它可以做一些与类A不同的事情。

注意静态语言如C++、Java、或者C#和动态语言如Python、Ruby的多态有些不同。在静态语言中编译器决定了方法的定义。在动态语言中我们专注了同名方法的不同操作。

#!/usr/bin/ruby

class Animal
    
    def make_noise 
        "Some noise"
    end

    def sleep 
        puts "#{self.class.name} is sleeping." 
    end
  
end

class Dog < Animal
    
    def make_noise 
        'Woof!'         
    end 
    
end

class Cat < Animal 
    
    def make_noise 
        'Meow!' 
    end 
end

[Animal.new, Dog.new, Cat.new].each do |animal|
  puts animal.make_noise
  animal.sleep
end

我们创建了一个简单的继承结构。有一个Animal基类和两个后代Cat和Dog。这三个类都有它自己的make_noise方法实现。后代的实现方法会替换掉Animal类的。

class Dog < Animal
    
    def make_noise 
        'Woof!'         
    end 
    
end

Dog类的make_noise实现替换掉了Animal类的实现。

[Animal.new, Dog.new, Cat.new].each do |animal|
  puts animal.make_noise
  animal.sleep
end

为每个类的创建了一个实例对象，并对该对象调用了make_noise方法和sleep方法。

$ ./polymorhism.rb
Some noise
Animal is sleeping.
Woof!
Dog is sleeping.
Meow!
Cat is sleeping.

polymorhism.rb脚本的输出结果。

模块

一个Ruby模块是方法、类和常量的集合。模块与类相似也有些不同。模块不能创建实例，没有子类。

模块用于将相关的类、方法和常量聚集单独放在一个模块中。这样也避免了命名的冲突，因为模块将它包含的对象进行了封装。从这方面来看Ruby的模块与C#的命名空间和Java的包相似。

在Ruby中模块也支持混合类（mixins）。混入类（mixin）是一个创建多继承的工厂。如果一个类继承自多个类，则称为多继承。

#!/usr/bin/ruby

puts Math::PI
puts Math.sin 2

Ruby有一个内建的Math模块。它有许多方法和常量。我们使用::操作符访问PI常量。与类相同使用点操作符访问方法。

#!/usr/bin/ruby

include Math

puts PI
puts sin 2

如果包含了一个模块，我们就可以直接引用Math的对象了。模块导入使用include关键字。

$ ./modules.rb
3.141592653589793
0.9092974268256817

程序的输出结果。

下面的例子我们展示了如何使用模块来组织代码。

#!/usr/bin/ruby

module Forest
 
    class Rock ; end
    class Tree ; end
    class Animal ; end    
    
end

module Town
    
   class Pool ; end
   class Cinema ; end
   class Square ; end
   class Animal ; end
        
end


p Forest::Tree.new
p Forest::Rock.new
p Town::Cinema.new

p Forest::Animal.new
p Town::Animal.new

Ruby代码可以主义分组。Rocks和Tree属于Forest。Pools、Cinema、Squares属于Town。使用模块让我们的代码更加有条理。Animals可以在Forest里也可以有Town里。对于一个脚本我们不能定义两个Animal类，它们会冲突。将它们放在不同的模块即可解决这个问题。

p Forest::Tree.new
p Forest::Rock.new
p Town::Cinema.new

创建属于Forest和Town的对象。我们使用::操作符访问模块里的对象。

p Forest::Animal.new
p Town::Animal.new

创建两个Animal对象。Ruby解释器会将它们标识为它们的模块名。

$ ./modules3.rb
#<Forest::Tree:0x97f35ec>
#<Forest::Rock:0x97f35b0>
#<Town::Cinema:0x97f3588>
#<Forest::Animal:0x97f3560>
#<Town::Animal:0x97f3538>

modules3.rb程序的输出。

这节的最后一个例子我们将展示使用模块进行多继承。在这里的上下文中模块称为混合类（mixins）。

#!/usr/bin/ruby

module Device
    def switch_on ; puts "on" end    
    def switch_off ; puts "off" end
end

module Volume
    def volume_up ; puts "volume up" end    
    def vodule_down ; puts "volume down" end
end

module Pluggable
    def plug_in ; puts "plug in" end    
    def plug_out ; puts "plug out" end
end

class CellPhone
    include Device, Volume, Pluggable
   
    def ring
        puts "ringing"
    end    
end

cph = CellPhone.new
cph.switch_on
cph.volume_up
cph.ring

我们定义了三个模块和一个类。模块代表了一些功能。一个设备可以调节开头。许多对象都可以分享这个功能，包含电视、手机、电脑和冰箱。相对于为每个对象创建这个功能，我们是将它分隔在一个模块里，它可以被每个对象包含。这样代码将更加有条理更紧凑。

module Volume
    def volume_up ; puts "volume up" end    
    def vodule_down ; puts "volume down" end
end

Volume模块组织了负责控制音量等级的方法。如果一个设备需要这些方法，它只需要简单的在自己的类中包含这个模块即可。

class CellPhone
    include Device, Volume, Pluggable
   
    def ring
        puts "ringing"
    end    
end

CellPhone添加了这三个模块。这些模块的方法混合在CellPhone类中。对于这个类的实例对象同样有效。CellPhone类也有一个自己的ring方法。

cph = CellPhone.new
cph.switch_on
cph.volume_up
cph.ring

创建了一个CellPhone对象并调用了三个方法。

$ ./mixins.rb
on
volume up
ringing

例子的运行结果。

异常

异常是对象偏离了正常的程序执行流的信号。异常出现、抛出或者开始。

在应用程序执行期间，许多事情可能引起错误。磁盘满了我们不能保存文件。网络断了但应用程序试图连接某个网站。所有的这些可能引起应用程序崩溃。为了避免这个的发生，我们应当在程序异常时预先处理错误。对于这个我们可以使用异常处理。

异常是对象，它们是内建Exception类的后代。Exception对象携带了关于异常的信息。它的类型（异常的类名），可选的描述字符串，和一个可选的跟踪信息。为了获取关于程序运行异常的额外信息，程序可以子类化Exception或者更多是StandardError。

#!/usr/bin/ruby
x = 35
y = 0

begin
    z = x / y
    puts z
rescue => e
    puts e
    p e
end

上面的程序我们故意的除以0,这个导致一个错误。

begin
    z = x / y
    puts z

出错的语句位置begin关键字之后。

rescue => e
    puts e
    p e
end

rescue关键字之后的代码我们处理一个异常。这里我们在终端上打印错误信息。e是一个异常对象，在错误发生时创建的。

$ ./zerodivision.rb
divided by 0
#<ZeroDivisionError: divided by 0>

输出结果我们看到了异常信息。最后一行显示了异常对象名为ZeroDivisionError。

程序员可以使用raise关键字发起自己的异常。

#!/usr/bin/ruby

age = 17

begin
    if age < 18
        raise "Person is a minor"
    end
    
    puts "Entry allowed"
rescue => e
    puts e
    p e
    exit 1
end

俱乐部不允许不满18岁的青年进入。我们使用Ruby脚本模拟这个情况。

begin
    if age < 18
        raise "Person is a minor"
    end
    
    puts "Entry allowed"

如果是未成年人，将出现一个异常。如果raise关键字没有指明异常参数，则RuntimeError异常将引发。这个代码不会到达puts “Entry allowed”这行。代码执行中断并继续rescue的代码块。

rescue => e
    puts e
    p e
    exit 1
end

在rescue代码块中我们打印错误信息，RuntimeError对象的一个字符串描述。我们也调用了exit方法通知环境该脚本错误退出。

$ ./raise_exception.rb 
Person is a minor
#<RuntimeError: Person is a minor>
$ echo $?
1

未成年人不允许进行俱乐部。bash的$?变量设置了这个脚本错误退出。

Ruby的ensure从名创建的代码块总是会被执行，不管是否有异常。

#!/usr/bin/ruby

begin
    f = File.open("stones", "r")
    
    while line = f.gets do
        puts line
    end    
    
rescue => e
    puts e
    p e
ensure
    f.close if f
end

这个例子我们尝试打开并读取stones文件。I/O操作容易出现错误。

ensure
    f.close if f
end

在ensure的代码块中我们关闭文件处理对象。我们查检处理对象是否存在，因为它可能没有被创建。分配的资源通常位于ensure代码块里。

如果想到，我们可以创建自定义的异常。Ruby中自定义异常继承自StandardError类。

#!/usr/bin/ruby

class BigValueError < StandardError ; end

LIMIT = 333
x = 3_432_453
    
begin
    
    if x > LIMIT
        raise BigValueError, "Exceeded the maximum value"
    end
        
    puts "Script continues"
    
rescue => e
    puts e
    p e
    exit 1
end

我们有一个情况不能处理大的数字。

class BigValueError < StandardError ; end

我们定义一个BigValueError类。这个类继承自StandardError类。

LIMIT = 333

数字超过这个常量就被认为是大的。

if x > LIMIT
    raise BigValueError, "Exceeded the maximum value"
end

如果值比LIMIT大，则抛出一个自定义异常。异常信息为”Exceeded the maximum value”。

$ ./custom_exception.rb
Exceeded the maximum value
#<BigValueError: Exceeded the maximum value>

执行程序。

在这一章我们完成了Ruby语言的面向对象编程。zetcode原文地址

ruby