here...

use Mob

1. class Atom {
2.   float var1, var2, var3;
3.   Atom() {
4.   }
5.   Boolean isMob() {
6.     return false;
7.   }
8. }
9. class Mob extends Atom {
10.   float var4, var5;
11.   Mob() {
12.     super();
13.   }
14.   Boolean func1() {
15.     return true;
16.   }
17.   Boolean isMob() {
18.     return true;
19.   }
20. }
21. void setup() {
22.   Mob atom=new Mob();
23.   println ( atom.func1()  ) ;       //This doesn't work but is there proper syntax for this or do I have to make a Mob var?
24. }

it would.

what do you mean?

1. class Atom{
2.   float var1,var2,var3;
3.   Atom(){}
4.   Boolean isMob(){return false;}
5. }
6. class Mob extends Atom{
7.   float var4,var5;
8.   Mob(){super();}
9.   Boolean func1(){return true;}
10.   Boolean isMob(){return true;}
11. }
12. setup(){
13.   Atom[] atoms=new Atom[4];
      atoms[3]=new Mob();
14.   atoms[3]<Mob>.func1();           //This doesn't work but is there proper syntax for this or do I have to make a Mob var?
15. }

This is a more relevant example of what I'm trying to accomplish.

yes.


atom gives all its properties and methods to Mob and you can access it from there afaik

1. class Atom {
2.   float var1, var2, var3;
3.   Atom() {
4.   }
5.   Boolean isMob() {
6.     return false;
7.   }
8. }
9. class Mob extends Atom {
10.   float var4, var5;
11.   Mob() {
12.     super();
13.   }
14.   Boolean func1() {
15.     return true;
16.   }
17.   Boolean isMob() {
18.     return true;
19.   }
20. }
21. void setup() {
22.   Mob[] atoms=new Mob[4];
23.   atoms[3]=new Mob();
24.   println (   atoms[3].func1() ) ;      //This doesn't work but is there proper syntax for this or do I have to make a Mob var?
25. }

I've got a little secret Java shortcut for it-> operator instanceof

class Atom {
  float var1, var2, var3;
}

class Mob extends Atom {
  float var4, var5;
}

void setup() {
  Atom a = new Atom();
  Atom b = new Mob();

  println( a instanceof Mob );
  println( b instanceof Mob );

  exit();
}

Still misunderstanding as there will be other Atoms in the Atoms list.

atoms[0]=new Atom();
atoms[1]=new Mob();
atoms[2]=new Terrain(); //Which also extends Atom

What you are trying to do is called polymorphism and it will avoid the need for type casting. In fact you have already done this with the isMob method.

The reason that
atoms[3]<Mob>.func1();
doesn't work is that atom[3] is an Atom class reference (even though the object is a Mob) and no such method exists in the Atom class. Simply put this function in Atom as well. I have done that and added the printName method to your code to get.

1. class Atom {
2.   float var1, var2, var3;
3.   Atom() {
4.   }
5.   Boolean isMob() {
6.     return false;
7.   }
8.   Boolean func1() {
9.     return false;
10.   }
11.   void printName() {
12.     println("I am an Atom");
13.   }
14. }
15. 
    
16. class Mob extends Atom {
17.   float var4, var5;
18.   Mob() {
19.     super();
20.   }
21.   Boolean func1() {
22.     return true;
23.   }
24.   Boolean isMob() {
25.     return true;
26.   }
27.   void printName() {
28.     println("I am a Mob");
29.   }
30. }
31. 
    
32. void setup() {
33.   Atom[] atoms=new Atom[4];
34.   atoms[0]=new Atom();
35.   atoms[1]=new Atom();
36.   atoms[2]=new Mob();
37.   atoms[3]=new Atom();
38.   for (int i = 0; i < atoms.length; i++)
39.     atoms[i].printName();
40. }

Will produce the output

I am an Atom
I am an Atom
I am a Mob
I am an Atom

The scenario I have is much more complex then this example one. I have to reference functions and variables that the other classes do not have access too.

TIL instanceof negates the need of my isMob() function. That being said it doesn't help with my issue lol.

AFAIK, a parent class can't access fields & methods from a child class w/o some serious hack!

The reason why it is so, is b/c a parent class is "less complete" than any class which may inherit from it.
The heir child class has, besides its own fields + methods, all of the fields + methods from all its lineage class/interface parents!

A parent class just gives all, and takes none!

The child class can access original & untainted parent's fields + methods by using super to refer to them!
There's no corresponding keyword to access the heirs' though!

Some remarks on the code, unrelated to the question.
- Use Boolean instead of boolean. These are not the same thing, The former is slower and bigger than the latter.
- No need to declare the empty constructor, nor the one only calling super(). This is automatic.

In my own example, I've removed all of those empty and superfluous constructors & methods!  ^_^

I just need to know if its possible to call the Mobs functions without creating another variable. [Typecast]

As quarks already shown, the answer is not!

P.S.: You don't need to create a new temporary variable for cast.
However, you'd need to use (cast) all the time otherwise!  

When you declare a variable as a class of type Atom,
you access fields + methods from Atom only,
even though the instance content itself is derived from it.

Atom myAtomInstance = new Mob();

In the case above, the instance variable myAtomInstance
can freely access all original fields + methods from class Atom.

However, if it tries to access a field or method which only exists within class Mob,
it will fail, even though it is itself an instance of Mob!

Internally it is Mob, but externally it is Atom!

A classical example is the relationship between interface List and class ArrayList:
final static List <Atom> atoms = new ArrayList <Atom> ();

As long as only common methods like size(), get(), add() and remove(), etc. are used,
it works alright as a List!

But if exotic ones like clone(), ensureCapacity(), trimToSize(), etc.
which are exclusive methods from ArrayList, are needed;
you either use (cast) or outright declare atoms as an ArrayList rather than just a List!

Hope you get the logic now!  

An alternative of quarks' using instanceof:

1. if ( atoms[i] instanceof Mob ) {
2.   Mob m = (Mob) atoms[i];
3. 
   
4.   if ( m.var4 == 3 && m.var3 == 1.5 && m.func1() )
5.     m.printName();
6. }

Even though I don't get what you need method func1() for!