标签: instance-variables

public class Sentencegenerator {
private String[] subjects;
private String[] verbs; 
private String[] directObjects;

public Sentencegenerator(){
    subjects = {"Cat", "Dog", "Joe", "Teacher", "Policeman", "Doctor", "Dick"};
    verbs = {"eats", "reads", "cums", "farts", "poops", "stabs", "cries"};
    directObjects = {"book", "sticker", "fish", "man", "chiwawa", "marker", "cheese"};
}

public Sentencegenerator(String[] mySubjects, String[] myVerbs, String[]    myDirectObjects){
    subjects = mySubjects;
    verbs = myVerbs;
    directObjects = myDirectObjects;
}

我知道只能在初始化数组时创建数组常量，但是有没有办法可以创建一个数组实例变量，然后创建一个拥有自己的常量的构造函数？

是否必须将实例变量括在大括号中？还是只是约定俗成？

例如：

#import <Foundation/Foundation.h>    

@interface Person : NSObject
{
    NSString *name;
    int age;
}

Python 3.4.0a1
视窗 8.1

创建的类：

class Bank(object):  
    bankrupt = False  

命令在 IDLE 中输入，__main__结果如下：

>>> a = Bank()
>>> b = Bank()
>>> a.bankrupt
False
>>> b.bankrupt
False
>>> b.bankrupt = True
>>> b.bankrupt
True
>>> a.bankrupt
False

预期输出：

当我更改 b.bankrupt 时，我预计 a.bankrupt 会更改为 True，因为变量 bankrupt 是为整个类定义的，而不是为单个实例定义的（带有self.bankrupt） 为什么这没有发生？

例如，如果我创建一个类 Point。

类点：

def__init__(self, x, y):
    self._x = x
    self._y = y 

和

类点：

def__init__(self, x, y):
    self.x = x
    self.y = y 

self._x 和 self.x 的使用有什么区别。

我有一个MyClass包含实例变量的类,@id并且@color:

class MyClass
  attr_accessor :id, :color
end

我创建了一个对象:

d = MyClass.new
d.id = 2
d.color = 'red'
d #=> #<MyClass:0x00000005fb52c0 @id=2, @color="red"> 

我想获得一个包含实例变量及其值的哈希:

d.to_hash #=> { id: 2, color: 'red'}

实施此类方法的最佳方法是什么？

我刚刚遇到了一段代码。在一种情况下，我无法使用其实例访问类的私有成员（这很好），但在其他情况下，我能够使用其不同的实例访问私有成员（属于同班）。谁能解释一下为什么会发生这种情况？

 class Complex {
    private double re, im; 
    public String toString() {
        return "(" + re + " + " + im + "i)";
    }
    Complex(){}

/*Below c is different instance, still it can access re,im( has a private access) 
  without any error.why? */

    Complex(Complex c) {
        re = c.re;
        im = c.im;
    }
}

public class Main {
    public static void main(String[] args) {
        Complex c1 = new Complex();
        Complex c2 = new Complex(c1);
        System.out.println(c1.re);  /* But getting an …

我有一个带有方法的类register(key, val)。我正在尝试将其添加key为类的实例变量并将其设置为等于val. 现在我正在尝试使用，self.instance_variable_set(':@' + key, val)但出现此错误：

in `instance_variable_set': `:@table' is not allowed as an instance variable name (NameError)

我在打电话 register('table', {'key' => 'value'})

知道如何正确执行此操作吗？谢谢！

在这里我想知道什么是基于实例的成员？我认为是基于实例的成员==实例变量。我对么？如果我是正确的，那么我怎么知道哪个是变量还是实例变量？构造函数下的变量将成为实例变量，对吧？还是我理解错了？

我正在寻找在类被实例化后设置引用另一个实例属性的实例属性的最佳实践。

例如：

class Foo:
    def __init__(self):
        self.a = 1
        self.b = self.a + 1

>>> obj_foo = Foo()
>>> obj_foo.a
1
>>> obj_foo.b
2
>>> obj_foo.a = 5
>>> obj_foo.a
5
>>> obj_foo.b
2 # I want this to be 6

一个实例属性引用另一个实例属性是不好的做法吗？

我可以看到如何实现一种方法来检查和更新依赖的实例属性，但这似乎有很多开销/hacky。非常感谢任何帮助！

我们知道...

实例变量在默认构造函数中初始化.例如.

public class H{
    int x;

    public static void main(String... args){
        System.out.print(new H().x);
    }
}

上面代码的O/P是0, 因为有一个默认构造函数被调用,并且该构造函数将x初始化为0.

现在,我的问题是,如果我们运行以下代码,即

public class H{
        int x;

        public H(){}

        public static void main(String... args){
            System.out.print(new H().x);
        }
}

在这种情况下,实际的O/P也是0,但我认为应该有编译器错误,x没有被初始化,因为我们已经覆盖了默认的构造函数而没有初始化xI认为我已经让我的问题清楚了..