进一步深入Ruby中的类与对象概念_ruby专题

Ruby是纯面向对象的语言，所有项目似乎要Ruby中为一个对象。Ruby中的每个值是一个对象，即使是最原始的东西：字符串，数字甚至true和false。即使是一个类本身是一个对象，它是Class类的一个实例。本章将通过所有功能涉及到Ruby的面向对象。

类是用来指定对象的形式，它结合了数据表示和方法操纵这些数据，转换成一个整齐的包。在一个类的数据和方法，被称为类的成员。
Ruby类的定义：

定义一个类，定义的数据类型的草图。 这实际上并不定义任何数据，但它定义的类名字的意思什么，即是什么类的对象将包括这样一个对象上执行什么操作可以。

类定义开始与关键字class类名和 end 分隔。例如，我们定义Box类使用class关键字如下：

class Box
   code
end

名称必须以大写字母开始，按照约定名称中包含多个单词，每个单词没有分隔符（驼峰式）一起执行。
定义Ruby的对象：

类为对象的蓝图，所以基本上是一个从一个类对象被创建。我们声明一个类的对象使用new关键字。下面的语句声明了两个对象，Box 类：

box1 = Box.new
box2 = Box.new

initialize方法：

initialize方法是一个标准的Ruby类的方法，和其它面向对象编程语言的构造方法有相同的方式工作。 initialize方法是有用的，在创建对象的时候，一些类变量初始化。这种方法可能需要的参数列表，它像其他Ruby之前的方法用def关键字定义，如下所示：

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

实例变量：

实例变量是类的一种属性，一旦我们使用的类对象被创建的对象的属性。每个对象的属性被分别赋值的并与其它对象共享，它们在类的内部使用@操作符访问，但访问类之外的，我们使用的公共方法被称为访问器方法。如果我们把上述定义的类 Box，然后 @width 和 @height 类 Box实例变量。

class Box
  def initialize(w,h)
   # assign instance avriables
   @width, @height = w, h
  end
end

访问器和setter方法：

为了外部能访问类的变量，它们必须定义存取器方法，这些存取器方法也被称为getter方法。下面的例子演示了如何使用访问器方法：

#!/usr/bin/ruby -w

# define a class
class Box
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end

  # accessor methods
  def printWidth
   @width
  end

  def printHeight
   @height
  end
end

# create an object
box = Box.new(10, 20)

# use accessor methods
x = box.printWidth()
y = box.printHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

当上面的代码执行时，它会产生以下结果：

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

类似的存取方法用于访问的变量值，Ruby提供了一种方法来从类的外部设置这些变量的值，那就是setter方法??，定义如下：

#!/usr/bin/ruby -w

# define a class
class Box
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end

  # accessor methods
  def getWidth
   @width
  end
  def getHeight
   @height
  end

  # setter methods
  def setWidth=(value)
   @width = value
  end
  def setHeight=(value)
   @height = value
  end
end

# create an object
box = Box.new(10, 20)

# use setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

当上面的代码执行时，它会产生以下结果：

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

实例方法：

也以同样的方式，因为我们使用def关键字定义其他方法，并按下图所示仅对使用一个类的实例，它们可以被用来定义该实例方法。它们的功能不局限于访问实例变量，他们也可以按要求做更多的事情。

#!/usr/bin/ruby -w

# define a class
class Box
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end
  # instance method
  def getArea
   @width * @height
  end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

当上面的代码执行时，它会产生以下结果：

Area of the box is : 200

类的方法和变量：

类变量是一个变量，这是一个类的所有实例之间共享。该变量是一个实例，它是可访问对象实例。两个@字符类变量带有前缀（@@）。在类定义类变量必须初始化，如下所示。

类方法的定义使用：def self.methodname() 以 end 字符结束，将被称为使用classname.methodname类名，在下面的例子所示：

#!/usr/bin/ruby -w

class Box
  # Initialize our class variables
  @@count = 0
  def initialize(w,h)
   # assign instance avriables
   @width, @height = w, h

   @@count += 1
  end

  def self.printCount()
   puts "Box count is : #@@count"
  end
end

# create two object
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)

# call class method to print box count
Box.printCount()

当上面的代码执行时，它会产生以下结果：

Box count is : 2

 to_s 方法:

所定义的任何类的实例应该有一个 to_s 方法返回一个字符串形式表示对象。下面以一个简单的例子来表示一个Box对象，在宽度和高度方面：

#!/usr/bin/ruby -w

class Box
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end
  # define to_s method
  def to_s
   "(w:#@width,h:#@height)" # string formatting of the object.
  end
end

# create an object
box = Box.new(10, 20)

# to_s method will be called in reference of string automatically.
puts "String representation of box is : #{box}"

当上面的代码执行时，它会产生以下结果：

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

访问控制：

Ruby提供了三个级别的保护实例方法的级别：public, private 和 protected。 Ruby没有应用实例和类变量的任何访问控制权。

  1.     Public Methods: 任何人都可以被称为public方法。方法默认为公用初始化，这始终是 private 除外。 .
  2.     Private Methods: private方法不能被访问，或者甚至从类的外部浏览。只有类方法可以访问私有成员。
  3.     Protected Methods: 受保护的方法可以被调用，只能通过定义类及其子类的对象。访问保存在类内部。

以下是一个简单的例子来说明三个访问修饰符的语法：

#!/usr/bin/ruby -w

# define a class
class Box
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end

  # instance method by default it is public
  def getArea
   getWidth() * getHeight
  end

  # define private accessor methods
  def getWidth
   @width
  end
  def getHeight
   @height
  end
  # make them private
  private :getWidth, :getHeight

  # instance method to print area
  def printArea
   @area = getWidth() * getHeight
   puts "Big box area is : #@area"
  end
  # make it protected
  protected :printArea
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

# try to call protected or methods
box.printArea()

当上面的代码被执行时，产生下面的结果。在这里，第一种方法被调用成功，但第二种方法给一个提示。

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

类的继承：

在面向对象的编程中最重要的概念之一是继承。继承允许我们定义一个类在另一个类的项目，这使得它更容易创建和维护应用程序。

继承也提供了一个机会，重用代码的功能和快速的实现时间，但不幸的是Ruby不支持多级的继承，但Ruby支持混入。一个mixin继承多重继承，只有接口部分像一个专门的实现。

当创建一个类，而不是写入新的数据成员和成员函数，程序员可以指定新的类继承现有类的成员。这种现有的类称为基类或父类和新类称为派生类或子类。

Ruby也支持继承。继承和下面的例子解释了这个概念。扩展类的语法很简单。只需添加一个<字符的超类声明的名称。例如，定义Box类的子类classBigBox：

#!/usr/bin/ruby -w

# define a class
class Box
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end
  # instance method
  def getArea
   @width * @height
  end
end

# define a subclass
class BigBox < Box

  # add a new instance method
  def printArea
   @area = @width * @height
   puts "Big box area is : #@area"
  end
end

# create an object
box = BigBox.new(10, 20)

# print the area
box.printArea()

当上面的代码执行时，它会产生以下结果：

Big box area is : 200

方法重载：

虽然可以在派生类中添加新的函数，但有时想改变的行为已经在父类中定义的方法。只需通过保持相同的方法名和重写该方法的功能，如下图所示，在这个例子可以这样做：

#!/usr/bin/ruby -w

# define a class
class Box
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end
  # instance method
  def getArea
   @width * @height
  end
end

# define a subclass
class BigBox < Box

  # change existing getArea method as follows
  def getArea
   @area = @width * @height
   puts "Big box area is : #@area"
  end
end

# create an object
box = BigBox.new(10, 20)

# print the area using overriden method.
box.getArea()

运算符重载：

我们想“+”运算符使用+，*操作由一个标量乘以一箱的宽度和高度，这里是一个版Box类的定义及数学运算符：

class Box
 def initialize(w,h) # Initialize the width and height
  @width,@height = w, h
 end

 def +(other)     # Define + to do vector addition
  Box.new(@width + other.width, @height + other.height)
 end

 def -@        # Define unary minus to negate width and height
  Box.new(-@width, -@height)
 end

 def *(scalar)    # To perform scalar multiplication
  Box.new(@width*scalar, @height*scalar)
 end
end

冻结对象：

有时候，我们要防止被改变的对象。冻结对象的方法可以让我们做到这一点，有效地把一个对象到一个恒定。任何对象都可以被冻结通过调用Object.freeze。不得修改冻结对象：不能改变它的实例变量。

可以使用Object.frozen？语句检查一个给定的对象是否已经被冻结，被冻结的情况下的对象语句方法返回true，否则返回false值。下面的示例 freeze 的概念：

#!/usr/bin/ruby -w

# define a class
class Box
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end

  # accessor methods
  def getWidth
   @width
  end
  def getHeight
   @height
  end

  # setter methods
  def setWidth=(value)
   @width = value
  end
  def setHeight=(value)
   @height = value
  end
end

# create an object
box = Box.new(10, 20)

# let us freez this object
box.freeze
if( box.frozen? )
  puts "Box object is frozen object"
else
  puts "Box object is normal object"
end

# now try using setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

当上面的代码执行时，它会产生以下结果：

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

类常量：

可以在类里定义分配一个直接的数字或字符串值，而不使用其定义一个变量为@@ 或 @。按照规范，我们保持常量名大写。

一个常量一旦被定义就不能改变它的值，但可以在类里像常量一样直接访问，但如果要访问一个类之外的常量，那么要使用类名::常量，所示在下面的例子。

#!/usr/bin/ruby -w

# define a class
class Box
  BOX_COMPANY = "TATA Inc"
  BOXWEIGHT = 10
  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end
  # instance method
  def getArea
   @width * @height
  end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

当上面的代码执行时，它会产生以下结果：

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

类常量继承和实例方法一样，可以覆盖。
创建对象使用分配：

当创建一个对象，而不调用它的构造函数初始化，即可能有一个情况：采用 new 方法，在这种情况下可以调用分配，这将创造一个未初始化的对象，看下面的例子：

#!/usr/bin/ruby -w

# define a class
class Box
  attr_accessor :width, :height

  # constructor method
  def initialize(w,h)
   @width, @height = w, h
  end

  # instance method
  def getArea
   @width * @height
  end
end

# create an object using new
box1 = Box.new(10, 20)

# create another object using allocate
box2 = Box.allocate

# call instance method using box1
a = box1.getArea()
puts "Area of the box is : #{a}"

# call instance method using box2
a = box2.getArea()
puts "Area of the box is : #{a}"

当上面的代码执行时，它会产生以下结果：

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

类信息：

如果类定义的可执行代码，这意味着他们在执行的上下文中一些对象：自身都必须引用的东西。让我们来看看它是什么。

#!/usr/bin/ruby -w

class Box
  # print class information
  puts "Type of self = #{self.type}"
  puts "Name of self = #{self.name}"
end

当上面的代码执行时，它会产生以下结果：

Type of self = Class
Name of self = Box

这意味着，一个类的定义，作为当前对象的类并执行。在元类和其超类的方法将在执行过程中使用的方法定义。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索ruby
深入浅出ruby、进一步深入、进一步深入基层、进一步深入学习、关护概念的进一步理解，以便于您获取更多的相关知识。

时间： 2024-09-20 16:49:22

进一步深入Ruby中的类与对象概念_ruby专题的相关文章

进一步深入Ruby中的类与对象概念

  这篇文章主要介绍了进一步深入Ruby中的类与对象概念,包括集成与多态等更多知识点的整理,需要的朋友可以参考下 Ruby是纯面向对象的语言,所有项目似乎要Ruby中为一个对象.Ruby中的每个值是一个对象,即使是最原始的东西:字符串,数字甚至true和false.即使是一个类本身是一个对象,它是Class类的一个实例.本章将通过所有功能涉及到Ruby的面向对象. 类是用来指定对象的形式,它结合了数据表示和方法操纵这些数据,转换成一个整齐的包.在一个类的数据和方法,被称为类的成员. Ruby类的

Ruby中使用正则表达式的基础指引_ruby专题

正则表达式的内建支持通常只限于脚本语言如Ruby,Perl和awk等,这是一个耻辱:尽管正则表达式很神秘,但它是一个强大的文本处理工具.通过内建而不是通过程序库接口来支持它,有很大的不同. 正则表达式只是一种指定字符模式的方法,这个字符模式会在字符串中进行匹配.在Ruby中,通常在斜线之间(/pattern/)编写模式(pattern)来创建正则表达式.同时,Ruby就是Ruby,正则表达式是对象并且可以当作对象来操作. 比如,可以使用如下的正则表达式来编写模式,它会匹配包含Perl或Pytho

Ruby中的Socket编程简单入门_ruby专题

 Ruby提供了两个访问级别的网络服务.在一个较低的水平,可以访问底层的操作系统,它可以实现面向连接和无连接协议的客户端和服务器支持基本的socket. Ruby也具有程序库,提供更高级别的访问特定的应用程序级的网络协议,如FTP,HTTP等. 这篇教程介绍 Ruby Socket编程概念及讲解一个简单的实例. 什么是Sockets? 套接字是一个双向通信信道的端点.socket能在一个进程,进程在同一台机器之间,或在不同的机器上的进程之间的进行通信. 套接字可实施过许多不同类型的通道:Unix

Ruby中操作文件的方法介绍_ruby专题

 Ruby提供了一套完整的I/O相关的内核模块中实现方法.所有I/O方法来自IO类. 类IO提供了所有的基本方法,如 read, write, gets, puts, readline, getc 和 printf. 本章将涵盖所有可供在Ruby中使用的基本I/O功能.如需使用更多的功能,请参考Ruby的IO类.puts 语句: 在前面的章节中,你指定值的变量和然后使用声明 puts 输出. puts 把语句指示程序显示存储在变量值.这将添加一个新行,每行末尾写出(输出). 例子: #!/usr

Ruby中对一元操作符重载实例_ruby专题

一元操作大家都知道,就是表达式的操作符只有一个输入值.这个在C和Java中都很常见.今天我们要探讨一下Ruby中的一元操作符重载. 一元操作符有:+ – * ! & 等,为了避免与数值的 + – 混淆,重载一元操作符,要在后面加上一个 @ 操作符. 1. 一个简单的一元操作符重载例子:-@ 操作符我们以String类为例子.String默认没有定义 – 操作符: 复制代码 代码如下: 1.9.3p125 :027 > a = "Hello" => "Hel

深入理解Ruby中的代码块block特性_ruby专题

block是什么? 在Ruby中,block并不罕见.官方对block的定义是"一段被包裹着的代码".当然,我觉得这样的解释不会让你变的更明白. 对block的一种更简单的描述是"一个block就是一段存储在一个变量中的代码,它和其他的对象一样,可以被随时的运行" 然后,咱们通过看一些代码,之后再把这些代码重构成Ruby中的block形式.通过代码来实际的感受,更加直观. 比如,对两个数做加法? puts 5 + 6 # => 11 嗯,这样写是可以的.但是,

Ruby中的Mechanize的使用教程_ruby专题

Ruby中实现网页抓取,一般用的是mechanize,使用非常简单. 安装 复制代码 代码如下: sudo gem install mechanize 抓取网页 复制代码 代码如下: require 'rubygems' require 'mechanize' agent = Mechanize.new page = agent.get('http://google.com/') 模拟点击事件 复制代码 代码如下: page = agent.page.link_with(:text => 'Ne

Ruby中的异常处理代码编写示例_ruby专题

单个异常使用 fail 关键字仅仅当捕获一个异常并且反复抛出这个异常(因为这里你不是失败,而是准确的并且故意抛出一个异常). begin fail 'Oops' rescue => error raise if error.message != 'Oops' end     不要为 fail/raise 指定准确的 RuntimeError.     # bad fail RuntimeError, 'message' # good - signals a RuntimeError by def

详解Ruby中的代码块及其参数传递_ruby专题

一,块的声明   块的声明在函数调用之后,用{..}括起来,或do..end封装.{}一般用在单行语句上,do..end用在多行语句上. (1..4).each{|v| print "#{v} "} #输出1 2 3 4   块可以带参数,与函数参数不同,块参数用||封装,当然,可以带多个参数.这些参数怎么定义,实际上是在函数内部定义好的,后面会讲到. 二,块内变量的访问   块内可以访问块外的变量,也就是块外的变量在块内是可见的,如 sum = 0 (1..5).each do |v