There are quite a few issues with this code. To make this run...

1. Move this line bulletE.add(new Bullet(x, y, 1)); into the constructor of Enemy. It is not a variable. It is a method to add an object to an arraylist.
2. Remove the void before the constructor in the class Bullet: void Bullet (float _x, float _y, float _z). Constructors do not have a return type. They are used to create objects.
3. You will get an error on this line: bulletE.get(i).run(); To fix this use a typed ArrayList. Change the ArrayList in the Enemy class to this: ArrayList <Bullet> bulletE = new ArrayList <Bullet> ();
4. You will get an error on this line: break; Remove all the code: else { break; }
5. Now your code will run. But there is a hidden problem. You are adding three enemies per draw(). Add println(enemy.size()); to draw() to see the number of enemies grow steadily. You probably want to move   addEnemy(dif); to setup() or add a conditional to max out the number of enemies.
   

Once the code runs normally, I only see a blue circle, so I don't know your further intentions.

ah... I am too late....

1. float xpos = 250;
2. int dif = 3;
3. boolean start = false;
4. boolean hit = false;
5. ArrayList enemy = new ArrayList();
6. void addEnemy(int s) {
7.   for (int a = 0; a < s; a++) {
8.     enemy.add(new Enemy(random(500)));
9.   }
10. }
11. void setup() {
12.   size (500, 500);
13.   smooth();
14.   addEnemy(dif);
15. }
16. void draw() {
17.   //background (255);
18.   if (hit) {
19.     background (125, 125, 125);
20.   }
21.   else {
22.     background(255);
23.   }
24.   Enemy myTest=(Enemy) enemy.get(0);
25.   println(myTest.x);
26.   myTest.bulletE.add(new Bullet(7.0, 12.0, 1.0));
27.   fill (0, 0, 255);
28.   ellipseMode(CENTER);
29.   ellipse (xpos, 250, 50, 50);
30. }
31. void keyPressed() {
32.   if (key == CODED) {
33.     if (keyCode == LEFT) {
34.       xpos-=10;
35.       if (xpos <= 25) {
36.         xpos = 25;
37.       }
38.     }
39.     else if (keyCode == RIGHT) {
40.       xpos+=10;
41.       if (xpos >= 475) {
42.         xpos = 475;
43.       }
44.     }
45.   }
46. }
47. class Bullet {
48.   float x;
49.   float y;
50.   float speed = 5;
51.   float direction;
52.   //
53.   Bullet (float _x, float _y, float _z) {
54.     x = _x;
55.     y = _y;
56.     direction = _z;
57.   }
58.   void run() {
59.     display();
60.     movement();
61.   }
62.   void display() {
63.     fill (0, 0, 255);
64.     ellipse (x, y, 5, 5);
65.   }
66.   void movement() {
67.     y += speed * direction;
68.   }
69. } // class
70. // ===============================================================
71. class Enemy {
72.   float x;
73.   float y = 0;
74.   float speed = 2.5;
75.   float timer = 200;
76.   ArrayList<Bullet> bulletE;
77.   Enemy (float _x) {
78.     x = _x;
79.     bulletE = new ArrayList();
80.   }
81.   void run() {
82.     display();
83.     movement();
84.     shoot();
85.     timer--;
86.   }
87.   void display() {
88.     fill(0);
89.     ellipse (x, y, 50, 50);
90.   }
91.   void movement() {
92.     y += speed;
93.   }
94.   void shoot() {
95.     if (timer <= 0) {
96.       for (int i = bulletE.size()-1; i >= 0; i--) {
97.         bulletE.get(i).run();
98.         if (bulletE.get(i).y > height ) {
99.           bulletE.remove(i);
100.         }
101.         else if ((bulletE.get(i).x >= xpos - 25) && (bulletE.get(i).x <= xpos + 25)) {
102.           if (bulletE.get(i).y >= 250) {
103.             bulletE.remove(i);
104.             hit();
105.           }
106.         }
107.       } // for
108.       timer = 200;
109.     }
110.     else {
111.       // break;
112.     }
113.   }
114.   void hit() {
115.     hit = true;
116.   }
117. }

ah, if nothing is happening then I need to rethink the code. I wasn't sure if what I was doing was right or not as I was doing it but I couldn't check if I was heading in the right direction without running it and seeing what was happening.

Search the forum and openprocessing for examples.

Both enemies and bullets seem to be flying around here a lot.

I took a closer look

1. float xpos = 250;
2. int dif = 3;
3. boolean start = false;
4. boolean hit = false;
5. ArrayList<Enemy> enemy = new ArrayList();
6. //
7. void addEnemy(int s) {
8.   for (int a = 0; a < s; a++) {
9.     enemy.add(new Enemy(random(500)));
10.   }
11. }
12. void setup() {
13.   size (500, 500);
14.   smooth();
15.   addEnemy(dif);
16. }
17. void draw() {
18.   //background (255);
19.   if (hit) {
20.     background (125, 125, 125);
21.   }
22.   else {
23.     background(255);
24.   }
25.   for (Enemy myTestEnemy : enemy ) {
26.     // println(myTestEnemy.x);
27.     // random
28.     if (random(100)>98) {
29.       // fire!
30.       myTestEnemy.bulletE.add(new Bullet(myTestEnemy.x, myTestEnemy.y, 1.0));
31.     }
32.     myTestEnemy.run();
33.   }
34.   // show hero
35.   fill (0, 0, 255);
36.   ellipseMode(CENTER);
37.   text("Hero", xpos-16, 250-40);
38.   ellipse (xpos, 250, 50, 50);
39. }
40. void keyPressed() {
41.   if (key == CODED) {
42.     if (keyCode == LEFT) {
43.       xpos-=10;
44.       if (xpos <= 25) {
45.         xpos = 25;
46.       }
47.     }
48.     else if (keyCode == RIGHT) {
49.       xpos+=10;
50.       if (xpos >= 475) {
51.         xpos = 475;
52.       }
53.     }
54.   }
55. }
56. // ==========================================================
57. class Bullet {
58.   float x;
59.   float y;
60.   float speed = 5;
61.   float direction;
62.   //
63.   Bullet (float _x, float _y, float _z) {
64.     x = _x;
65.     y = _y;
66.     direction = _z;
67.   }
68.   void run() {
69.     display();
70.     movement();
71.   }
72.   void display() {
73.     fill (0, 0, 255);
74.     ellipse (x, y, 15, 5);
75.   }
76.   void movement() {
77.     y += speed * direction;
78.   }
79. } // class
80. //
81. // ===============================================================
82. //
83. class Enemy {
84.   float x;
85.   float y = 40;
86.   float speed = .45;
87.   float timer = 200;
88.   ArrayList<Bullet> bulletE;
89.   Enemy (float _x) {
90.     x = _x;
91.     bulletE = new ArrayList();
92.   }
93.   void run() {
94.     display();
95.     movement();
96.     shoot();
97.     timer--;
98.   }
99.   void display() {
100.     fill(0);
101.     ellipse (x, y, 50, 50);
102.   }
103.   void movement() {
104.     y += speed;
105.   }
106.   void shoot() {
107.     //if (timer <= 0) {
108.     for (int i = bulletE.size()-1; i >= 0; i--) {
109.       Bullet mybulletE = bulletE.get(i);
110.       mybulletE.run();
111.       if (mybulletE.y > height ) {
112.         bulletE.remove(i);
113.       }
114.       else if ((mybulletE.x >= xpos - 25) && (mybulletE.x <= xpos + 25)) {
115.         if (mybulletE.y >= 250) {
116.           bulletE.remove(i);
117.           hit();
118.         }
119.       }
120.     } // for
121.     timer = 200;
122.     /*}
123.      else {
124.      // break;
125.      }*/
126.   } // func
127.   void hit() {
128.     hit = true;
129.   }
130. }

Thank you =] I'll study the code and try to replicate the result. I have a few questions about the changes that you made, I've looked through the reference but I've never seen an arraylist created like  ArrayList<Enemy> enemy = new ArrayList(); before, what is purpose of the "<Enemy>" part and also in the  (Enemy myTestEnemy : enemy ) what is the meaning of the colon?

both very good questions!  

it's stuff I learned here in the forum.

since processing is (based on) JAVA and Java got changed in these things, you can use these new stuff in processing as well (although it's not in the processing help or examples)

What it means?

Well, others here in the forum could explain it much better than me, but:

First question:

1. 
   

   ArrayList<Enemy> enemy = new ArrayList();

   
   

This says the objects in your arraylist are of type Enemy (thus <Enemy> ).
Therefore when you get an objects later via get out of your arraylist, no need to cast the object coming out (the arraylist knows the type already).

Second question:

1. for (Enemy myTestEnemy : enemy )

this is a new form of a for loop.
You have for (int i=0...etc.  and loop via i) and have then

1. Enemy myTestEnemy = ...get(i);

That here is the same thing but in one line saying:
do a for loop over all objects in arraylist enemy (thus the : sign) and give each object of the arraylist one after another into object myTestEnemy (which is of type Enemy).
So you can work with myTestEnemy then.

Hope this helps.

Greetings, Chrisir   

It does, thank you very much =]