Suppose, I have a webserver which holds numerous servlets. For information passing among those servlets I am setting session and instance variables.

Now, if 2 or more users send request to this server then what happens to the session variables?   
Will they all be common for all the users or they will be different for each user?  
If they are different, then how was the server able to differentiate between different users?

One more similar question, if there are `n` users accessing a particular servlet, then this servlet gets instantiated only the first time the first user accessed it or does it get instantiated for all the users separately?   
In other words, what happens to the instance variables?

How do servlets work? Instantiation, sessions, shared variables and multithreading

Is there any advantage for either approach?


Example 1:

    class A {
        B b = new B();
    }

Example 2:

    class A {
        B b;

        A() {
             b = new B();
        }
    }



Should I instantiate instance variables on declaration or in the constructor?

I read [https://stackoverflow.com/questions/826734/when-do-ruby-instance-variables-get-set][1] but I&#39;m of two minds when to use class instance variables.  

Class variables are shared by all objects of a class, Instance variables belong to one object. There&#39;s not much room left to use  class instance variables if we have class variables.
  
Could someone explain the difference between these two and when to use them?

Here&#39;s a code example:  

    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


**Update:** I understand now! Class Instance Variables are not passed along the inheritance chain.


  [1]: http://archive.today/dCYNj

Ruby class instance variable vs. class variable

Here is some code:
    
    class Person
      def initialize(age)
        @age = age
      end
    
      def age
        @age
      end
    
      def age_difference_with(other_person)
        (self.age - other_person.age).abs
      end
    
      protected :age
    end

What I want to know is the difference between using `@age` and `self.age` in ```age_difference_with``` method.

Instance variable: self vs @

What are Ruby variables preceded with double at signs (`@@`)? My understanding of a variable preceded with an at sign is that it is an instance variable, like this in PHP:

PHP version

    class Person {
    
        public $name;

        public function setName($name) {
            $this-&gt;name = $name;
        }
    
        public function getName() {
            return $this-&gt;name;
        }
    }

Ruby equivalent

    class Person

        def set_name(name)
            @name = name
        end

        def get_name()
            @name
        end
    end

What does the double at sign `@@` mean, and how does it differ from a single at sign?

What does @@variable mean in Ruby?

Let&#39;s say I have a `Gift` object with `@name = &quot;book&quot;` &amp; `@price = 15.95`. What&#39;s the best way to convert that to the Hash `{name: &quot;book&quot;, price: 15.95}` in Ruby, not Rails (although feel free to give the Rails answer too)?

Ruby convert Object to Hash

Is there a built-in method in Python to get an array of all a class&#39; instance variables? For example, if I have this code:

    class hi:
      def __init__(self):
        self.ii = &quot;foo&quot;
        self.kk = &quot;bar&quot;

Is there a way for me to do this:

    &gt;&gt;&gt; mystery_method(hi)
    [&quot;ii&quot;, &quot;kk&quot;]

Edit: I originally had asked for class variables erroneously.

How to get instance variables in Python?

Do properties in Objective-C 2.0 require a corresponding instance variable to be declared? For example, I&#39;m used to doing something like this:

**MyObject.h**

    @interface MyObject : NSObject {
    NSString *name;
    }
    @property (nonatomic, retain) NSString *name;
    @end

**MyObject.m**

    @implementation
    @synthesize name;
    @end

However, what if I did this instead:

**MyObject.h**

    @interface MyObject : NSObject {
    }
    @property (nonatomic, retain) NSString *name;
    @end

Is this still valid? And is it in any way different to my previous example?

Do declared properties require a corresponding instance variable?

Let&#39;s say I have the following hash:

    { :foo =&gt; &#39;bar&#39;, :baz =&gt; &#39;qux&#39; }

How could I dynamically set the keys and values to become instance variables in an object...

    class Example
      def initialize( hash )
        ... magic happens here...
      end
    end

... so that I end up with the following inside the model...

    @foo = &#39;bar&#39;
    @baz = &#39;qux&#39;


?
      

Ruby Metaprogramming: dynamic instance variable names

If an instance variable belongs to a class, can I access the instance variable (e.g. `@hello`) directly using the class instance?

    class Hello
      def method1
        @hello = &quot;pavan&quot;
      end
    end
    
    h = Hello.new
    puts h.method1



Access instance variable from outside the class

I want to pass a default argument to an instance method using the value of an attribute of the instance:

    class C:
        def __init__(self, format):
            self.format = format
        
        def process(self, formatting=self.format):
            print(formatting)

When trying that, I get the following error message:

&lt;!-- language: lang-none --&gt;

    NameError: name &#39;self&#39; is not defined

I want the method to behave like this:

    C(&quot;abc&quot;).process()       # prints &quot;abc&quot;
    C(&quot;abc&quot;).process(&quot;xyz&quot;)  # prints &quot;xyz&quot;

What is the problem here, why does this not work? And how could I make this work?

How to pass a default argument value of an instance member to a method?

I&#39;m trying to test the following method:

    def unprocess_move(board, move)
      if move[0].instance_of?(Array)
        multi_move = @multi_move.pop(2).reverse
        multi_move.each do |single_move|
          unapply_move(board, single_move)
        end
      else
        board = unapply_move(board, move)
      end
      board
    end


where I want to set the state for @multi_move, but I don&#39;t want to add an accessor just for testing. Is there a way to do so without the accessor? Thanks.



Ruby Rspec : Testing instance variables without adding an accessor to source

Does somebody know how to make private, non-static members in CoffeeScript? Currently I&#39;m doing this, which just uses a public variable starting with an underscore to clarify that it shouldn&#39;t be used outside of the class:

    class Thing extends EventEmitter
      constructor: (@_name) -&gt;

      getName: -&gt; @_name

Putting the variable in the class makes it a static member, but how can I make it non-static? Is it even possible without getting &quot;fancy&quot;?

Private members in CoffeeScript?

I have some modules where I would like to use instance variables in. I&#39;m currently initializing them like this:

    module MyModule
      def self.method_a(param)
        @var ||= 0
        # other logic goes here
      end
    end

I also could call a init method to initialize them:

    def init
      @var = 0
    end

but this would mean I have to remember to always call it. 

Is there a better way of doing this?



How can I initialize a module&#39;s instance variables in Ruby?

What is the semantic difference between these 3 ways of using ivars and properties in Objective-C?

1.

    @class MyOtherObject; 
    @interface MyObject {
    }
    @property (nonatomic, retain) MyOtherObject *otherObj;
2.

    #import &quot;MyOtherObject.h&quot;
    @interface MyObject {
        MyOtherObject *otherObj;
    }
    @property (nonatomic, retain) MyOtherObject *otherObj;
3.

    #import &quot;MyOtherObject.h&quot;
    @interface MyObject {
        MyOtherObject *otherObj;
    }



What is the difference between ivars and properties in Objective-C

Can anyone explain the difference between accessing an instance attribute via `self.attribute` and by `@attribute`?


Directly accessing an instance variable vs. Using an accessor method

Is it safe to count on `int`s always being initialized to 0 in Objective-C?

More specifically, when an object with `int` ivars has been newly instantiated, is it safe to assume that its ivars have value 0?

Are ints always initialized to 0?

I have just tried to lint some code with Pylint, and the last remaining error is

    R0902: too-many-instance-attributes (8/7)

I understand the rationale behind limiting the number of instance attributes, but seven seems a bit low. I also realise that the linter should not have the last word. However, I would like to know what I should be doing instead of:

    def __init__(self, output_file=None, output_dir=None):
        &quot;&quot;&quot;
        Set the frobnicator up, along with default geometries
        &quot;&quot;&quot;

        self.margin = 30

        self.pos = [0, 0]
        self.sep = [5, 5]

        self.cell = [20, 20]

        self.frobbr = library.Frobbr()

        page = self.frobbr.get_settings(&#39;page&#39;)

        self.lim = [page.get_width() - self.margin,
                    page.get_height() - self.margin]

        self.filename = output_file
        self.moddir = output_dir

Should I package the geometries up into a dict, do something else to stop Pylint complaining, or just ignore it (which I don&#39;t really want to do)?

How to deal with Pylint&#39;s &quot;too-many-instance-attributes&quot; message?

I just rewrote a working program into functions in a class and everything messed up.

**First**, in the `__init__` section of the class I declared a bunch of variables with `self.variable=something`.

Should I be able to access/modify these variables in every function of the class by using `self.variable` in that function? In other words, by declaring `self.variable` I have made these variables, global variables in the scope of the class right?

If not, how do I handle self?

**Second**, how do I correctly pass arguments to the class?

**Third**, how do I call a function of the class outside of the class scope?

**Fouth**, how do I create an Instance of the `class INITIALCLASS` in another `class OTHERCLASS`, passing variables from `OTHERCLASS` to `INITIALCLASS`?

I want to call a function from `OTHERCLASS` with arguments from `INITIALCLASS`. What I&#39;ve done so far is.

    class OTHERCLASS():
        def __init__(self,variable1,variable2,variable3):
            self.variable1=variable1
            self.variable2=variable2
            self.variable3=variable3
        def someotherfunction(self):
            something=somecode(using self.variable3)
            self.variable2.append(something)
            print self.variable2
        def somemorefunctions(self):
            self.variable2.append(variable1)
            
    class INITIALCLASS():
        def __init__(self):
            self.variable1=value1
            self.variable2=[]
            self.variable3=&#39;&#39;
            self.DoIt=OTHERCLASS(variable1,variable2,variable3)

        def somefunction(self):
            variable3=Somecode
            #tried this
            self.DoIt.someotherfunctions()
            #and this
            DoIt.someotherfunctions()

I clearly didn&#39;t understand how to pass variables to classes or how to handle `self`, when to use it and when not. I probably also didn&#39;t understand how to properly create an instance of a class. In general I didn&#39;t understand the mechanics of classes so please help me and explain it to me like I have no idea (which I don&#39;t, it seems). Or point me to a thorough video, or readable tutorial.

All I find on the web is super simple examples, that didn&#39;t help me much. Or just very short definitions of classes and class methods instances etc.

I can send you my original code if you guys want, but its quite long.

Passing variables, creating instances, self, The mechanics and usage of classes: need explanation



    class Hello
    @hello = &quot;hello&quot;
    	def display
    		puts @hello
    	end
    end
    
    h = Hello.new
    h.display

I created the class above. It doesn&#39;t print anything out. I thought the instance variable @hello was set during the class declaration. But when I call the display method the output is &#39;nil&#39;. What&#39;s the correct way to do this?

When do Ruby instance variables get set?

I have a class something like below, and I used instance variables (array) to avoid using lots of method parameters. 

It works as I expected but is that a good practice?
Actually I wouldn&#39;t expect that worked, but I guess class methods are not working as static methods in other languages.

    class DummyClass
      def self.dummy_method1
        @arr = []
        # Play with that array
      end
    
      def self.dummy_method2
        # use @arr for something else
      end
    end



Using Instance Variables in Class Methods - Ruby

Maybe this is more of a style question than a technical one but I have a class with several member variables and I want to have it work so that some of the member variables are initialized when the user first creates an instance of the class (i.e. in the `__init__` function) and I want the other member variables to be defined from arguments of member functions that will be called later on.  So my question is should I initialize all member variables in the `__init__` function (and set the ones that will be defined later on to dummy values) or initialize some in the `__init__` function and some in later functions.  I realize this might be difficult to understand so here are a couple of examples.

This example has `var3` set to 0 initially in the `__init__` function, then set to the desired value later on in the my_funct function.

    class myClass(object):
       def __init__(self,var1,var2):
            self.var1=var1
            self.var2=var2
            self.var3=0

      def my_funct(self,var3):
           self.var3=var3

and in this example, `var3` is not defined at all in the `__init__` function 

    class myClass(object):
       def __init__(self,var1,var2):
            self.var1=var1
            self.var2=var2
    
      def my_funct(self,var3):
           self.var3=var3

I don&#39;t think either way would make a big difference (maybe a slight difference in memory usage).  But I was wondering if one of these is preferred over the other for some reason.

Should all member variables be initialized in __init__

I see it recommended all over the place when coding for iOS that properties should be used for accessing instance variables because of the benefits this lends to memory management, among other things.

This advice doesn&#39;t sit terribly well with me. I find that using properties instead of plain old ivars just takes too much code and I don&#39;t really see the benefits if you&#39;re comfortable with memory management. Is it really that important? What&#39;s your approach to managing instance variables?

Must every ivar be a property?

I&#39;m rather confused about properties and instance variables in Objective-C.

I&#39;m about half-way through Aaron Hillegass&#39;s &quot;Cocoa Programming for Mac OS X&quot; and everything is logical. You would declare a class something like this:

    @class Something;
    
    @interface MyClass : NSObject {
    	NSString *name;
    	NSArray *items;
    	
    	Something *something;
    	
    	IBOutlet NSTextField *myTextField;
    }
    
    @property (nonatomic, retain) NSString *name;
    @property (nonatomic, retain) NSArray *items;

- Since other objects need to manipulate our `name` and `items` instance variables, we use `@property`/`@synthesize` to generate accessors/mutators for them. Within our class, we don&#39;t use the accessors/mutators—we just interact with the instance variable directly.

- `something` is just an instance variable that we&#39;re going to use in our class, and since no one else needs to use it, we don&#39;t create a pair of accessors and mutators for it.

- We need to interact with a text field in our UI, so we declare an `IBOutlet` for it, connect it, and we&#39;re done.

All very logical.

However, in the iPhone world, things seem to be different. People declare properties for every single instance variable, declare properties for `IBOutlets`, and use accessors/mutators to interact with instance variables **within** the class (e.g. they would write `[self setName:@&quot;Test&quot;]` rather than `name = @&quot;Test&quot;`).

Why? What is going on? Are these differences iPhone-specific? What are the advantages of declaring properties for all instance variables, declaring properties for `IBOutlets`, and using accessors/mutators within your own class?

Properties and Instance Variables in Objective-C

I want to make an instance variable that can&#39;t be accessed from outside. Is something like that possible in objective-c? I remember Apple has private variables and stuff like that, but if people know about them, they can use them. Apple calls that &quot;private API&quot;, but obviously others can access that stuff if they find out what&#39;s in there.

Until now I believed that something like this creates a private instance variable:

    @interface MyClass : NSObject {
        CGFloat weight;
    }

No @property, no @synthesize, just the declaration above.

Also I know Apple adds a _inFrontOfTheirPrivateInstanceVariables, but they said somewhere that they don&#39;t like to see others doing that because they might override accidently hidden instance variables when doing that.

What&#39;s the trick here?

All Instance Variables Solutions on Gang of Coders

Total of 25 Instance Variables Solutions