Ideas:

How can you possibly expect to merge these sketches without making them run separately first?
If they depend on classes contained in the other, then that is one thing - but there is no class Grow, for instance.

Generally, you would combine the setup(), draw(), mousePressed(), etc. functions.
In your case, you have two different size() calls: one with (500, 500) and one with (400, 400).
Similarly, you have background(0) and background(100).

You first must make the sketches compatible, then simply extract various parts and insert them into their corresponding parts in the other sketch.

Some notes:

Your first sketch is missing a " }" character at the end.
Go to Edit > Auto Format; it can make your code easier to read.

Thanks for your comments, I copied part of the wrong sketch to the forum (the one that I was working on to merge previously). I'll fix the first one up now. 

Here is a working one, and I have changed the size and background of the second sketch so they match up:

Also, here is the redone second sketch. I changed new cell to kaleidoscope - I'm guessing I am able to name the array after this state, since that's what I'm copying over, not the original empty 'healthy' cell??

I'm on it.

done.

1. //
2. // The whole program has to parts:
3. // 1st part: viruses and cell,
4. // 2nd part: kaleidoscope replaces
5. // cell, kaleidoscopes can be added.
6. //
7. // This pattern can be seen throughout
8. // the program.
9. //
10. // 1st part: viruses and cell
11. Disease[] d = new Disease[55]; // viruses
12. HealthyCell health;            // cell
13. //
14. // 2nd part
15. ArrayList<kaleidoscope> kal;
16. boolean isMoving;
17. kaleidoscope selectedkaleidoscope;
18. //
19. void setup() {
20.   // general init
21.   size(500, 500);
22.   smooth();
23.   //
24.   // init 1st part: viruses and cell
25.   for (int i = 0; i < d.length; i++) {
26.     float x = random(0, 15);
27.     float y = map(i, 0, d.length, -100, height-200);
28.     d[i] = new Disease(30, x, y);
29.     health = new HealthyCell(380, 380, 200);
30.   } // for
31.   // 
32.   // init 2nd part : kaleidoscope
33.   kal = new ArrayList<kaleidoscope>();
34.   selectedkaleidoscope = null;
35. } // func
36. //
37. void draw() {
38.   // general
39.   background(0);
40.   // 1st part
41.   health.display();
42.   for (int i = 0; i < d.length; i++) {
43.     d[i].display();
44.     d[i].move();
45.     if (d[i].intersect(health)) {
46.       d[i].attach();
47.     } // if
48.   } // for
49.   // 2nd part
50.   // paint kaleidoscopes
51.   for (kaleidoscope k: kal) {
52.     k.draw();
53.   } // for
54.   // add kaleidoscope
55.   if (isMoving & selectedkaleidoscope!= null) {
56.     PVector motion = new PVector(mouseX - pmouseX, mouseY - pmouseY);
57.     selectedkaleidoscope._pos.add(motion);
58.   } // if
59. } // func
60. //
61. void mousePressed() {
62.   // for 2nd part
63.   PVector mousePos = new PVector(mouseX, mouseY);
64.   for (kaleidoscope k: kal) {
65.     if (k.isMouseOver(mousePos)) {
66.       kal.add(new kaleidoscope(k._pos.x, k._pos.y));
67.       selectedkaleidoscope = kal.get(kal.size() - 1);
68.       break;
69.     }
70.   } // for
71.   isMoving = true;
72. } // func
73. //
74. void mouseReleased() {
75.   // for 2nd part
76.   isMoving = false;
77.   selectedkaleidoscope = null;
78. } // for
79. //////////////////////////////////////
80. // All classes
81. /////////////////////////////////////
82. class Disease {
83.   // for 1st part
84.   float s;
85.   float x;
86.   float y;
87.   float xIncrement = 5.0;
88.   float yIncrement = 5.01;
89.   float d;
90.   //this determines whether the cell is attached to the health cell or not
91.   boolean attached = false;
92.   Disease (float d, float tempX, float tempY) {
93.     d = s;
94.     xIncrement = tempX;
95.     yIncrement = tempY;
96.     x = 40;
97.     y = 40;
98.   }
99.   void move () {
100.     //if I am not attached to the helth cell
101.     if (attached == false) {
102.       float d = dist(mouseX, mouseY, x, y);
103.       d = constrain(d, 0, 50);
104.       float speed = map(d, 0, 49, 0.2, 0.001);
105.       xIncrement += speed;
106.       yIncrement += speed-0.01;
107.       x = noise(xIncrement)*width;
108.       y = noise(yIncrement)*height;
109.     }
110.     else {
111.       //get it to do the stuff that attaches it to the healthy cell
112.       //"constrain" it within the cell
113.       //move slower
114.       float speed = 0.005;
115.       xIncrement += speed;
116.       yIncrement += speed-0.001;
117.       //instead of being able to move anywhere one the screen move only around the cell area
118.       //i.e. move to the top of the circle then constrict the noise to the diameter of the health cell
119.       y = (health.y-health.diam/2) +  noise(yIncrement)*health.diam;
120.       x = (health.x-health.diam/2) +  noise(xIncrement)*health.diam;
121.       fill(0, 255, 0);
122.     }
123.   }
124.   void attach() {
125.     //speed = 0;
126.     //y = 10;
127.     //changes the attached variable to true
128.     if (!attached) {
129.       // tell the cell it got one virus more
130.       health.cellCount++;
131.       attached = true;
132.     }
133.   }
134.   boolean intersect(HealthyCell tempH) {
135.     // Calculate distance
136.     float distance = dist(x, y, tempH.x, tempH.y);
137.     // Compare distance to sum of radius we need to divide the diameter by 2 to get the radius
138.     if (distance < d/2 + tempH.diam/2) {
139.       return true;
140.     }
141.     else {
142.       return false;
143.     }
144.   }
145.   void display () {
146.     noStroke();
147.     stroke(200);
148.     fill(30);
149.     ellipse(random(x, x+3), random(y, y+3), s-5, s-5);
150.   } // method
151. } // class
152. /////////////////
153. class HealthyCell {
154.   // for 1st part
155.   float x;
156.   float y;
157.   int diam;
158.   float angle = 0.0;
159.   float offset = 60;
160.   float scalar = 30;
161.   float speed = 0.05;
162.   // health data
163.   boolean bHealthy;
164.   int cellCount;
165.   HealthyCell (float tempX, float tempY, int d) {
166.     x = tempX;
167.     y = tempY;
168.     diam = d;
169.     cellCount = 0;
170.     bHealthy = true;
171.   }
172.   void display() {
173.     strokeWeight(5);
174.     // if too many viruses it gets ill
175.     if (cellCount > 15) {
176.       if (bHealthy) {
177.         println ("got ill");
178.       }
179.       bHealthy=false;
180.     }
181.     // if healthy
182.     if (bHealthy) {
183.       // if healthy border is gray
184.       stroke(55);
185.       fill(50);
186.       ellipse(x, y, diam, diam);
187.     } // if
188.     else {
189.       // start one kaleidoscope
190.       kal.add(new kaleidoscope(x, y));
191.     } // else
192.   } // method
193.   //
194. } // class
195. //////////////////////
196. class kaleidoscope {
197.   // for 2nd part
198.   PVector _pos;
199.   int _radius = 200;
200.   kaleidoscope (float x, float y) {
201.     _pos = new PVector(x, y);
202.   }
203.   void draw() {
204.     int num = 50;
205.     float[] x= new float[num]; //x value
206.     float[] y= new float[num]; //y value
207.     float[] a= new float[num]; //rate of growth
208.     color[] c= new color[num]; //colour
209.     for (int i=0; i< num;i++) {
210.       x[i] = random(200);
211.       y[i] = i* (5/num);
212.       a[i] = random(3, 6);
213.       c[i] = color(int(random(255)), 50, 100, 50);
214.     }
215.     for (int i=0; i< num; i++) {
216.       stroke(random(255), 50, 50);
217.       fill(c[i]);
218.       ellipse(_pos.x, _pos.y, _radius-x[i], _radius-x[i]);
219.       x[i]=x[i]+ a[i];
220.       if (x[i]> 200) {
221.         x[i] = -100;
222.       }
223.     }
224.   }
225.   boolean isMouseOver(PVector mouse) {
226.     if (_pos.dist(mouse) <= _radius) {
227.       return true;
228.     }
229.     else {
230.       return false;
231.     }
232.   }
233. } // class
234. //

I swear everything you touch turns to gold!!!!

Well, I'am not happy with it.

little improvement (you had e.g. once & instead of && )

1. //
2. // The whole program has to parts:
3. // 1st part: viruses and cell,
4. // 2nd part: kaleidoscope replaces
5. // cell, kaleidoscopes can be added.
6. //
7. // This pattern can be seen throughout
8. // the program.
9. //
10. // general part
11. // is the 2nd part reached?
12. boolean part2IsReached = false;
13. // 1st part: viruses and cell
14. Disease[] d = new Disease[55]; // viruses array
15. HealthyCell health;            // cell
16. //
17. // 2nd part
18. ArrayList<kaleidoscope> kal;
19. boolean isMoving;
20. kaleidoscope selectedkaleidoscope;
21. //
22. void setup() {
23.   // general init
24.   size(500, 500);
25.   smooth();
26.   println ("Starting."); 
27.   //
28.   // init 1st part: viruses and cell
29.   for (int i = 0; i < d.length; i++) {
30.     float x = random(0, 15);
31.     float y = map(i, 0, d.length, -100, height-200);
32.     d[i] = new Disease(30, x, y);
33.   } // for
34.   // one big cell:
35.   health = new HealthyCell(380, 380, 200);
36.   // 
37.   // init 2nd part : kaleidoscope
38.   kal = new ArrayList<kaleidoscope>();
39.   selectedkaleidoscope = null;
40. } // func
41. //
42. void draw() {
43.   // general
44.   background(0);
45.   // 1st part drawing
46.   health.display();
47.   for (int i = 0; i < d.length; i++) {
48.     d[i].display();
49.     d[i].move();
50.     if (d[i].intersect(health)) {
51.       d[i].attach();
52.     } // if
53.   } // for
54.   // 2nd part drawing
55.   // paint kaleidoscopes
56.   for (kaleidoscope k: kal) {
57.     k.draw();
58.   } // for
59.   // add kaleidoscope
60.   if ((isMoving) && (selectedkaleidoscope!= null)) {
61.     PVector motion = new PVector(mouseX - pmouseX, mouseY - pmouseY);
62.     selectedkaleidoscope._pos.add(motion);
63.   } // if
64. } // func
65. //
66. void mousePressed() {
67.   // for 2nd part
68.   PVector mousePos = new PVector(mouseX, mouseY);
69.   for (kaleidoscope k: kal) {
70.     if (k.isMouseOver(mousePos)) {
71.       kal.add(new kaleidoscope(k._pos.x, k._pos.y));
72.       selectedkaleidoscope = kal.get(kal.size() - 1);
73.       break;
74.     }
75.   } // for
76.   isMoving = true;
77. } // func
78. //
79. void mouseReleased() {
80.   // for 2nd part
81.   isMoving = false;
82.   selectedkaleidoscope = null;
83. } // for
84. //
85. Disease[] clearViruses () {
86.   // when coming from part 1 to 2 this shortens
87.   // viruses array the hard way: only non attached
88.   // stay alive.
89.   Disease[] bufferNew = new Disease[0]; // viruses array
90.   for (int i = 0; i < d.length; i++) {
91.     if (!d[i].attached) {
92.       // take over
93.       bufferNew=(Disease[])append(bufferNew, d[i]);
94.     }
95.   } // for
96.   return bufferNew;
97. } // func
98. //
99. //////////////////////////////////////
100. // All classes
101. /////////////////////////////////////
102. class Disease {
103.   // for 1st part
104.   float s;
105.   float x;
106.   float y;
107.   float xIncrement = 5.0;
108.   float yIncrement = 5.01;
109.   float d;
110.   //this determines whether the cell is attached to the health cell or not
111.   boolean attached = false;
112.   Disease (float d, float tempX, float tempY) {
113.     d = s;
114.     xIncrement = tempX;
115.     yIncrement = tempY;
116.     x = 40;
117.     y = 40;
118.   }
119.   void move () {
120.     //if I am not attached to the helth cell
121.     if (attached == false) {
122.       float d = dist(mouseX, mouseY, x, y);
123.       d = constrain(d, 0, 50);
124.       float speed = map(d, 0, 49, 0.2, 0.001);
125.       xIncrement += speed;
126.       yIncrement += speed-0.01;
127.       x = noise(xIncrement)*width;
128.       y = noise(yIncrement)*height;
129.     }
130.     else {
131.       //get it to do the stuff that attaches it to the healthy cell
132.       //"constrain" it within the cell.
133.       //Paint this only in part 1.
134.       if (!part2IsReached) {
135.         //move slower
136.         float speed = 0.005;
137.         xIncrement += speed;
138.         yIncrement += speed-0.001;
139.         //instead of being able to move anywhere one the screen move only around the cell area
140.         //i.e. move to the top of the circle then constrict the noise to the diameter of the health cell
141.         y = (health.y-health.diam/2) +  noise(yIncrement)*health.diam;
142.         x = (health.x-health.diam/2) +  noise(xIncrement)*health.diam;
143.         fill(0, 255, 0);
144.       }
145.     }
146.   } // method
147.   //
148.   void attach() {
149.     //changes the attached variable to true
150.     if (!attached) {
151.       // tell the cell it got one virus more
152.       health.cellCount++;
153.       // attach virus
154.       attached = true;
155.     }
156.   }
157.   boolean intersect(HealthyCell tempH) {
158.     // Calculate distance
159.     float distance = dist(x, y, tempH.x, tempH.y);
160.     // Compare distance to sum of radius we need to divide the diameter by 2 to get the radius
161.     if (distance < d/2 + tempH.diam/2) {
162.       return true;
163.     }
164.     else {
165.       return false;
166.     }
167.   }
168.   void display () {
169.     // paint if it's part 1 (or when part 2 only unattached viruses)
170.     if (( part2IsReached && !attached ) ||
171.       (!part2IsReached) ) {
172.       //noStroke();
173.       stroke(200);
174.       fill(30);
175.       ellipse(random(x, x+3), random(y, y+3), s-5, s-5);
176.     } // if
177.   } // method
178. } // class
179. /////////////////
180. class HealthyCell {
181.   // for 1st part
182.   float x;
183.   float y;
184.   int diam;
185.   float angle = 0.0;
186.   float offset = 60;
187.   float scalar = 30;
188.   float speed = 0.05;
189.   // health data
190.   boolean bHealthy;
191.   int cellCount;
192.   HealthyCell (float tempX, float tempY, int d) {
193.     x = tempX;
194.     y = tempY;
195.     diam = d;
196.     cellCount = 0;
197.     bHealthy = true;
198.   }
199.   void display() {
200.     strokeWeight(5);
201.     // if too many viruses it gets ill
202.     if (cellCount > 50) {
203.       if (bHealthy) {
204.         // this is run only once (when part 1 goes part 2)
205.         println ("got ill");
206.         part2IsReached=true;
207.         println(d);
208.         d=clearViruses();
209.         println(d);
210.         bHealthy=false;
211.       }
212.     }
213.     // if healthy
214.     if (bHealthy) {
215.       // part 1
216.       // if healthy border is gray
217.       stroke(55);
218.       fill(50);
219.       ellipse(x, y, diam, diam);
220.     } // if
221.     else {
222.       // part 2
223.       // start one kaleidoscope
224.       kal.add(new kaleidoscope(x, y));
225.     } // else
226.   } // method
227.   //
228. } // class
229. //////////////////////
230. class kaleidoscope {
231.   // for 2nd part
232.   PVector _pos;
233.   int _radius = 200;
234.   kaleidoscope (float x, float y) {
235.     _pos = new PVector(x, y);
236.   }
237.   void draw() {
238.     int num = 50;
239.     float[] x= new float[num]; //x value
240.     float[] y= new float[num]; //y value
241.     float[] a= new float[num]; //rate of growth
242.     color[] c= new color[num]; //colour
243.     for (int i=0; i< num;i++) {
244.       x[i] = random(200);
245.       y[i] = i* (5/num);
246.       a[i] = random(3, 6);
247.       c[i] = color(int(random(255)), 50, 100, 50);
248.     } // for
249.     for (int i=0; i< num; i++) {
250.       stroke(random(255), 50, 50);
251.       fill(c[i]);
252.       ellipse(_pos.x, _pos.y, _radius-x[i], _radius-x[i]);
253.       x[i]=x[i]+ a[i];
254.       if (x[i]> 200) {
255.         x[i] = -100;
256.       }
257.     } // for
258.   } // method
259.   //
260.   boolean isMouseOver(PVector mouse) {
261.     if (_pos.dist(mouse) <= _radius) {
262.       return true;
263.     }
264.     else {
265.       return false;
266.     }
267.   } // method
268. } // class
269. //