Below is an example of such a simulation in it's most basic form. You have an abstract class Animal which holds most of the functionality. Then you have two animal classes Giraffe and Tiger, each with their own bodies and heads through interfaces. Here Giraffes are red-circles and Tigers are blue-rects. Because of the abstract Animal class and the interfaces, it becomes possible to create Mix animals which have a 'random' Head and Body. For the Mix animal the Head and Body is randomly chosen from it's parents. This is a quick sketch so there are many shortcuts with regard to movement, population control etc. But hopefully it will give you an idea how it could be done. You can add as many animals, heads and bodies as you want.

Code Example

1. ArrayList <Animal> kingdom = new ArrayList <Animal> ();
2. int maxPopulation = 200;
3.  
4. void setup() {
5.   size(1280, 720);
6.   smooth();
7.   rectMode(CENTER);
8.   addRandomAnimals(20);
9.   textSize(50);
10. }
11.  
12. void draw() {
13.   background(255);
14.   for (int i=kingdom.size()-1; i>=0; i--) {
15.     Animal a = kingdom.get(i);
16.     a.update();
17.     a.breed();
18.     a.display();
19.   }
20.   fill(0);
21.   text(kingdom.size(), 10, 50);
22. }
23.  
24. void addRandomAnimals(int num) {
25.   for (int i=0; i<num; i++) {
26.     PVector loc = new PVector(random(width), random(height));
27.     float rnd = random(1);
28.     if (rnd<0.5) { kingdom.add(new Giraffe(loc)); }
29.     else { kingdom.add(new Tiger(loc)); }
30.   }
31. }
32. abstract class Animal {
33.   PVector loc, vel;
34.   Head head;
35.   Body body;
36.   int lastBreeded;
37.  
38.   Animal(PVector loc) {
39.     this.loc = loc.get();
40.     vel = new PVector(random(-1,1), random(-1,1));
41.   }
42.  
43.   void update() {
44.     loc.add(vel);
45.     if (loc.x <= 0 || loc.x >= width)  { vel.x *= -1; }
46.     if (loc.y <= 0 || loc.y >= height) { vel.y *= -1; }
47.   }
48.  
49.   void breed() {
50.     if (kingdom.size() < maxPopulation && millis() - lastBreeded > 3000) {
51.       for (int i=kingdom.size()-1; i>=0; i--) {
52.       Animal a = kingdom.get(i);
53.         if (!a.equals(this)) {
54.           if (loc.dist(a.loc) < 20) {
55.             Animal child = new Mix(loc, this, a);
56.             kingdom.add(child);
57.             lastBreeded = millis();
58.             a.lastBreeded = millis();
59.             child.lastBreeded = millis();
60.           }
61.         }
62.       }
63.     }
64.   }
65.  
66.   void display() {
67.     body.display(loc);
68.     head.display(loc);
69.   }
70. }
71.  
72. class Giraffe extends Animal {
73.   Giraffe(PVector loc) {
74.     super(loc);
75.     head = new GiraffeHead();
76.     body = new GiraffeBody();
77.   }
78. }
79.  
80. class Tiger extends Animal {
81.   Tiger(PVector loc) {
82.     super(loc);
83.     head = new TigerHead();
84.     body = new TigerBody();
85.   }
86. }
87.  
88. class Mix extends Animal {
89.   Mix(PVector loc, Animal father, Animal mother) {
90.     super(loc);
91.     if (random(1)<0.5) { head = father.head; } else { head = mother.head; }
92.     if (random(1)>0.5) { body = father.body; } else { body = mother.body; }
93.   }
94. }
95.  
96. interface Body {
97.   void display(PVector loc);
98. }
99.  
100. class GiraffeBody implements Body{
101.   void display(PVector loc) {
102.     fill(255, 0, 0);
103.     ellipse(loc.x, loc.y+20, 30, 30);
104.   }
105. }
106.  
107. class TigerBody implements Body{
108.   void display(PVector loc) {
109.     fill(0, 0, 255);
110.     rect(loc.x, loc.y+20, 30, 30);
111.   }
112. }
113.  
114. interface Head {
115.   void display(PVector loc);
116. }
117.  
118. class GiraffeHead implements Head{
119.   void display(PVector loc) {
120.     fill(255, 0, 0);
121.     ellipse(loc.x, loc.y, 20, 20);
122.   }
123. }
124.  
125. class TigerHead implements Head{
126.   void display(PVector loc) {
127.     fill(0, 0, 255);
128.     rect(loc.x, loc.y, 20, 20);
129.   }
130. }

An individual animal shouldn't have the power to kill the whole kingdom. Only god, I mean the programmer, is allowed to determine this.

Just like with update(), breed() and display() you can simply add a call to the die() method in the list. The kingdom list already moves backwards to allow adding and removing from it while running it. Moving forwards (like you do normally) doesn't play nice with adding and removing while running the list. Anyway, so the die() call is easy. Inside the Animal class you can check the time that has passed since it's creation. Store the birth millis() in an int. Target it for termination on it's 20.000th milli-birthday. Of course now it's easy to vary the life's length of individual Animals.

p.s. instead of the remove(this) route in die, you could also create a God class that checks Animals life/death and removes them from the kingdom. But in my opinion that's only extra code. I'd say you don't really need a God class, unless you want to introduce some other divine intervention in your simulation.

The DIE code (only showing adapted code areas)

1. void draw() {
2.   for (int i=kingdom.size()-1; i>=0; i--) {
3.     Animal a = kingdom.get(i);
4.     a.update();
5.     a.breed();
6.     a.die(); // add call to die for each Animal in the kingdom
7.     a.display();
8.   }
9. }
10.  
11. abstract class Animal {
12.   int startTime; // add this variable to the Animal class
13.  
14.   Animal(PVector loc) {
15.     startTime = millis(); // set it when the Animal is created
16.   }
17.  
18.   // when the 20.000 milliseconds (20 seconds) has passed, DIE! ;-)
19.   void die() {
20.     if (millis()-startTime > 20000) {
21.       kingdom.remove(this);
22.     }
23.   }
24. }

Your current check doesn't make sense and can never be true.

You need to check if the animals are of a different gender aka the booleans are not equal.

1.   if(male != a.male){

I get it now, and that statement is saying if our animal is male(true) and intersects with one that is Not a male(false) then we can run our breed

Or vice versa. The statement checks for inequality, it doesn't care which way.

It will return true if the genders are not equal (male-female or female-male).
It will return false if the genders are equal (male-male or female-female).