Java中“私有静态最终"和“公共静态最终"类变量的最接近的Ruby表示?

本文介绍了Java中“私有静态最终"和“公共静态最终"类变量的最接近的Ruby表示?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

给定下面的 Java 代码，您在 Ruby 类中最接近的表示这两个 static final 变量是什么?而且，在 Ruby 中是否可以像在 Java 中那样区分 private static 和 public static 变量?

Given the Java code below, what's the closest you could represent these two static final variables in a Ruby class? And, is it possible in Ruby to distinguish between private static and public static variables as there is in Java?

public class DeviceController
{
  ...
  private static final Device myPrivateDevice = Device.getDevice("mydevice");
  public static final Device myPublicDevice = Device.getDevice("mydevice");
  ...
  public static void main(String args[])
  {
   ...
  }
}

推荐答案

Ruby 中确实没有等效的构造.

There really is no equivalent construct in Ruby.

但是，您似乎正在犯典型的移植错误之一:您在语言 A 中有一个解决方案，然后尝试将其翻译成语言 B，而此时您真正应该做的是弄清楚问题，然后找出如何用语言 B 解决它.

However, it looks like you are making one of the classic porting mistakes: you have a solution in language A and try to translate that into language B, when what you really should do is figure out the problem and then figure out how to solve it in language B.

我不能确定你想从那个小代码片段中解决什么问题，但这里有一个关于如何在 Ruby 中实现它的可能想法:

I can't really be sure what the problem is you are trying to solve from that small codesnippet, but here is one possible idea for how to implement it in Ruby:

class DeviceController
  class << self
    def my_public_device;  @my_public_device  ||= Device['mydevice'] end

    private

    def my_private_device; @my_private_device ||= Device['mydevice'] end
  end
end

这是另一个:

class DeviceController
  @my_public_device  ||= Device['mydevice']
  @my_private_device ||= Device['mydevice']

  class << self
    attr_reader :my_public_device, :my_private_device
    private :my_private_device
  end
end

(区别在于第一个例子是惰性的，它只在第一次调用相应的属性读取器时才初始化实例变量.第二个在类体执行后立即初始化它们，即使它们永远不需要，就像 Java 版本一样.)

(The difference is that the first example is lazy, it only initializes the instance variable when the corresponding attribute reader is first called. The second one initializes them as soon as the class body is executed, even if they are never needed, just like the Java version does.)

让我们回顾一下这里的一些概念.

Let's go over some of the concepts here.

在 Ruby 中，就像在所有其他正确"(正确"的各种定义)面向对象语言中一样，状态(实例变量、字段、属性、槽、属性，无论您想如何称呼它们)都是始终私密.没有办法从外部访问它们.与对象通信的唯一方法是向其发送消息.

In Ruby, as in every other "proper" (for various definitions of "proper") object-oriented language, state (instance variables, fields, properties, slots, attributes, whatever you want to call them) is always private. There is no way to access them from the outside. The only way to communicate with an object is by sending it messages.

[注意:每当我写不可能"、总是"、唯一的方法"等内容时，实际上并不意味着没有办法，除了反思".在这种特殊情况下，例如有 Object#instance_variable_set.]

[Note: Whenever I write something like "no way", "always", "the only way" etc., it actually no means "no way, except for reflection". In this particular case, there is Object#instance_variable_set, for example.]

换句话说:在 Ruby 中，变量始终是私有的，访问它们的唯一方法是通过 getter 和/或 setter 方法，或者在 Ruby 中调用属性读取器和/或写入器.

In other words: in Ruby, variables are always private, the only way to access them is via a getter and/or setter method, or, as they are called in Ruby, an attribute reader and/or writer.

现在，我继续写实例变量，但在Java示例中，我们有静态字段，即类变量.好吧，在 Ruby 中，与 Java 不同的是，类也是对象.它们是 Class 类的实例，因此，就像任何其他对象一样，它们可以具有实例变量.因此，在 Ruby 中，类变量的等价物实际上只是一个标准实例变量，它属于恰好是类的对象.

Now, I keep writing about instance variables, but in the Java example we have static fields, i.e. class variables. Well, in Ruby, unlike Java, classes are objects, too. They are instances of the Class class and so, just like any other object, they can have instance variables. So, in Ruby, the equivalent to a class variable is really just a standard instance variable which belongs to an object which just happens to be a class.

(还有类层次结构变量，用双符号表示@@sigil.这些真的很奇怪，你可能应该忽略它们.类层次结构变量在整个类中共享层次结构，即它们所属的类，它的所有子类及其子类和子类......以及所有这些类的所有实例.实际上，它们更像是全局变量而不是类变量.它们真的应该被称为$$var 而不是 @@var，因为它们与全局变量的关系比实例变量更密切.它们并非完全没用，只是很少有用.)

(There are also class hierarchy variables, denoted with a double at sign @@sigil. Those are really weird, and you should probably just ignore them. Class hierarchy variables are shared across the entire class hierarchy, i.e. the class they belong to, all its subclasses and their subclasses and their subclasses ... and also all instances of all of those classes. Actually, they are more like global variables than class variables. They should really be called $$var instead of @@var, since they are much more closely related to global variables than instance variables. They are not entirely useless but only very rarely useful.)

所以，我们已经涵盖了字段"部分(Java 字段 == Ruby 实例变量)，我们已经涵盖了公共"和私有"部分(在 Ruby 中，实例变量始终是私有的，如果您想使它们是公共的，使用公共的 getter/setter 方法)，我们已经涵盖了静态"部分(Java 静态字段 == Ruby 类实例变量).最后"部分呢?

So, we have covered the "field" part (Java field == Ruby instance variable), we have covered the "public" and "private" parts (in Ruby, instance variables are always private, if you want to make them public, use a public getter/setter method) and we have covered the "static" part (Java static field == Ruby class instance variable). What about the "final" part?

在 Java 中，final"只是const"的一种有趣的拼写方式，设计者避免了这种方式，因为 C 和 C++ 等语言中的 const 关键字被巧妙地破坏了，他们不想要来迷惑人.Ruby 确实有常量(以大写字母开头).不幸的是，它们并不是真正恒定的，因为尝试修改它们，同时生成警告，实际上是有效的.因此，它们更像是一种约定，而不是编译器强制执行的规则.然而，常量更重要的限制是它们总是公开的.

In Java, "final" is just a funny way of spelling "const", which the designers avoided because the const keyword in languages like C and C++ is subtly broken and they didn't want to confuse people. Ruby does have constants (denoted by starting with a capital letter). Unfortunately, they are not really constant, because trying to modify them, while generating a warning, actually works. So, they are more of a convention than a compiler-enforced rule. However, the more important restriction of constants is that they are always public.

所以，常量几乎是完美的:它们不能被修改(好吧，它们不应该被修改)，即它们是final，它们属于一个类(或模块)，即它们是static.但是它们总是public，所以不幸的是它们不能用于建模private static final字段.

So, constants are almost perfect: they cannot be modified (well, they shouldn't be modified), i.e. they are final, they belong to a class (or module), i.e. they are static. But they are always public, so unfortunately they cannot be used to model private static final fields.

这正是考虑问题而不是解决方案的关键.你想要什么?你想声明

And this is exactly the point where thinking about problems instead of solutions comes in. What is it that you want? You want state that

属于一个类，
只能读不能写，
只初始化一次
可以是私有的，也可以是公共的.

您可以实现所有这些，但方式与 Java 完全不同:

You can achieve all of that, but in a completely different way than in Java:

类实例变量
不提供setter方法，只提供getter
使用 Ruby 的 ||= 复合赋值只赋值一次
getter 方法

您唯一需要担心的是，您不要在任何地方分配@my_public_device，或者更好的是，根本不要访问它.始终使用 getter 方法.

The only thing you have to worry about, is that you don't assign to @my_public_device anywhere, or better yet, don't access it at all. Always use the getter method.

是的，这是实施中的一个漏洞.Ruby 通常被称为成年人的语言"或同意的成人语言"，这意味着您不必让编译器强制执行某些事情，而只需将它们放在文档中，并简单地相信您的开发伙伴已经学会了接触其他人人们的私处很粗鲁...

Yes, this is a hole in the implementation. Ruby is often called a "grown-up's language" or a "consenting adults language", which means that instead of having the compiler enforce certain things, you just put them in the documentation and simply trust that your fellow developers have learned that touching other people's privates is rude ...

一种完全不同的隐私方法是函数式语言中使用的方法:使用闭包.闭包是关闭其词法环境的代码块，即使在该词法环境超出范围之后也是如此.这种实现私有状态的方法在 Scheme 中非常流行，但最近也被 Douglas Crockford 等人推广.对于 JavaScript.这是 Ruby 中的示例:

A totally different approach to privacy is the one used in functional languages: use closures. Closures are blocks of code that close over their lexical environment, even after that lexical environment has gone out of scope. This method of implementing private state is very popular in Scheme, but has recently also been popularized by Douglas Crockford et al. for JavaScript. Here's an example in Ruby:

class DeviceController
  class << self
    my_public_device, my_private_device = Device['mydevice'], Device['mydevice']

    define_method :my_public_device  do my_public_device  end
    define_method :my_private_device do my_private_device end

    private :my_private_device
  end # <- here the variables fall out of scope and can never be accessed again
end

请注意与我的答案顶部的版本的细微但重要的区别:缺少 @ 符号.在这里，我们创建的是local 变量，而不是instance 变量.一旦类体结束，这些局部变量就会超出范围并且永远无法再次访问.只有定义了两个 getter 方法的两个块仍然可以访问它们，因为它们关闭了类主体.现在，它们真的私有并且它们是final，因为整个程序中唯一仍然可以访问它们的是一个纯粹的getter 方法.

Note the subtle but important difference to the versions at the top of my answer: the lack of the @ sigil. Here, we are creating local variables, not instance variables. As soon as the class body ends, those local variables fall out of scope and can never be accessed ever again. Only the two blocks which define the two getter methods still have access to them, because they close over the class body. Now, they are really private and they are final, because the only thing in the entire program which still has access to them is a pure getter method.

这可能不是惯用的 Ruby，但对于任何具有 Lisp 或 JavaScript 背景的人来说，这应该足够清楚了.也很优雅.

This is probably not idiomatic Ruby, but for anyone with a Lisp or JavaScript background it should be clear enough. It is also very elegant.

这篇关于Java中“私有静态最终"和“公共静态最终"类变量的最接近的Ruby表示?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！