class inheritance

[Grant Hackshaw]

I have written code similar to what is below.
Can anyone explain to me why the instance of class1 created in class2 can't be referenced in class3?

class Class1
{
  private int x;
 
   public void setX(int x)
   {
      this.x=x; 
   }
   public int getX()
   {
      return x; 
   }
}
class Class2
{
   static int blob;
   public static void main(String[] args)
  {
    Class1 class1=new Class1();
    class1.setX(9);
    
    Class3 effe = new Class3();
    effe.someFunction();
      
   }
}
public class Class3
{

public Class3()
{
}

    int blob;
    Void someFunction()
    {
    blob = class1.getX;
    System.out.println(blob);
    }
 
}

[ EJFH: Added [code ][ /code] tags to preserve formatting. ]
[ March 26, 2006: Message edited by: Ernest Friedman-Hill ]

[Ernest Friedman-Hill]

Hi,

Welcome to JavaRanch!

Variables defined inside of a method are "local variables" -- their names are not visible outside of the method in which they're defined. The variable "class1" is local to the method "main" in Class2, and therefore is available nowhere else.

[Grant Hackshaw]

Thanks Earnest 4 the warm welcome and the fast reply.

So I should declare variable class1 outside of the method, is that the trick if I need to use it in Class3?

[Ernest Friedman-Hill]

Well, looking at your code and trying to guess what you want to accomplish: you want to call someFunction() and have it operate on a specific instance of Class1, created by Class2. The best way to do this, instead of using member variables like (yuk) global variables, is to give someFunction() an argument -- i.e., define someFunction like

    void someFunction(Class1 c1)
    {
        int blob = c1.getX();
        System.out.println(blob);
    }

Then you can create a Class1 in Class2.main() and pass it to Class3.someFunction(), like this:

 public static void main(String[] args)
 {
      Class1 class1=new Class1();
      class1.setX(9);
    
      Class3 effe = new Class3();
      effe.someFunction(class1);      
 }

Although this may look like a small change, it's really rather profound. What we've done is to decouple Class3 and Class2. Class3 doesn't need to know anything about Class2, and this makes it easier to write the classes and to maintain them when they need to change. The main reason is that it makes everything easier to understand: you can see what someFunction() does without knowing anything about any other class that might use it.