标签: class-variables

是否有可能在python中有静态类变量或方法？这样做需要什么语法？

首先,一个难题:以下代码打印什么？

public class RecursiveStatic {
    public static void main(String[] args) {
        System.out.println(scale(5));
    }

    private static final long X = scale(10);

    private static long scale(long value) {
        return X * value;
    }
}

回答:

0

下面的剧透.

如果您打印X的规模(长),并重新定义X = scale(10) + 3,印刷品会X = 0那么X = 3.这意味着X暂时设置为0以后设置为3.这是违反final!

static修饰符与final修饰符结合使用,也用于定义常量.最终修饰符表示此字段的值不能更改.

来源:https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html [强调添加]

我的问题:这是一个错误吗？被final定义不清？

这是我感兴趣的代码. X分配了两个不同的值:0和3.我认为这违反了 …

我读过" Ruby实例变量什么时候设置？ "但我在使用类实例变量时有两种想法.

类变量由类的所有对象共享,实例变量属于一个对象.如果我们有类变量,那么使用类实例变量的余地就不大了.

有人可以解释这两者之间的区别以及何时使用它们？

这是一个代码示例:

class S
  @@k = 23
  @s = 15
  def self.s
    @s
  end
  def self.k
     @@k
  end

end
p S.s #15
p S.k #23

我现在明白了,Class Instance Variables不会传递给继承链!

什么是Ruby变量,在符号(@@)前面加上double ？我对一个带有at符号的变量的理解是它是一个实例变量,在PHP中是这样的:

PHP版本

class Person {

    public $name;

    public function setName($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

Ruby相当于

class Person

    def set_name(name)
        @name = name
    end

    def get_name()
        @name
    end
end

双重标志@@是什么意思,它与单个标志有什么不同？

对于类变量,向上铸造和向下铸造有什么区别？

例如,在下面的程序类中,Animal只包含一个方法但Dog类包含两个方法,那么我们如何将Dog变量转换为Animal变量.

如果完成了施法,那么我们如何使用Animal的变量调用Dog的另一种方法.

class Animal 
{ 
    public void callme()
    {
        System.out.println("In callme of Animal");
    }
}


class Dog extends Animal 
{ 
    public void callme()
    {
        System.out.println("In callme of Dog");
    }

    public void callme2()
    {
        System.out.println("In callme2 of Dog");
    }
}

public class UseAnimlas 
{
    public static void main (String [] args) 
    {
        Dog d = new Dog();      
        Animal a = (Animal)d;
        d.callme();
        a.callme();
        ((Dog) a).callme2();
    }
}

有没有办法在Ruby中的模块中创建一个类似于类变量的变量？我的意思是,它可以在不初始化模块实例的情况下访问,但可以更改(与模块中的常量不同).

谁能告诉我类变量和类实例变量之间的区别？

我已经在Ruby中编程了几个月了,我想知道什么时候使用常量而不是类变量,反之亦然.(我在Rails工作,考虑模型中的常量).

class Category
  TYPES = %w(listing event business).freeze
end

要么

class Category
  @@types = %w(listing event business).freeze
  cattr_reader :types
end

是否存在一种优于另一种情况的情况？或者只是品味/风格问题？

我很惊讶地发现子类的类变量无法访问父类的类变量而没有明确指出父类的类名:

>>> class A(object):
...     x = 0
... 
>>> class B(A):
...     y = x+1
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in B
NameError: name 'x' is not defined
>>> class B(A):
...     y = A.x + 1
... 
>>> B.x
0
>>> B.y
1

为什么在定义中我必须引用Ax而不仅仅是x？这与我对实例变量的直觉相反,因为我可以在定义B之后引用Bx.

为什么java常量声明为static？

class Foo{
    static final int FII = 2 ;
}

在这个我理解使用final？为什么它必须是静态的？为什么它应该是一个类变量,而不是一个实例变量？