分享 Ruby 的面向对象编程

Mind · 发布于 2017年11月10日 · 最后由 rocLv 回复于 2017年11月12日 · 697 次阅读
8fff4c

1.面向对象编程:

1.0 为何要有面向对象编程:

很早之前程序员就发现,随着软件的日趋复杂与庞大,维护往往变成了一个很棘手的问题.因为贯穿整个程序的依赖(dependencies),在一个程序中一个很小的改变就可能引起如同涟漪般扩散的偏差(errors).

而面向对象编程正是为了解决这个问题而诞生的.

1.1 何为面向对象编程:

面向对象编程(Object oriented programming)是一种基于对象的编程范型.在面向对象编程语言中,一切均是对象.

1.2 对象(object)的定义:

对象是指一个具体的事物.它有具体的行为(behaviors),有具体的属性(states).有时可以对应现实世界的事物,例如小狗聪聪,猫咪毛毛等.

1.3 类(class)的定义:

定义:

类相当于一副蓝图,定义了一类事物的抽象特点. 例如,"狗"这个类会包含狗的一切基础特征,即所有“狗”都共有的特征或行为,例如它的孕育、毛皮颜色和吠叫的能力。

作用:

这样创建一类具有相同行为与共通的属性的对象时,先创建一个这样的一个类,再用这个类去定义具体的对象,就可以少写很多代码.

1.4 面向对象编程的三大支柱:

  • 封装性(Encapsulation)

限定只有特定的类的对象才能调用特定类的方法,并且隐藏了方法的具体执行步骤.

示例:

/* 一个面向过程的程序会这样写: */
定义莱丝
莱丝.设置音调(5)
莱丝.吸气()
莱丝.吐气()

/* 而当狗的吠叫被封装到类中,任何人都可以简单地使用: */
定义莱丝是狗
莱丝.吠叫()
  • 继承(inheritance)

在某些情况下一个类会有子类,子类比父类更加具体.例如,“狗”这个类可能会有它的子类"牧羊犬"和"吉娃娃".子类会继承父类的属性和行为,并且包含它自己的.假设"狗"这个类有一个方法(行为)叫做“吠叫()”和一个属性叫做“毛皮颜色”。它的子类(前例中的牧羊犬和吉娃娃犬)会继承这些成员。

例如:

类牧羊犬:继承狗

定义莱丝是牧羊犬
莱丝.吠叫()    /* 注意这里调用的是狗这个类的吠叫方法。*/
  • 多态(Polymorphism)

多态(Polymorphism)是一个专业术语,意指"许多形态"("many shapes").更具体来说是同一种操作被用不同方式执行.

例如,狗和鸡都有“叫()”这一方法,但是调用狗的“叫()”,狗会吠叫;调用鸡的“叫()”,鸡则会啼叫。 我们将它体现在伪代码上:

类狗
开始
   公有成员:
       叫()
       开始
          吠叫()
       结束
结束

类鸡
开始
   公有成员:
       叫()
       开始
          啼叫()
       结束
结束

定义莱丝是狗
定义鲁斯特是鸡
莱丝.叫()
鲁斯特.叫()

这样同样做出叫这个动作,莱丝与鲁斯特的实际行为会大相径庭.

2. 关于对象(object)

2.1 initialize object:

语法:

Classname.new

示例:

  • 不带参数:
--- initialize class called GoodDog ---
class GoodDog 

end 

--- initialize object ----
sparky=GoodDog.new
  • 带参数:
--- initialize class called GoodDog ---
class GoodDog 
    def initialize(name,color)
        @name = name
        @color = color
    end 
end 

--- initialize object ----

sparky=GoodDog.new("sparky","white")

2.2 instance variable

2.2.1 作用:

记录对象的属性(keep track of states of object)

2.2.2 定义语法:

  • 以"@"符号开头
  • 后面跟着表示对象属性的单词,并且使用小写字母

示例:

class GoodDog 
    def initialize(name,color)
        @name = name
        @color = color
    end 
end 

sparky = GoodDog.new("sparky","white")

2.2.3 instance variable的存取:

2.2.3.1 如何进行存取:

背景问题1:

如何输出@name的值

以上面代码为例,虽然有了instance variable,但是如果我们想要 输出 sparky 的name,那么应该怎么办?

sparky.name # => NoMethodError: undefined method `name' for #<GoodDog:0x007f91821239d0
  @name="Sparky">

上面的错误提示告诉我们我们没有定义一个叫做name 的method,也就是说我们需要定义一个方法来存放@name的值,来方便我们输出.

这似乎是说"object."后面只能跟method,而不能跟variable

解决方案:

class GoodDog 
    def initialize(name,color)
        @name = name
        @color = color
    end 

--- add getter_method ---   

    def get_name
        @name
    end
end 

sparky = GoodDog.new("sparky","white")

这样我们就可以输出sparky的名字了:

puts sparky.get_name # => sparky

背景问题2:

现在已经有了getter method,

但如何改变name的值?

解决方案:

class GoodDog 
    def initialize(name,color)
        @name = name
        @color = color
    end 

--- add getter_method ---   

    def get_name
        @name
    end

--- add setter_method ---

    def set_name=(name)
        @name = name 
    end
end 

sparky = GoodDog.new("sparky","white")

现在运行下面的代码:

sparky.set_name = "spartacus"
puts sparky.get_name    #=> spartacus

就会发现name的值改变了.

2.2.3.2 对上述代码进行重构:
  • 重构的原因:

Rubyist习惯使用相同的名称来命名instance variable的getter method 和setter method .

  • 重构后的代码:

统一使用name来命名getter method 和setter method.

class GoodDog
  def initialize(name)
    @name = name
  end

  def name                      # This was renamed from "get_name"
    @name
  end

  def name=(n)                  # This was renamed from "set_name="
    @name = n
  end
end

sparky = GoodDog.new("Sparky")
puts sparky.speak
puts sparky.name            # => "sparky"
sparky.name = "Spartacus"
puts sparky.name            # => "Spartacus"
2.2.3.3 对上述代码进行再次重构(attr_*):
  • 重构的原因:

上述代码占用的空间太多了,只有一个instance variable还好,若是有多个呢?例如height / weight.这样就太麻烦了.

  • 解决方案:

Ruby内置了一套方案来解决上述问题.

attr_accessor method 可以自动的帮助我们产生和上面一样的getter / setter metods.

class GoodDog
    attr_accessor :name         # using attr_accessor method 

    def initialize(name)
      @name = name
    end

end

  sparky = GoodDog.new("Sparky")
  puts sparky.speak
  puts sparky.name            # => "Sparky"
  sparky.name = "Spartacus"
  puts sparky.name            # => "Spartacus"

这样写就会简洁/方便很多.

  • 含有多个instance variable的写法:
attr_accessor :name, :height, :weight
2.2.3.4 其他两种attr_* method:
  • 只想要getter method,而不需要setter method :

attr_reader

  • 只想要setter method ,而不想要 getter method:

attr_writer

2.2.4 在class内部使用getter / setter method:

2.2.4.1在class内部使用getter method 替换 instance variable:
  • 原因:

如果我们有一个social_security_numbers(用@ssn表示),我们并不想展示所有的数字,只想展示后四位,那么可以这样写:

"****-****-" + @ssn.split("-").last

如果我们需要多次使用到这行代码,与其多次重复写入,不如写一个method将这行代码封装起来.

另外原本的getter mehod 不能让别人直接调用,所以不如直接使用getter method 来封装这行代码:

def ssn
    "****-****-" + @ssn.split("-").last    
end     
  • 示例:
class Account

  def initialize(name,ssn)
      @name = name
      @ssn =ssn
  end 

  def ssn
      "****-****-" + @ssn.split("-").last    
    end   

  def ssn_hint
      "Your ssn is #{ssn}"        #  using ssn instead of @ssn
  end

end   
2.2.4.2在class内部使用setter method:
  • 原因:

如实在GoodDog class中有多个instance variable,而我们定义一个方法(change_info)用来同时改变着多变量的值:

def change_info(n,h,w)
    @name = n
    @height = h 
    @weight = w
end 

为了与上面的在class内部使用getter method保持一致(consistence),从而使用setter_method来进行替换.

  • 失败的尝试:

根据上面的思路我们对change_info这个method进行了修改.

class GoodDog
    attr_accessor :name, :height, :weight

    def initialize(n, h, w)
      @name = n
      @height = h
      @weight = w
    end

    def speak
      "#{name} says arf!"
    end

    def change_info(n, h, w)        # try using setter method
      name = n
      height = h
      weight = w
    end

    def info
      "#{name} weighs #{weight} and is #{height} tall."
     end

但是当我们进行检测时,却发现变量的值并没有改变.

sparky = GoodDog.new('Sparky', '12 inches', '10 lbs')

puts sparky.info      # => Sparky weighs 10 lbs and is 12 inches tall.

sparky.change_info('Spartacus', '24 inches', '45 lbs')

puts sparky.info      # => Spartacus weighs 45 lbs and is 24 inches tall.
  • 失败的原因:

在上述代码中Ruby误以为我们是想创建新的变量,分别叫name/height/weight了.

所以就会发现@name等变量并没有改变.

  • 使用self method进行修正:
def change_info(n, h, w)        # using self method
  self.name = n
  self.height = h
  self.weight = w
end
  • 为了保持一致,统一将调用getter method 的地方加上self.
def info
    "#{self.name} weighs #{self.weight} and is #{self.height} tall."
end
  • 最终结果是形成一个惯例(convention):
  • class 内,用到instance variable的地方使用getter method ;
  • class内,除setter method以外,需要改变instance variable值的地方统一使用setter method;
  • 在class内使用到getter / setter method 的地方都使用self method

3.关于类(class)

3.1 class variable:

3.1.1 作用:

不知道怎么描述,所以通过下面的代码进行感受.

3.1.2 定义方法:

  • 语法:
  • 使用"@@"作为开头;
  • 紧跟着是能够描述想要记录属性的小写的英文单词.
  • 示例:
class GoodDog
  @@number_of_dogs = 0

  def initialize
    @@number_of_dogs += 1
  end

end

3.2 类方法(class method):

3.2.1 作用:
3.2.2 定义方法:
  • 语法:
  • 使用self method;
  • 用小写单词命名.
  • 示例:
class GoodDog
  @@number_of_dogs = 0

  def initialize
    @@number_of_dogs += 1
  end

  def self.total_number_of_dogs
    @@number_of_dogs
  end 
end

puts GoodDog.total_number_of_dogs   # => 0
dog1 = GoodDog.new
dog2 = GoodDog.new
puts GoodDog.total_number_of_dogs   # => 2

3.3 常量(constants):

其实和class并没有什么关系.

3.3.1 为什么要有常量:

有时候我们无论如何都不想要定义的量的值改变,这时就使用常量.

3.3.2 常量的定义方法:
  • 语法:
  • 使用首字母大写的英语单词;
  • Rubyist习惯上将常量的所有字母都大写.
  • 示例:
class GoodDog
    DOG_YEARS = 7                   # constants

    attr_accessor :name, :age

    def initialize(n, a)
      self.name = n
      self.age  = a * DOG_YEARS
    end 
end

sparky = GoodDog.new("Sparky", 4)
puts sparky.age

3.4 The to_s method:

这部分其实和class也没有什么关系.

3.4.1 自动调用to_s method的两种情况 :
  • puts method 自动调用to_method.

示例:

---这里输出的结果是:前面是sparky这个对象对应的class(GoodDog),紧跟的一串数字/字母是这个是这个对象的ID编码---

puts sparky      # => #<GoodDog:0x007fe542323320>

puts sparky 等价于puts sparky.to_s

  • 字符串插值(string interpolation)自动调用to_s method:

    • 字符串插值(string interpolation)就是将常量或者变量插入字符串中.

示例:

irb :001 > arr = [1, 2, 3]
  => [1, 2, 3]
  irb :002 > x = 5
  => 5
  irb :003 > "The #{arr} array doesn't include #{x}."
  => The [1, 2, 3] array doesn't include 5.

在这里字符串插值自动的调用to_s method,然后将arr 和 x 两个变量转换成了对应的值,然后与字符串结合在了一起.

3.4.2 了解to_s method的自动调用的益处:

虽然当前感觉了解to_s method是无关紧要的,但这却会在日后帮助我们更好的读写oo code.

3.5 进一步了解self method

上面有两处使用了self method:

  • 告诉Ruby我们想要调用的是setter method,而不是创建新的变量;
  • 使用self method帮助定义class method.

那么self究竟是什么?

3.5.1 self指代object:

代码示例

class GoodDog
    # ... rest of code omitted for brevity
    def what_is_self
      self
end end
sparky = GoodDog.new('Sparky', '12 inches', '10 lbs')
  p sparky.what_is_self
   # => #<GoodDog:0x007f83ac062b38 @name="Sparky", @height="12 inches",
  @weight="10 lbs">

通过上述代码我们可以发现self指代的是object(sparky)

3.5.2 self指代class:

代码示例:

class GoodDog
    # ... rest of code omitted for brevity
    puts self
end
irb :001 > GoodDog
  => GoodDog

通过上面我们得出self指代的是GoodDog这个class.

3.5.3 如何判断self指代什么:
  1. self,insideofaninstancemethod,referencestheinstance(object)thatcalledthemethod - the calling object. Therefore, self.weight= is the same as sparky.weight= ,in our example.
  2. self,outsideofaninstancemethod,referencestheclassandcanbeusedtodefineclass methods. Therefore, def self.name=(n) is the same as def GoodDog.name=(n) ,in our example.

4. 继承(inheritance)

4.0 继承的对象:

继承的东西是superclass中的behavior.

4.1 继承的作用:

通过继承能够实现代码复用,从而达到以下好处:

  • 除去写重复代码的麻烦;
  • 方便debug.

4.1 继承的两种方式:

  • class inheritance
  • mixing in module

4.2 class inheritance:

4.2.1 语法:

使用 <符号去标记继承方向.

示例:

class Animal
  def speak
    "Hello!" 
  end
end

class GoodDog < Animal          # 标记GoodDog从Animal继承behavior
end

class Cat < Animal
end

sparky = GoodDog.new
paws = Cat.new
puts sparky.speak           # => Hello!
puts paws.speak             # => Hello!

4.2.2 继承behavior的overring

当subclass中有与superclass中想相同的method时,subclass的object调用的就是subclass中的method.

示例:

class Animal
    def speak
        "Hello!"
    end
end

class GoodDog < Animal

    attr_accessor :name

    def initialize(n)
      self.name = n
    end

    def speak
      "#{self.name} says arf!"
    end 
end

class Cat < Animal
end

sparky = GoodDog.new("Sparky")
paws = Cat.new
puts sparky.speak           # => Sparky says arf!
puts paws.speak             # => Hello!

4.3 super

4.3.1 作用

在subclass中调用superclass中与instance method同名method.

示例:

class Animal
    def speak
        "Hello!" 
    end
end

class GoodDog < Animal
    def speak
      super + " from GoodDog class"
    end
end

sparky = GoodDog.new
sparky.speak             # => "Hello! from GoodDog class"
4.3.2调用super的三种状况:
  1. 不含参数:
class Animal
    def speak
        "Hello!" 
    end
end

class GoodDog < Animal
    def speak
      super + " from GoodDog class"
    end
end

sparky = GoodDog.new
sparky.speak             # => "Hello! from GoodDog class"
  1. 含参数,但是不指定:
class Animal
    attr_accessor :name

    def initialize(name)
       @name = name
    end 
end

class GoodDog < Animal
    def initialize(color)
      super
      @color = color
    end
end

---这里因为使用了super 所以初始化object的时候调用了Animal中的initialze method,从而导致bruno多了一个属性--name ---

bruno = GoodDog.new("brown")        # => #<GoodDog:0x007fb40b1e6718,@color="brown", @name="brown">
  1. 指定参数:
class BadDog < Animal
    def initialize(age, name)
        super(name)
        @age = age 
    end
end

BadDog.new(2, "bear")           # => #<BadDog:0x007fb40b2beb68 @age=2,@name="bear">

4.4 Mixing in module

4.4.1 为什么要有mixing in module:

[图片上传失败...(image-614c12-1510277893483)]

已上图为例,如实Cat 与Dog有相同的behavior,这个时候我们就可以将它提取出来,放在Mammal中,通过继承来使用.

那么问题来了,Dog与Fish也有相同的behavior—swim,这个时候显然不能将对应的method提取出来放到Mammal或者是Animal中(因为Cat不可以swim).解决方案就是使用Mixing in module .

4.4.2 mixing in module的思路

就是将两个或者多个无法通过继承来dry up 的code 封装到一个容器中,然后让这些class调用这个容器中的内容.

具体来说是这样.将Fish与Dog都有的behavior(swim)用Swimmable这个module进行封装,然后让Fish与Dog进行调用.

4.4.3 mixing in module 的定义:

示例:

module Swimmable
    def swim
        "I'm swim."
    end 
end 

解释:

  • 使用首字母大写的单词;
  • rubyist 习惯上将单词以able作为后缀.
4.4.4 mixing in module 的使用:
module Swimmable
  def swim
    "I'm swimming!"
  end
end

class Animal; end

class Fish < Animal
  include Swimmable     # mixing in Swimmable module
end

class Mammal < Animal
end

class Cat < Mammal
end

class Dog < Mammal
  include Swimmable     # mixing in Swimmable module
end

语法:

include modulename

5.其他:

5.1 Method lookup path:

5.1.1 定义:

object在调用方法(method)时,是按照一定顺序进行的,这个顺序就叫method loopup path.

5.1.2 知道method lookup path的作用:

当我们研究一个较大的项目时,可能会困惑于那些方法是哪来的.但是若是知道了method lookup path,便能够较好的理解那些方法是在哪儿,以及是如何组织的.

5.1.3 使用ancestors查询method lookup path:

以下述代码为例,如何才能知道Animal的object的method loopup path呢?

module Walkable
    def walk
      "I'm walking."
    end
end

module Swimmable
    def swim
      "I'm swimming."
    end
end

module Climbable
    def climb
      "I'm climbing."
    end
end

class Animal
    include Walkable

    def speak
      "I'm an animal, and I speak!"
    end 
end

使用ancestors method :

puts "---Animal method lookup---"
  puts Animal.ancestors

结果:

--- Animal method lookup ---
Animal
Walkable
Object
Kernel
BasicObject

5.1.4 method lookup path:

顺序:

  • 在初始化对象的类中查找
  • 在该对象的module中查找(按照mixing进的module的顺序,进行倒序查找)
  • 在该类的父类中查找

示例:

module Walkable
    def walk
      "I'm walking."
    end
end

module Swimmable
    def swim
      "I'm swimming."
    end
end

module Climbable
    def climb
      "I'm climbing."
    end
end

class Animal
    include Walkable

    def speak
      "I'm an animal, and I speak!"
    end 
end

class GoodDog < Animal
    include Swimmable
    include Climbable
end

puts "---GoodDog method lookup---"
puts GoodDog.ancestors

输出结果:

---GoodDog method lookup path ---
GoodDog
Climbable
Swimmable
Animal
Walkable
Object
Kernel
BasicObject

5.2 module的另外两种用法:

1.用于namespacing;

2.作为container of methods

5.2.1 用于namespacing:

作用:

  • 将同类型的class归类放在一起;
  • 区分具有相同名字的class

定义方法:

module Mammal
    class Dog
      def speak(sound)
        p "#{sound}"
      end 
    end

    class Cat
      def say_name(name)
        p "#{name}"
      end
    end 
end

如何使用module中的class初始化对象:

buddy = Mammal::Dog.new
kitty = Mammal::Cat.new
buddy.speak('Arf!')           # => "Arf!"
kitty.say_name('kitty')       # => "kitty"
5.2.2 作为container of methods (module methods)

定义方法:

module Mammal
    ...
    def self.some_out_of_place_method(num)
      num ** 2
    end 
end

调用方法:

  • 法一:
value = Mammal.some_out_of_place_method(4)
  • 法二:
value = Mammal::some_out_of_place_method(4)

5.3 私有/公共/保护方法(private/public/protected):

5.3.1 私有方法(private method)

作用:

有时候我们只想让某个方法在class内部发生作用,而不再外部被调用,这个时候就使用private method.

定义方法:

使用保留字:private

class GoodDog
  DOG_YEARS = 7

   attr_accessor :name, :age

   def initialize(n, a)
      self.name = n
      self.age = a
    end

    private             # method following "private is pirvate method

    def human_years
      age * DOG_YEARS
    end 
end

sparky = GoodDog.new("Sparky", 4)
sparky.human_years

说明:

私有方法(private method)只能在instance method中被调用,且是直接调用不能用self method.

即使是objectname.privatemethod的形式也不行.

5.3.2 保护方法(protected method)

作用:

有时候我们想要在instance method中使用self.privatemethod或者objectname.privatemethod,的形式,但是有不想外界调用,这是就使用protected method.

语法:

使用保留字:protected

class Animal

    def a_public_method
      "Will this work? " + self.a_protected_method
    end

    protected

    def a_protected_method
      "Yes, I'm protected!"
    end 
end

class Student
      def initialize(name, grade)
        @name = name
        @grade = grade
      end

      def better_grade_than?(other_student)
        grade > other_student.grade
      end

      protected

      def grade
        @grade
      end 
end

joe = Student.new("Joe", 90)
bob = Student.new("Bob", 84)
puts "Well done!" if joe.better_grade_than?(bob)

5.4 偶发的方法重写(accidental method overrding)

5.4.1 产生原因:

因为所有自己创建的类都继承自class Object,这就导致当有些method与Object中的method同名时,发生method overring.

示例:

例如:Object的send method可以调用某个方法,但是若被重写了,就会出问题.

class Child
    def say_hi
      p "Hi from Child."
    end

    def send
      p "send from Child..."
    end 
end

lad = Child.new
lad.send :say_hi

报错:

ArgumentError: wrong number of arguments (1 for 0)
from (pry):12:in `send'
5.4.2 启示:

要熟知一些常见的Object methods,避免发生重写(overrding),否则会对应用造成灾难性的后果.

参考资料:

共收到 4 条回复
A72675

帖子的分类是新手问题,那么问题在哪里呢?还是说只是意外地选错了分类?

8fff4c
A726755long 回复

我想放在多个节点里的,结果只能放在最后选的节点里...

3楼 已删除
60

今天刚好看了 A Sarah Mei - "Is Your Code Too SOLID?", 提到了 为什么重构, 重构什么, 怎么重构, 什么时候重构等问题, 值得看看

3a5cee

修改了个拼写,竟然一下不小心删除,还好回退了一下,还有本地缓存

面向对象最主要的就是开闭原则

对于扩展是开放的,对于修改是关闭的

另外就是类要遵循 单一负责原则(SRP)

其他的一些如依赖倒转原则、里氏代换原则、接口隔离原则、合成/聚合复用原则,多了解一下有利于写出真正面向对象的代码。

最近看了一些设计模式方面的书,包括 Rails Anti-Pattern,发现所谓重构的技巧,都不外乎在遵循额这些基本的原则。

Rails的问题在于大家发现应用其他设计模式会比较难,所以整个Rails大项目结构的变迁从Fat controller到Fat Model,Skinny Controller,然后再到Skinny Model,Skinny Controller,每一次Rails社区对架构的演进都是一次对设计模式一次内省和应用。

无论是Fat Controller,还是Fat Model无疑都违反了SRP,仔细看看Fat Model里面的代码,很容易发现它们或多或少并不遵从REST或者其他面向对象的设计模式。

需要 登录 后方可回复, 如果你还没有账号请点击这里 注册