Question

Write a program to help answer questions like the following: Suppose the species Klingon ox has a population of 100 and a growth rate of 15 percent, and the species elephant has a population of 10 and a growth rate of 35 percent. How many years will it take for the elephant population to exceed the Klingon ox population? You can assume that this will happen within 10 years.

Use the version of the class Species from Sakai’s Week 7 Source Code folder as your starting point – download it to your Java programs folder. Your program will ask for the data on both species and will respond by telling you how many years it will take for the species that starts with the lower population to outnumber the species that starts with the higher population. The two species may be entered in any order, so you’ll have to figure out which is which; you might assign them to lower and upper Species variables. You can assume the populations are different to start.

The main method in this program has been set up for you to create two Species objects and run a loop with increasing future year numbers (add 1 each time) until the lower population species outnumbers the higher population species, using the predictPopulation() method. Again, you can assume that this will happen within 10 years or not at all.

Note that it’s possible the species with the smaller population will never outnumber the other species. In this case, your program should just display a suitable message.

Hint: If the species with the lower population has a growth rate less than or equal to the species with the higher population then it will never outnumber the other species, otherwise it must outnumber it at some year in the future. You may assume that both species have growth rates greater than 0 for this exercise.

Your program must output one of the following two statements at the end; here and are the names of the two species, and is the number of years it takes for the lower one to overtake the higher one:

Species <lower> will not overtake " <higher>.
Species <lower> will overtake <higher> in <years> years.

IN JAVA:

/**
File name: YearsToOvertake.java

This program does the following:
Reads in the names, populations and growth rates for two species
and calculates the number of years it will take the one
with the lower initial population to overtake the other
or prints a message that it will never have a higher population).

Preconditions: none.

Postconditions:
Displays either the number of years it takes for the species with the
lower population to have a population greater than the other,
or a message that it will not exceed the other
species' population within ten years.
*/

public class YearsToOvertake
{
public static void main(String[] args)
{
Species s1 = new Species();
Species s2 = new Species();
Species lower = new Species(); // has lower initial population
Species higher = new Species(); // has higher initial population

// Read in two species

s1.readInput();
s2.readInput();

// Determine which has the lower initial population - if they are
// the same, assign the 1st species to "lower" and the 2nd to "higher"

/* your code to do that goes here */

// In a loop, find number of years it takes the species with the
// lower initial population to overtake the other one.
// Here are some useful variables for that loop:

int years = 1;
int nextPopulationLower;
int nextPopulationHigher;

/* write the appropriate while loop here - only go to 10 years */


years--; // Adjust years to correct value (it is 1 too many on exit from while-loop)

// If years == 10 "lower" may or may not have overtaken "higher"
// so you must do a final check.

/* write that check here and print out the appropriate statement */

}
}

Answer 1

import java.util.Scanner;

/**
 * File name: YearsToOvertake.java
 * 
 * This program does the following: Reads in the names, populations and growth
 * rates for two species and calculates the number of years it will take the one
 * with the lower initial population to overtake the other or prints a message
 * that it will never have a higher population).
 * 
 * Preconditions: none.
 * 
 * Postconditions: Displays either the number of years it takes for the species
 * with the lower population to have a population greater than the other, or a
 * message that it will not exceed the other species' population within ten
 * years.
 */

class Species {
    private String name;
    private int population;
    private double growthRate;
    public Scanner in = new Scanner(System.in);

    public void readInput() {
        System.out.println("What is the species’ name?");
        name = in.nextLine();
        System.out.println("What is the population of the species?");
        population = in.nextInt();
        while (population < 0) {
            System.out.println("Population cannot be negative.");
            System.out.println("Reenter population:");
            population = in.nextInt();
        }
        System.out.println("Enter growth rate (percent increase per year):");
        growthRate = in.nextDouble();
    }

    public void writeOutput() {
        System.out.println("Name = " + name);
        System.out.println("Population = " + population);
        System.out.println("Growth rate = " + growthRate + "%");
    }

    /*******************************************************
     * Precondition: years is a nonnegative number. Returns the projected population
     * of the calling object after the specified number of years.
     *******************************************************/
    public int projectedPopulation(int years) {
        double populationAmount = population;
        int count = years;

        while ((count > 0) && (populationAmount > 0)) {
            populationAmount = (populationAmount + (growthRate / 100) * populationAmount);
            count--;
        }
        if (populationAmount > 0)
            return (int) populationAmount;
        else
            return 0;
    }

    public void set(String newName, int newPopulation, double newGrowthRate) {
        name = newName;
        if (newPopulation >= 0)
            population = newPopulation;
        else {
            System.out.println("ERROR: using a negative population.");
            System.exit(0);
        }
        growthRate = newGrowthRate;
    }

    public String getName() {
        return name;
    }

    public int getPopulation() {
        return population;
    }

    public double getGrowthRate() {
        return growthRate;
    }

    public boolean equals(Species otherObject) {
        return ((name.equalsIgnoreCase(otherObject.name)) && (population == otherObject.population)
                && (growthRate == otherObject.growthRate));
    }
}

public class YearsToOvertake {
    public static void main(String[] args) {
        Species s1 = new Species();
        Species s2 = new Species();
        Species lower = new Species(); // has lower initial population
        Species higher = new Species(); // has higher initial population

        // Read in two species
        s1.readInput();
        s2.readInput();

        // Determine which has the lower initial population - if they are
        // the same, assign the 1st species to "lower" and the 2nd to "higher"
        if (s1.getPopulation() > s2.getPopulation()) {
            lower = s2;
            higher = s1;
        } else {
            lower = s1;
            higher = s2;
        }

        /* your code to do that goes here */

        // In a loop, find number of years it takes the species with the
        // lower initial population to overtake the other one.
        // Here are some useful variables for that loop:

        int years = 1;
        int nextPopulationLower = lower.getPopulation();
        int nextPopulationHigher = higher.getPopulation();

        /* write the appropriate while loop here - only go to 10 years */
        while (years <= 10 && (nextPopulationLower < nextPopulationHigher)) {
            nextPopulationLower = lower.projectedPopulation(years);
            nextPopulationHigher = higher.projectedPopulation(years);

            years++;
        }

        years--; // Adjust years to correct value (it is 1 too many on exit from while-loop)

        // If years == 10 "lower" may or may not have overtaken "higher"
        // so you must do a final check.

        /* write that check here and print out the appropriate statement */

        if (nextPopulationLower > nextPopulationHigher) {
            System.out.println("Species " + lower.getName() + " will overtake " + 
                    higher.getName() + " in " + years + " years.");
        } else {
            System.out.println("Species " + lower.getName() + " will not overtake " + 
                    higher.getName() + ".");            
        }
    }
}

$E Console & ㄨ吮ㄧ泳SE Egl E) !ゴ曰▼ R ▼ D AnimalTestava LinkedListjava YearsToOvertake java <terminated> YearsToOvertake Java Application] CAProgram FilesJava\idk1.8.0 73in105 106 107 198 109 110 if (s1.getPopulation() > s2.getPopulationO) lower -s2; higher - s1; What is the species name? sad What is the population of the species? 100 Enter growth rate (percent increase per year): 15 What is the species name? else { lower s1; higher - s2; 112 your code to do that goes here What is the population of the species? 30 114 115 116 // In a loop, find number of years it takes the species with the /I lower initial population to overtake the other one // Here are some useful variables for that loop Enter growth rate (percent increase per year): Species sasa will overtake sad in 8 years 118 int years1; int nextPopulationLowerlower.getPopulation); int nextPopulationHigher- higher.getPopulation); 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 /* write the appropriate while loop here - only go to 10 years while (years 10 && (nextPopulationLower<nextPopulationHigher)) [ nextPopulationLower-lower.projectedPopulation (years); nextPopulationHigher- higher projectedPopulation(years); years++ years-- // Adjust years to correct value (it is 1 too many on exit from while-loop) /I If years1 lower may or may not have overtaken higher // so you must do a final check /* write that check here and print out the appropriate statement if (nextPopulationLower > nextPopulationHigher) l else ( System.out.println( Species lower.getName will overtake higher.getName ) +in yearsyears.) System.out.println( Species + lower.gete will not overtake + higher.getName ) .);$

Hi. Please find the answer above.. In case of any doubts, you may ask in comments. You may upvote the answer if you feel i did a good work!