Private
private 函数只好 在本类和子类的 上下文中调用,且不得不通过self访问。

Ruby是纯面向对象的言语,全部体系仿佛要Ruby中为贰个对象。Ruby中的每一个值是二个指标,就算是最原始的东西:字符串,数字照旧true和false。纵然是二个类自身是三个目的,它是Class类的多个实例。本章将经过具备功效涉及到Ruby的面向对象。

开创类:
class后跟类名,在那之中类名的首字母须要求大写。实例化时,通过new方法实例化。在c#中有构造器,构造器与类同名。在ruby中,构造器为initialize方法。当通过new方法实例化一个类对象后,会活动调用initialize方法,把new中的参数字传送递给initialize方法实行初步化。在c#中的域,在ruby中称之为实例变量,定义时前面加@前缀,表示是贰个实例变量。

Ruby基础知识等等,Ruby基础知识

制造类:
class后跟类名,当中类名的首字母绝对要大写。实例化时,通过new方法实例化。在c#中有构造器,构造器与类同名。在ruby中,构造器为initialize方法。当通过new方法实例化三个类对象后,会自行调用initialize方法,把new中的参数字传送递给initialize方法开始展览初阶化。在c#中的域,在ruby中称之为实例变量,定义时前边加@前缀,表示是一个实例变量。
复制代码 代码如下:
class Customer
    def initialize(name,age)
      @name,@age=name,age
    end
end
 
c1=Customer.new(“Tom”,20)

访问器

实例变量只可以通超过实际例方法来拜会。如若要拜候它们能够提供格局访谈器。在c#中称为属性,Java中也是定义方法来代表属性。
复制代码 代码如下:
class Customer
    def initialize(name,age)
      @name,@age=name,age
    end
    
    def name
      @name
    end
    def age
      @age
    end
end

如上定义了五个方法x,y,它们得以读@x,@y实例变量。那就定义了读属性方法。借使要举办赋值操作,还要定义写属性方法:
复制代码 代码如下:
    def name=(v)
      @name=v
    end
    def age=(v)
      @age=v
    end

要留心的是:
复制代码 代码如下:
c1=Customer.new(“Tom”,20)
c1.name=”Jhon”

除非在实例中能力这么使用写属性。借使在类中,不可能经过name=value那样来顶替@name=value。但足以经过self来那样使用:self.name=value
Ruby提供了简化定义属性方法:attr_reader和attr_accessor。后面跟符号,会自行创立同名的读写属性。
复制代码 代码如下:
class Customer
    def initialize(name,age)
      @name,@age=name,age
    end 
 
    attr_reader :name,:age
    attr_accessor:name,:age
end
c1=Customer.new(“Tom”,20)
puts c1.name,c1.age
c1.name=”Jhon”
c1.age=30
puts c1.name,c1.age

类变量,常量,类方法 类变量以@@起先;常量通过[类名+::常量名]进展拜见;类形式在实例方法方式名前加类名。在定义类方法时,能够使用一种方法:
复制代码 代码如下:
class<<self
       def 方法
       end
end

那正是说,那些措施便是一个类情势:
复制代码 代码如下:
class Customer
    def initialize(name,age)
      @name,@age=name,age
    end
    class <<self
      def showName
        ‘ok’
      end
    end
end
 
puts Customer.showName

格局的访谈性 public:公有的,暗中认可情形下类中的方法是国有的,能够用在其余地点。构造方法initialize为个人的。
private:私有的,类内部使用的,只好被类或子类的实例方法所调用。只好通过self隐式调用,无法通过二个对象出示调用。二个私有方法m,只好通过m调用,而不能够经过o.m或self.m调用。
protected:受保险的,类内部或子类内部使用的办法。与私家的界别是:除self隐式调用外,还足以通过此类对象出示调用。
能够透过以下格局来声称方法的访谈性:
复制代码 代码如下:
#访问性 private protected public
Ruby基础知识等等,Ruby基础知识。  private
  def private_method
    puts “private method testing”
  end
  protected
  def protected_method
    puts “protected method testing”
  end
  
  public:protected_method

厂子方法 行使new方法私有,然后经过类格局创造实例
复制代码 代码如下:
class Fruit
  private_class_method:new
  def Fruit.CreateFruit
    new Fruit
  end
end
f=Fruit.CreateFruit

模块module

module功用之一是做为名字空间用。调用类时与调用常量同样:五个冒号
另一作用是当做混入。通过include把模块中的实例方法包蕴到任何类中。认为效用像C#中的名字空间引进。

创建类:
class后跟类名,个中类名的首字母必供给大写。实例化时,通过new方法实例化。在c#中有构造器,…

本条意思正是:private函数,只好在本对象内部访谈到。

类是用来钦定对象的花样,它结合了数据表示和方法垄断这几个多少,调换到叁个齐整的包。在贰个类的数目和章程,被称为类的积极分子。

复制代码 代码如下:

目的实例变量(@)的探望权限就是 private。

Ruby类的概念:

class Customer
    def initialize(name,age)
      @name,@age=name,age
    end
end
 
c1=Customer.new(“Tom”,20)

复制代码 代码如下:

概念多少个类,定义的数据类型的草图。
那其实并不定义任何数据,但它定义的类名字的意思什么,正是什么类的靶子将席卷那样五个对象上施行如何操作可以。

访问器

class AccessTest
def test
return “test private”
end
def test_other(other)
“other object ”+ other.test
end
end
t1 = AccessTest.new
t2 = AccessTest.new

类定义开头与根本字class类名和 end
分隔。比方,我们定义Box类使用class关键字如下:

实例变量只好通超过实际例方法来做客。假诺要走访它们得以提供方式采访器。在c#中称为属性,Java中也是定义方法来代表属性。

p t1.test # => test private

复制代码 代码如下:

复制代码 代码如下:

p t1.test_other(t2) # => other object test private

class Box
   code
end

class Customer
    def initialize(name,age)
      @name,@age=name,age
    end
    
    def name
      @name
    end
    def age
      @age
    end
end

# Now make ‘test’ private

名称必须以大写字母起先,依照预定名称中包蕴多个单词,每一种单词未有分隔符(驼峰式)一齐施行。

如上定义了多少个方法x,y,它们能够读@x,@y实例变量。那就定义了读属性方法。即使要举办赋值操作,还要定义写属性方法:

class AccessTest
private :test
end

定义Ruby的对象:

复制代码 代码如下:

p t1.test_other(t2) #错误 in `test_other’: private method `test’
called for #<AccessTest:0x292c14> (NoMethodError)

类为目的的蓝图,所以基本上是贰个从二个类对象被创建。我们声惠氏(Beingmate)个类的靶子使用new关键字。下边包车型大巴话语表明了多个对象,Box类:

    def name=(v)
      @name=v
    end
    def age=(v)
      @age=v
    end

Protected
protect 函数只可以 在本类和子类的 上下文中调用,但能够利用
other_object.function的款式。(那跟 C++ 的 private 情势等同)

复制代码 代码如下:

要小心的是:

那么些的基本点是 protected函数能够在同类(含子类)的别样对象的中间中央银行使。

box1 = Box.new
box2 = Box.new

复制代码 代码如下:

# Now make ‘test’ protect

initialize方法:

c1=Customer.new(“Tom”,20)
c1.name=”Jhon”

class AccessTest
protected:test
end

initialize方法是三个专门的学问的Ruby类的章程,和任何面向对象编制程序语言的构造方法有一致的措实行事。
initialize方法是卓有功效的,在创设对象的时候,一些类变量开端化。这种办法或许要求的参数列表,它像任何Ruby在此之前的形式用def关键字定义,如下所示:

唯有在实例中才具如此使用写属性。若是在类中,不可能透过name=value那样来替代@name=value。但足以由此self来那样使用:self.name=value
Ruby提供了简化定义属性方法:attr_reader和attr_accessor。后面跟符号,会自动创立同名的读写属性。

p t1.test_other(t2) # other object test private

复制代码 代码如下:

复制代码 代码如下:

Public
public 函数能够在其他地点调用。成员函数和常量的暗中认可访问权限就是public。

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

class Customer
    def initialize(name,age)
      @name,@age=name,age
    end 
 
    attr_reader :name,:age
    attr_accessor:name,:age
end
c1=Customer.new(“Tom”,20)
puts c1.name,c1.age
c1.name=”Jhon”
c1.age=30
puts c1.name,c1.age

您恐怕感兴趣的稿子:

  • Ruby中的public、private、protected差别小结
  • 容易谈谈Ruby的private和protected

实例变量:

类变量,常量,类方法 类变量以@@起始;常量通过[类名+::常量名]开始展览寻访;类形式在实例方法措施名前加类名。在定义类方法时,能够运用一种办法:

实例变量是类的一种属性,一旦大家采取的类对象被成立的目的的习性。各类对象的习性被分级赋值的并与别的对象共享,它们在类的里边使用@操作符访谈,但访问类之外的,大家应用的集体艺术被堪称访谈器方法。即使大家把上述定义的类
博克斯,然后 @width 和 @height 类 Box实例变量。

复制代码 代码如下:

复制代码 代码如下:

class<<self
       def 方法
       end
end

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

那么,这几个方法就是叁个类格局:

访谈器和setter方法​​:

复制代码 代码如下:

为了外界能访谈类的变量,它们必须定义存取器方法,那几个存取器方法也被堪当getter方法。下面包车型客车例子演示了怎么着行使访问器方法:

class Customer
    def initialize(name,age)
      @name,@age=name,age
    end
    class <<self
      def showName
        ‘ok’
      end
    end
end
 
puts Customer.showName

复制代码 代码如下:

方法的访谈性 public:公有的,私下认可景况下类中的方法是公有的,能够用在别的地方。构造方法initialize为个人的。
private:私有的,类内部选用的,只可以被类或子类的实例方法所调用。只可以通过self隐式调用,无法经过贰个目的出示调用。多少个私有方法m,只好通过m调用,而不可能透过o.m或self.m调用。
protected:受有限补助的,类内部或子类内部采纳的不二诀要。与个人的区分是:除self隐式调用外,仍是能够经过此类对象出示调用。
能够通过以下方法来声称方法的访谈性:

#!/usr/bin/ruby -w

复制代码 代码如下:

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

#访问性 private protected public
  private
  def private_method
    puts “private method testing”
  end
  protected
  def protected_method
    puts “protected method testing”
  end
  
  public:protected_method

   # accessor methods
   def printWidth
      @width
   end

工厂方法 利用new方法私有,然后经过类情势创制实例

   def printHeight
      @height
   end
end

复制代码 代码如下:

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

class Fruit
  private_class_method:new
  def Fruit.CreateFruit
    new Fruit
  end
end
f=Fruit.CreateFruit

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

模块module

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

module成效之一是做为名字空间用。调用类时与调用常量相同:八个冒号
另一效应是用作混入。通过include把模块中的实例方法包蕴到别的类中。感到效果像C#中的名字空间引进。

当上面包车型客车代码推行时,它会产生以下结果:

您大概感兴趣的稿子:

  • 选取Ruby on
    Rails和PostgreSQL自动生成UUID的教程
  • 粗略介绍Ruby on
    Rails对PostgreSQL数组类型的辅助
  • 详解Ruby个中的算数运算

复制代码 代码如下:

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未有采纳实例和类变量的别的访谈调节权。

Public Methods:
任哪个人都得以被喻为public方法。方法默以为公用初叶化,这一贯是 private
除此而外。 .

Private Methods:
private方法无法被访谈,或然以至从类的外表浏览。只有类格局可以访谈私有成员。

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()

当上面的代码被实践时,产生上面包车型客车结果。在此地,第一种办法被调用成功,但第三种艺术给一个晋升。

复制代码 代码如下:

金沙注册送58,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的面向对象编制程序的基础教程
  • ruby 面向对象思维 概念
  • ruby 学习笔记(2)
    类的大旨使用
  • ruby 类常量 解析
  • Ruby
    中$起头的全局变量、内部变量、遮盖变量介绍
  • ruby 局地变量
  • 浅析 ruby 全局变量
  • ruby 变量
  • 简单来说解读Ruby面向对象编制程序中的功能域

相关文章

网站地图xml地图