标签: access-specifier

class Example
 private
 def example_test
  puts 'Hello'
 end
end

e = Example.new
e.example_test

这当然是行不通的,因为我们指定了Example(e)的显式接收器 - 实例,这是针对"私有规则"的.

但我无法理解,为什么人们不能在Ruby中做到这一点:

class Foo
 def public_m
  self.private_m # <=
 end
 private
 def private_m
  puts 'Hello'
 end
end

Foo.new.public_m

public_m方法定义(即self)中的当前对象是Foo的实例.那么为什么不允许呢？为了解决这个问题,我必须self.private_m改为公正private_m.但为什么这个不同,是不是selfFoo里面的一个例子public_m？谁是裸字private_m呼叫的接收者？不是self- 实际上你省略了什么,因为Ruby会为你做这件事(会在self上调用private_m)吗？

我希望我没有太多混淆,我对Ruby仍然很新鲜.

编辑:谢谢你的所有答案.把它们放在一起我能(最终)神交明显的(而不是一个人,谁从来没有见过的东西,比如Ruby那么明显):这self本身可以是显性和隐性的接收器,并且赚取差价.因此,有两条规则,如果你要调用一个私有方法:self必须是隐式接收器,以及自我必须是当前类的一个实例(Example在这种情况下-而且,只有当自己好像里面实例方法的定义,在此期间发生方法执行).如果我错了,请纠正我.

class Example 

 # self as an explicit receiver (will throw an error)
 def explicit 
  self.some_private_method
 end

 # self as an …

给定一个带有几个实例变量和一些方法的类.一些实例变量可通过attr_reader和设置访问attr_accessor.因此其他人是私人的.
某些私有实例变量在其中一个实例方法中设置,并在另一个方法中读取/使用.

为了测试我正在使用RSpec.由于我还是Ruby的新手,并且想要把所有事情都搞定,我将我的测试定义得相当精细.因此,我describe为每个实例方法都有一个块,它们本身被划分为contexts和its 的子集.一般环境先决条件定义为before.

但是,当测试其中一个方法,即使用但未设置其中一个私有变量时,我需要调用另一个方法,即设置此变量.这似乎相当超重,对我来说不是模块化的.

有没有办法强制私有实例变量到某个值.类似于" 剥离 "私有实例变量的值Object::instance_eval(:var).

在Java中,访问说明符和访问修饰符是一样的吗？

在Ruby中,如何创建私有类常量？(即在课堂内可见但不在课堂外可见的)

class Person
  SECRET='xxx' # How to make class private??

  def show_secret
    puts "Secret: #{SECRET}"
  end
end

Person.new.show_secret
puts Person::SECRET # I'd like this to fail

我正在学习Ruby,并且已经达到了令我感到困惑的程度.

我使用的这本书是在谈论private,public和protected methods,但我还是有点困惑.每个之间有什么区别？

如果在包含类之外仍然无法访问Java中私有内部类公共成员的原因是什么？或者可以吗？

public class DataStructure {
    // ...

    private class InnerEvenIterator {
        // ...

        public boolean hasNext() { // Why public?
            // ...
        }
    }
}

它说,在Java教程"定义接口"中

如果未指定接口public,则只能在与接口相同的包中定义的类上访问您的接口.

但是,这个

interface PPInterface {
    void foo();
    void bar();
}

class NewClass implements PPInterface {
    void foo() {}
    void bar() {}
}

生成编译器错误NewClass因为我'试图分配较弱的访问权限; 是公开的.所以文档是错误的,或者我做错了什么,或者我误解了文档？

我想我不必使用界面 - 我喜欢它,因为它保持了良好的组织.

我有一个构造函数尝试初始化基类中的字段.编译器抱怨.该字段受到保护,因此派生类应具有访问权限.

//The base class: 

class BaseClass

{

public:

    BaseClass(std::string);
    BaseClass(const BaseClass& orig);
    virtual ~BaseClass();
    const std::string GetData() const;
    void SetData(const std::string& data);
protected:

    BaseClass();
    std::string m_data;

};

BaseClass::BaseClass(const std::string data) : m_data(data) { }

BaseClass::BaseClass() { } 

BaseClass::BaseClass(const BaseClass& orig) { }

BaseClass::~BaseClass() { }

void BaseClass::SetData(const std::string& data)
{
    m_data = data;
}

const std::string BaseClass::GetData() const
{
    return m_data;
}


//The derived class: 


class DerivedClass : public BaseClass
{

public:

    DerivedClass(std::string data);
    DerivedClass(const DerivedClass& orig);
    virtual ~DerivedClass();
private: …

我们都知道,如果我们没有专门定义构造函数,编译器会插入一个不可见的零参数构造函数.我认为它的访问修饰符是公开的,但在处理内部类问题时,我发现也许我错了.这是我的代码:

public class Outer {
  protected class ProtectedInner {
    // adding a public constructor will solve the error in SubOuterInAnotherPackage class
    //public ProtectedInner() {}
  }
}

并且Outer在另一个包中有一个子类:

public class SubOuterInAnotherPackage extends Outer {
  public static void main(String[] args) {
    SubOuterInAnotherPackage.ProtectedInner protectedInner 
      = new SubOuterInAnotherPackage().new ProtectedInner(); // Error!! Can't access the default constructor
  }
}

您将在main()方法中收到错误,但如果向ProtectedInner类中添加公共构造函数,则会解决该错误.这就是为什么我认为默认构造函数的修饰符不公开!那么有谁能告诉我默认构造函数的访问修饰符是什么？

我知道界面必须是公开的.但是,我不希望这样.

我希望我的实现方法只能从他们自己的包中访问,所以我希望我的实现方法受到保护.

问题是我无法使接口或实现的方法受到保护.

什么是解决方法？是否存在与此问题相关的设计模式？

从Java指南中,抽象类也不能完成这项工作.