Ruby中的private modifier与Java中的对比

先看一下Java的private modifier对于相同类型的不同对象是否有限制。

public class PrivateMethod {
    private StringBuilder sb;

    public PrivateMethod(String sb) {
        this.sb = new StringBuilder(sb);
    }

    private String getSB(){
        return sb.toString();
    }

    public String invokeOtherPrivateMethod(PrivateMethod other){
        return this.getSB() + other.getSB();
    }

    public static void main(String[] args) {
        final PrivateMethod a = new PrivateMethod("a ");
        final PrivateMethod b = new PrivateMethod("+ b");
        System.out.println(a.invokeOtherPrivateMethod(b));
    }
}

有Java基础的人都可以预料，JVM可以正常编译通过并且运行打印出：

a + b

然后，来看一下Ruby：

1. 首先定义一个基础类型 ModifierCheck

   class ModifierCheck
     private
     def private_check
       puts "我是一个私有方法#{__id__}"
     end
   
     public
     def public_check(other)
       puts "我是一个公有方法#{__id__}"
       other.protected_check
     end
   
     protected
     def protected_check
       puts "我是一个保护方法#{__id__}"
     end
   end

2. 然后定义一个子类并且执行

   class ModifierCheckSub < ModifierCheck
     def public_check
       private_check
       "==>你不是已经私有了么。。"
     end
   end
   
   modifier = ModifierCheckSub.new
   puts modifier.public_check

3. 最后执行结果

   我是一个私有方法70198988112100
   ==>你不是已经私有了么。。

4. 上面可以发现在子类中可以调用父类的私有方法，与Java完全不同。

   这里如果要问，为何Java的例子完全不写个子类来调用一下父类的private方法？这个还用说么，还没到运行时，直接编译器都过不了。

5. 接下来，来看一下在子类中是否可以override父类的私有方法，在子类中添加以下的部分：

   def private_check
     puts "我是覆盖私有方法的子方法"
   end

6. 执行结果：

   我是覆盖私有方法的子方法
   ==>你不是已经私有了么。。

7. 看，在子类中可以Override父类的私有方法。最后也许让我疑惑的私有在哪里，那么，来试一下最后这个。依然在子类中添加：

   def invokeOtherPrivateMethod(other)
     other.private_check
   end
   #而执行部分修改为：
   modifier = ModifierCheckSub.new
   modifier2 = ModifierCheck.new
   modifier.invokeOtherPrivateMethod modifier2

8. 这个时候执行直接报错：

   in `invokeOtherPrivateMethod': private method `private_check' called for #<ModifierCheck:0x007f8bc2a13df8> (NoMethodError)

9. 最终好像看出点什么，也许借鉴于Java与Ruby的静态/动态语言之分，

   private的访问级别：在Java中限制在同一个类中，而Ruby限制在同一个对象中。