Ruby的面向对象编程的基础教程

2024-04-02 08:43:03 133

Ruby是纯面向对象的语言，Ruby中的一切都是以对象的形式出现。Ruby中的每个值都是一个对象，即使是最原始的东西：字符串、数字，甚至连true和false都是对象。类本身也是一个对象，是Class类的一个实例。本章将向您讲解所有与Ruby面向对象相关的主要功能。

类用于指定对象的形式，它结合了数据表示法和方法，把数据整理成一个整齐的包。类中的数据和方法被称为类的成员。
Ruby类定义

当您定义一个类时，您实际是定义了一个数据类型的蓝图。这实际上并没有定义任何的数据，而是定义了类的名称意味着什么，也就是说，定义了类的对象将由什么组成，以及在该对象上能执行什么操作。

类定义以关键字class开始，后跟类名称，最后以一个end进行分隔表示终止该类定义。例如，我们使用关键字class来定义Box类，如下所示：

classBox
code
end

按照惯例，名称必须以大写字母开头，如果包含多个单词，每个单词首字母大写，但此间没有分隔符（例如：CamelCase）。
定义Ruby对象

类提供了对象的蓝图，所以基本上，对象是根据类进行创建的。我们使用new关键字声明类的对象。下面的语句声明了类Box的两个对象：

box1=Box.new
box2=Box.new

initialize方法

initialize方法是一个标准的Ruby类方法，与其他面向对象编程语言中的constructor工作原理类似。当您想要在创建对象的同时初始化一些类变量，initialize方法就派上用场了。该方法带有一系列参数，与其他Ruby方法一样，使用该方法时，必须在前面放置def关键字，如下所示：

classBox
definitialize(w,h)
@width,@height=w,h
end
end

实例变量

实例变量是类属性，它们在使用类创建对象时就变成对象的属性。每个对象的属性是单独赋值的，和其他对象之间不共享值。在类的内部，是使用@运算符访问这些属性，在类的外部，则是使用称为访问器方法的公共方法进行访问。下面我们以上面定义的类Box为实例，把@width和@height作为类Box的实例变量。

classBox
definitialize(w,h)
#给实例变量赋值
@width,@height=w,h
end
end

访问器&设置器方法

为了在类的外部使用变量，我们必须在访问器方法内部定义这些变量，这些访问器方法也被称为获取器方法。下面的实例演示了访问器方法的用法：

#!/usr/bin/ruby-w

#定义类
classBox
#构造器方法
definitialize(w,h)
@width,@height=w,h
end

#访问器方法
defprintWidth
@width
end

defprintHeight
@height
end
end

#创建对象
box=Box.new(10,20)

#使用访问器方法
x=box.printWidth()
y=box.printHeight()

puts"Widthoftheboxis:#{x}"
puts"Heightoftheboxis:#{y}"

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

Widthoftheboxis:10
Heightoftheboxis:20

与用于访问变量值的访问器方法类似，Ruby提供了一种在类的外部设置变量值的方式，也就是所谓的设置器方法，定义如下：

#!/usr/bin/ruby-w

#定义类
classBox
#构造器方法
definitialize(w,h)
@width,@height=w,h
end

#访问器方法
defgetWidth
@width
end
defgetHeight
@height
end

#设置器方法
defsetWidth=(value)
@width=value
end
defsetHeight=(value)
@height=value
end
end

#创建对象
box=Box.new(10,20)

#使用设置器方法
box.setWidth=30
box.setHeight=50

#使用访问器方法
x=box.getWidth()
y=box.getHeight()

puts"Widthoftheboxis:#{x}"
puts"Heightoftheboxis:#{y}"

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

Widthoftheboxis:30
Heightoftheboxis:50

实例方法

实例方法的定义与其他方法的定义一样，都是使用def关键字，但它们只能通过类实例来使用，如下面实例所示。它们的功能不限于访问实例变量，也能按照您的需求做更多其他的任务。

#!/usr/bin/ruby-w

#定义类
classBox
#constructormethod
definitialize(w,h)
@width,@height=w,h
end
#实例方法
defgetArea
@width*@height
end
end

#创建对象
box=Box.new(10,20)

#调用实例方法
a=box.getArea()
puts"Areaoftheboxis:#{a}"

当上面的代码执行时，它会产生以下结果：
Areaoftheboxis:200
类方法&类变量

类变量是在类的所有实例中共享的变量。换句话说，类变量的实例可以被所有的对象实例访问。类变量以两个@字符（@@）作为前缀，类变量必须在类定义中被初始化，如下面实例所示。

类方法使用defself.methodname()定义，类方法以end分隔符结尾。类方法可使用带有类名称的classname.methodname形式调用，如下面实例所示：
#!/usr/bin/ruby-w

classBox
#初始化类变量
@@count=0
definitialize(w,h)
#给实例变量赋值
@width,@height=w,h

@@count+=1
end

defself.printCount()
puts"Boxcountis:#@@count"
end
end

#创建两个对象
box1=Box.new(10,20)
box2=Box.new(30,100)

#调用类方法来输出盒子计数
Box.printCount()

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

Boxcountis:2

to_s方法

您定义的任何类都有一个to_s实例方法来返回对象的字符串表示形式。下面是一个简单的实例，根据width和height表示Box对象：

#!/usr/bin/ruby-w

classBox
#构造器方法
definitialize(w,h)
@width,@height=w,h
end
#定义to_s方法
defto_s
"(w:#@width,h:#@height)"#对象的字符串格式
end
end

#创建对象
box=Box.new(10,20)

#自动调用to_s方法
puts"Stringrepresentationofboxis:#{box}"

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

Stringrepresentationofboxis:(w:10,h:20)

访问控制

Ruby为您提供了三个级别的实例方法保护，分别是public、private或protected。Ruby不在实例和类变量上应用任何访问控制。

Public方法：Public方法可被任意对象调用。默认情况下，方法都是public的，除了initialize方法总是private的。
Private方法：Private方法不能从类外部访问或查看。只有类方法可以访问私有成员。
Protected方法：Protected方法只能被类及其子类的对象调用。访问也只能在类及其子类内部进行。

下面是一个简单的实例，演示了这三种修饰符的语法：

#!/usr/bin/ruby-w

#定义类
classBox
#构造器方法
definitialize(w,h)
@width,@height=w,h
end

#实例方法默认是public的
defgetArea
getWidth()*getHeight
end

#定义private的访问器方法
defgetWidth
@width
end
defgetHeight
@height
end
#makethemprivate
private:getWidth,:getHeight

#用于输出面积的实例方法
defprintArea
@area=getWidth()*getHeight
puts"Bigboxareais:#@area"
end
#让实例方法是protected的
protected:printArea
end

#创建对象
box=Box.new(10,20)

#调用实例方法
a=box.getArea()
puts"Areaoftheboxis:#{a}"

#尝试调用protected的实例方法
box.printArea()

当上面的代码执行时，它会产生以下结果。在这里，第一种方法调用成功，但是第二方法会产生一个问题。

Areaoftheboxis:200
test.rb:42:protectedmethod`printArea'calledfor#
<Box:0xb7f11280@height=20,@width=10>(NoMethodError)

类的继承

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

继承有助于重用代码和快速执行，不幸的是，Ruby不支持多继承，但是Ruby支持mixins。mixin就像是多继承的一个特定实现，在多继承中，只有接口部分是可继承的。

当创建类时，程序员可以直接指定新类继承自某个已有类的成员，这样就不用从头编写新的数据成员和成员函数。这个已有类被称为基类或父类，新类被称为派生类或子类。

Ruby也提供了子类化的概念，子类化即继承，下面的实例解释了这个概念。扩展一个类的语法非常简单。只要添加一个<字符和父类的名称到类语句中即可。例如，下面定义了类BigBox是Box的子类：

#!/usr/bin/ruby-w

#定义类
classBox
#构造器方法
definitialize(w,h)
@width,@height=w,h
end
#实例方法
defgetArea
@width*@height
end
end

#定义子类
classBigBox<Box

#添加一个新的实例方法
defprintArea
@area=@width*@height
puts"Bigboxareais:#@area"
end
end

#创建对象
box=BigBox.new(10,20)

#输出面积
box.printArea()

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

Bigboxareais:200

方法重载

虽然您可以在派生类中添加新的功能，但有时您可能想要改变已经在父类中定义的方法的行为。这时您可以保持方法名称不变，重载方法的功能即可，如下面实例所示：

#!/usr/bin/ruby-w

#定义类
classBox
#构造器方法
definitialize(w,h)
@width,@height=w,h
end
#实例方法
defgetArea
@width*@height
end
end

#定义子类
classBigBox<Box

#改变已有的getArea方法
defgetArea
@area=@width*@height
puts"Bigboxareais:#@area"
end
end

#创建对象
box=BigBox.new(10,20)

#使用重载的方法输出面积
box.getArea()

运算符重载

我们希望使用+运算符执行两个Box对象的向量加法，使用*运算符来把Box的width和height相乘，使用一元运算符-对Box的width和height求反。下面是一个带有数学运算符定义的Box类版本：

classBox
definitialize(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

冻结对象

有时候，我们想要防止对象被改变。在Object中，freeze方法可实现这点，它能有效地把一个对象变成一个常量。任何对象都可以通过调用Object.freeze进行冻结。冻结对象不能被修改，也就是说，您不能改变它的实例变量。

您可以使用Object.frozen?方法检查一个给定的对象是否已经被冻结。如果对象已被冻结，该方法将返回true，否则返回一个false值。下面的实例解释了这个概念：

#!/usr/bin/ruby-w

#定义类
classBox
#构造器方法
definitialize(w,h)
@width,@height=w,h
end

#访问器方法
defgetWidth
@width
end
defgetHeight
@height
end

#设置器方法
defsetWidth=(value)
@width=value
end
defsetHeight=(value)
@height=value
end
end

#创建对象
box=Box.new(10,20)

#让我们冻结该对象
box.freeze
if(box.frozen?)
puts"Boxobjectisfrozenobject"
else
puts"Boxobjectisnormalobject"
end

#现在尝试使用设置器方法
box.setWidth=30
box.setHeight=50

#使用访问器方法
x=box.getWidth()
y=box.getHeight()

puts"Widthoftheboxis:#{x}"
puts"Heightoftheboxis:#{y}"

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

Boxobjectisfrozenobject
test.rb:20:in`setWidth=':can'tmodifyfrozenobject(TypeError)
fromtest.rb:39

类常量

您可以在类的内部定义一个常量，通过把一个直接的数值或字符串值赋给一个变量来定义的，常量的定义不需要使用@或@@。按照惯例，常量的名称使用大写。

一旦常量被定义，您就不能改变它的值，您可以在类的内部直接访问常量，就像是访问变量一样，但是如果您想要在类的外部访问常量，那么您必须使用classname::constant，如下面实例所示。

#!/usr/bin/ruby-w

#定义类
classBox
BOX_COMPANY="TATAInc"
BOXWEIGHT=10
#构造器方法
definitialize(w,h)
@width,@height=w,h
end
#实例方法
defgetArea
@width*@height
end
end

#创建对象
box=Box.new(10,20)

#调用实例方法
a=box.getArea()
puts"Areaoftheboxis:#{a}"
putsBox::BOX_COMPANY
puts"Boxweightis:#{Box::BOXWEIGHT}"

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

Areaoftheboxis:200
TATAInc
Boxweightis:10

类常量可被继承，也可像实例方法一样被重载。
使用allocate创建对象

可能有一种情况，您想要在不调用对象构造器initialize的情况下创建对象，即，使用new方法创建对象，在这种情况下，您可以调用allocate来创建一个未初始化的对象，如下面实例所示：

#!/usr/bin/ruby-w

#定义类
classBox
attr_accessor:width,:height

#构造器方法
definitialize(w,h)
@width,@height=w,h
end

#实例方法
defgetArea
@width*@height
end
end

#使用new创建对象
box1=Box.new(10,20)

#使用allocate创建两一个对象
box2=Box.allocate

#使用box1调用实例方法
a=box1.getArea()
puts"Areaoftheboxis:#{a}"

#使用box2调用实例方法
a=box2.getArea()
puts"Areaoftheboxis:#{a}"

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

Areaoftheboxis:200
test.rb:14:warning:instancevariable@widthnotinitialized
test.rb:14:warning:instancevariable@heightnotinitialized
test.rb:14:in`getArea':undefinedmethod`*'
fornil:NilClass(NoMethodError)fromtest.rb:29

类信息

如果类定义是可执行代码，这意味着，它们可在某个对象的上下文中执行，self必须引用一些东西。让我们来看看下面的实例：.

#!/usr/bin/ruby-w

classBox
#输出类信息
puts"Typeofself=#{self.type}"
puts"Nameofself=#{self.name}"
end

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

Typeofself=Class
Nameofself=Box

这意味着类定义可通过把该类作为当前对象来执行，同时也意味着元类和父类中的该方法在方法定义执行期间是可用的。

Ruby的面向对象编程的基础教程

热门推荐

随机推荐