hey, your code isnt really complete and i dont really get your question. why dont you just use 

Well, what have you expected?
Inside class Mob, field icon is indeed = "guy.png"!

If you need to access parent class Atom's fields, you have to use statement super :
super.icon = "";

Here's your code using super :

class Atom {
  String icon = "";
  float x, y;

  Atom(float xx, float yy) {
    x = xx;
    y = yy;

    atoms.add(this);

    if ( !icon.equals("") ) {
      print("Atom's icon: \t");
      println(icon);              // <- Won't be blank

      PImage img = loadImage(icon);
      image(img, x, y);

      bounds[2] = img.width;
      bounds[3] = img.height;
    }
  }
}

class Mob extends Atom {
  String icon = "guy.png";
  //The problem is if the variable is initialized like this in Atom() it will read icon as ""

  Mob(float x, float y) {
    super(x, y);

    print("Mob's  icon:\t");
    println(icon);           // <- Will be "guy.png"
    print("super.icon: \t");
    println(super.icon);     // <- Will be blank!!!
  }
}

void setup() {
  size(600, 600);
  new Mob(50, 50);
  exit();
}

final static List
               
                <Atom> atoms = 
                new 
                ArrayList();

                final 
                static 
                int[] bounds = 
                new 
                int[5];

               

Here's your child class Mob modified to use inherited field icon:

class Mob extends Atom {

  Mob(float x, float y, String iconName) {
    super(x, y);
    icon = iconName;

    println("icon -> \t\t" + icon);
  }
}

Since child class Mob is gonna inherent all of parent class Atom's fields anyways,
(in this case -> icon, x, y),
it's illogical to overshadow them, by re-declaring them inside Mob again!

Doing so, makes 2 field variables w/ same name,
which needs to be differentiated from each other by the use of super and this!

To test the modified class, within function setup(),
for example, use instead -> new Mob(50, 50, "guy.png");

In OOP you CAN'T access child class attributes or methods from the parent class. This is true for C++ as well as Java and any hack programming that enables this is bad practice.

These comments made in the previous replies are all valid especially

Since child class Mob is gonna inherent all of parent class Atom's fields anyways, (in this case icon)
it's illogical to overshadow it, re-declaring it inside Mob again!

Doing so, makes 2 field variables w/ same name,
which needs to be differentiated from each other by the use of super and this!

In your example the Mob class there should be no attribute called icon since it is not needed. In general it is very bad practice to have attributes in a child class with the same name as those in the parent class.

To assign a particular value to icon that is different between the two classes then initialise it inside the constructor because the parent constructor is always called before child constructor. See this code

1. class Atom {
2.   String icon;
3. 
   
4.   Atom(float _x, float _y) {
5.     x=_x;
6.     y=_y;
7.     icon="";
8.     atoms.add(this);
9.     if (!icon.equals("")) {
10.       println(icon);                               //Will be blank
11.       PImage img=loadImage(icon);
12.       image(img, x, y);
13.       bounds[2]=img.width;
14.       bounds[3]=img.height;
15.     }
16.   }
17. 
    
18.   class Mob extends Atom {
19.     Mob(float _x, float _y) {
20.       super(_x, _y);
21.       // now overwrite the "" set by the parent constructor
22.       icon="guy.png";
23.       println(icon);
24.     }
25.   }
26. 
    
27.   void setup() {
28.     size(600, 600);
29.     new Mob(50, 50);
30.     noLoop();
31.   }
32. 
    
33.   void draw() {
34.   }

See the problem is that in the Atom constructor function I need to have the Mobs variables loaded. And in the mob constructor function I can't set the va riables before calling super. So my workaround is going to be to call the constructor function then set the variables and then to make a New() function that handles the stuff my constructor class was going to handle.  Now my problem is that unless I want to call New() in all my constructor functions is there a easy way to wait until the thread is completed before executing a block of code? 

In OOP inheritance is  used to describe the 'is kind of' relationship between classes. So if we have 2 classes A and B and class B inherits (extends) from class A then the following statement is true
B is kind of A

Real examples would include
A                   B
Fruit          Apple
Animal       Tiger
Vehicle      Car

In all these cases B is a kind of A is true so inheritance would be appropriate.

In your program is Mob a kind of Atom?

If the answer is no then you should not be using inheritance. If the answer is yes and the parent class needs to access child class attributes or methods then they should be in the parent class instead.

Yes the mob is definitely a atom. The way I have my classes setup is that everything that requires the ability to trigger collisions and/or the ability to move would derive from the Atom class. Mobs will be the people of the world, which will need the ability to move and trigger collisions. So yes the Mob archetype should be derived from the Atom archetype. The reason why I wanted the mobs variables in the Atom's constructor is so that I could run only the code that is optimal to the specific class, with respect to the specific variables activated. I know now that in processing that that is just not possible in the constructor class [which is dumb], in other languages the super function is not the first thing that has to be called meaning I can change variables before I call the constructors called. I don't know how you thought I didn't know what Object Orient Programming means,

That is exactly what I ended up doing thanks though.