Java Programming Assignment IIT/IIT G Java 2018 S1 r1 - Adapted from Trish Crowther Java Programming Assignment Introduction to Information Technology/G 4478/8936 Note 1: Only use Java classes that...

1 answer below »
done


Java Programming Assignment IIT/IIT G Java 2018 S1 r1 - Adapted from Trish Crowther Java Programming Assignment Introduction to Information Technology/G 4478/8936 Note 1: Only use Java classes that are part of the standard Java SE SDK distribution! For the purpose of this assignment, you are not allowed to use any third party classes except for UCanAccess 1 if you attempt stage 4. Note 2: Familiarise yourself with the Java Style Guide at the end of this document. Note 3: All cases of plagiarism will be pursued! If in doubt, consult the Student Academic Integrity Policy http://www.canberra.edu.au/current-students/canberra- students/conduct The context for this assignment (all parts) is an examination of the growth rates of species in a given habitat. This assignment will test a student’s knowledge of and skills in writing application software for a particular task, understanding the business rules of a particular problem, coding these in a computer program, developing a graphical user interface, reading data from a text file on disk, and connecting to an SQL database from within the program. As such, the assignment requires you to integrate and synthesise what you have learnt so far, in order to design and create a correctly working solution. For this assignment, students will use the Java programming language and development will be on the Eclipse IDE platform as practised in the computer lab classes. This assignment consists of four stages, with different requirements for undergraduate students in 4478 Introduction to IT and for graduate / postgraduate students in 8936 Introduction to IT G.  Stage 1: A simple console program (no GUI)  Stage 2: The same but wrapped in a GUI  Stage 3: Input comes from a text file – read only once, then information stored in a suitable data class, array, etc.  Stage 4: Input comes from an SQL database file. 4478 IIT 8936 IIT G Part A – Stage 1 (25 marks) Part A – Stages 1 and 2 (27 marks) Part B – Stage 2 (10 marks) Part B – Stage 3 (13 marks) Part C – Stage 3 (15 marks) Part C – Stage 4 (10 marks) Bonus* – Stage 4 (up to 10 marks) *Stage 4 is a bonus stage for undergraduate students to give you a stretch target. It allows you to pick up extra marks to make up for marks lost elsewhere in the assignment, but note that you cannot achieve more than 50/50 marks. 1 http://ucanaccess.sourceforge.net/site.html IIT/IIT G Java 2018 S1 r1 - Adapted from Trish Crowther Population Calculator Preamble: A client has approached you with a request to write a software application to calculate the number of specimens in a habitat after a given number of generations, given a starting population and two different ways for the population to grow. a) The first scenario is that the number of specimens grows by a given percentage in each generation (i.e. fixed growth rate, variable number of generations) b) The second way for the population to grow is by a varying rate each generation, for ten generations. (i.e. variable growth rate, fixed number (10) of generations) In each scenario, you’re required to calculate the final population after the given number of generations has elapsed and then calculate the number of specimens that will die due to overpopulation. A Worked example: In a hypothetical habitat the growth rate of a particular species per generation is given as a percentage of its population. For example, if the number of fish in a pond at the start is four and the growth rate is 50%, after one generation there are six fish (4*1.5 or 4+4*50/100), after two generations there are nine fish (6 * 1.5) and so on. At beginning, population of the pond = 4 After generation 1, population of the pond = 4 + (4*50/100) = 6 After generation 2, population of the pond = 6 + (6*50/100) = 9 … If the number of specimens doubles in every generation, the growth rate is 100%. Note that the habitat has a limited carrying capacity (5000 for part A). Any specimens spawning over that number will die due to overpopulation. (For simplicity we assume that they die due to overpopulation only after the prescribed number of generations has elapsed.) NOTE: For simplicity we assume the population to be an integer value. Test Cases When designing and implementing software applications, it is always important to first work out how to test the program(s) and what data to use, then to code. The following test cases have been designed to systematically test different conditions in the above rules. Use these to test your program, but make sure that your program can also handle other data, including negative growth in one or more generations. IIT/IIT G Java 2018 S1 r1 - Adapted from Trish Crowther Test Description Option Starting Population Number of Generati ons Growth Rate Final Population (integer) Died (inte ger) Fixed rate (doubling); under habitat capacity F 100 5 100 3200 0 Fixed Growth (80% each generation); over habitat capacity F 200 6 80 6796 1796 Variable Growth; no growth; under habitat capacity V 10 10 0,0,0,0,0,0,0,0, 0,0 10 0 Variable Growth, under habitat capacity V 150 10 15,20,25,30,50 ,70,60,80,50,2 3746 0 Variable Growth; over habitat capacity V 100 10 100,100,80,70, 60,100,10,20,5 ,85 10038 5038 Submission Instruction Add all Java files (ending in .java) to a ZIP file. You do not need to zip the entire project folder, just the Java source file(s) (the ‘src’ folder). Submit the ZIP file via Canvas (max. size 10MB). Click the submit button to upload the zipped file and submit assignment. Stage 1: Write a simple Java program to calculate the number of fish in a pond after a number of generations. The pond has a capacity of 5000 fish. ). In Stage 1, you will be developing a Java program without a GUI. Input and output are via the console. When the program is executed, the user will first input whether the calculation is of fixed rate of growth (F) or variable rate of growth (V). Then, depending on the user input, the program will branch out to execute either Section 1 or Section 2 as follows; Section 1 (Fixed rate of growth) The program must then request the user to input the starting population, number of generations and the rate of growth. At a minimum, when your program is run, the terminal window must display (with words that explain each number) the values of the starting population, the rate of growth (as a percentage) the CAPACITY of the pool, the IIT/IIT G Java 2018 S1 r1 - Adapted from Trish Crowther number of generations the program was run for, and whether or not there is still room in the pond. If the pond becomes full, also state how many fish died from over-population. Section 2 (Variable growth rates) The program must then request the user to input the starting population and the 10 rates of growth for the consequent generations. E.g. 100 100 80 70 60 100 10 20 5 85 Step-by-Step Guide for Stage 1 1. Think about your strategy for how you will calculate the population after each generation. Is the growth rate fixed or variable? For a fixed growth rate (section 1), how many generations will the program run for? What is the final population? How many fish died? Hint: those over the capacity of the pond. For section 2, you need different rates for each generation. Different strategies are possible. Here is one: a. Use an integer array of 10 elements to store the different growth rates. b. Once the values for the growth rates have been entered by the user via the console and stored in the array, multiply the current population by the growth rate and add the resulting number to the ‘current’ population, creating the new value for the population. Note that you can’t have part of a fish! 2. Create a new Java project. 3. Add a simple Java class named Stage1. Do not add a GUI. 4. In the Stage1 class (file Stage1.java), you may put all code for the user interaction and the calculation into the main method. (You might still need to define global variables and constants outside the main method at the start of the class.) Declare and instantiate the variables that you will need for section 1 IIT/IIT G Java 2018 S1 r1 - Adapted from Trish Crowther (starting population, number of generations). For section 2 you will also need an integer array that will hold the growth rates, at the start of the main method, for example: int[] iaGrowthRate = new int[10]; Add code to read in the starting population, then the ten values for each generation’s growth rate from the console. In Java, there are different ways to do this. A recommended way is to use the Scanner class: Scanner inConsole = new Scanner(System.in); // Read the starting population System.out.println(“Enter the starting population of fish”); iStart = inConsole.nextInt(); // Ask whether the growth rate is fixed or variable System.out.println(“Enter F for fixed growth, V for variable”) cOption = inConsole.next().charAt(0); // Read the fixed growth rate iRate = inConsole.nextInt(); // Variable Growth // First growth rate for generation 1 System.out.print(“Enter the growth rate for generation one: ”); iaGrowthRate[0] = inConsole.nextInt(); Repeat (and adapt) the last two lines for the other growth rates for the next nine generations. 5. Now add the code that implements your strategy of calculating the final population of fish. 6. Finally, add two System.out.println() statements that state the final
Answered Same DayApr 13, 2020

Answer To: Java Programming Assignment IIT/IIT G Java 2018 S1 r1 - Adapted from Trish Crowther Java Programming...

Snehil answered on Apr 16 2020
140 Votes
Population Calculator/.classpath

    
    
    
Population Calculator/.project

     Population Calculator
    
    
    
    
        
             org.eclipse.jdt.core.javabuilder
            
            
        
    
    
         org.eclipse.jdt.core.javanature
    
Population Calculator/.settings/org.eclipse.jdt.core.prefs
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.8
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.en
umIdentifier=error
org.eclipse.jdt.core.compiler.source=1.8
Population Calculator/bin/com/pop/calc/PopData.class
package com.pop.calc;
public synchronized class PopData {
private String sSpeciesName;
private String sHabitat;
private int iStartingPopulation;
private int[] iaGrowthRates;
public void PopData(String, String, int, int[]);
public String getSpeciesName();
public void setSpeciesName(String);
public String getHabitat();
public void setHabitat(String);
public int getStartingPopulation();
public void setStartingPopulation(int);
public int[] getGrowthRates();
public void setGrowthRates(int[]);
}
Population Calculator/bin/com/pop/calc/Stage1.class
package com.pop.calc;
public synchronized class Stage1 {
static final int MAX_CAPACITY = 5000;
static final int NUM_GEN = 10;
public void Stage1();
public static void main(String[]);
static void calculateFixedRateGrowth(int, int, int);
static void calculateVariableRateGrowth(int, int[]);
}
Population Calculator/bin/com/pop/calc/Stage2GUI$1.class
package com.pop.calc;
synchronized class Stage2GUI$1 implements Runnable {
void Stage2GUI$1();
public void run();
}
Population Calculator/bin/com/pop/calc/Stage2GUI$2.class
package com.pop.calc;
synchronized class Stage2GUI$2 implements java.awt.event.ActionListener {
void Stage2GUI$2(Stage2GUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
Population Calculator/bin/com/pop/calc/Stage2GUI$3.class
package com.pop.calc;
synchronized class Stage2GUI$3 implements java.awt.event.ActionListener {
void Stage2GUI$3(Stage2GUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
Population Calculator/bin/com/pop/calc/Stage2GUI$4.class
package com.pop.calc;
synchronized class Stage2GUI$4 implements java.awt.event.ActionListener {
void Stage2GUI$4(Stage2GUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
Population Calculator/bin/com/pop/calc/Stage2GUI$5.class
package com.pop.calc;
synchronized class Stage2GUI$5 implements java.awt.event.ActionListener {
void Stage2GUI$5(Stage2GUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
Population Calculator/bin/com/pop/calc/Stage2GUI$6.class
package com.pop.calc;
synchronized class Stage2GUI$6 implements java.awt.event.ActionListener {
void Stage2GUI$6(Stage2GUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
Population Calculator/bin/com/pop/calc/Stage2GUI.class
package com.pop.calc;
public synchronized class Stage2GUI {
private final int MAX_POP;
private final int NUM_GEN;
private javax.swing.JFrame jFrame_MainFrame;
private javax.swing.JTextField jTextField_StartingPopulation;
private javax.swing.JTextField jTextField_NumGenerations;
private javax.swing.JTextField jTextField_FixedRate;
private javax.swing.JTextField[] jTextFieldArray_VariableGrowthRates;
private final javax.swing.ButtonGroup buttonGroup_RateChoice;
private javax.swing.JRadioButton jRadioButton_FixedGrowth;
private javax.swing.JLabel jLabel_FinalPopulationResult;
private javax.swing.JLabel jLabel_NumFishDied;
public static void main(String[]);
public void Stage2GUI();
private void initialize();
private void SelectFixedToggle(boolean);
}
Population Calculator/bin/com/pop/calc/Stage3GUI$1.class
package com.pop.calc;
synchronized class Stage3GUI$1 implements Runnable {
void Stage3GUI$1();
public void run();
}
Population Calculator/bin/com/pop/calc/Stage3GUI$2.class
package com.pop.calc;
synchronized class Stage3GUI$2 implements java.awt.event.ActionListener {
void Stage3GUI$2(Stage3GUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
Population Calculator/bin/com/pop/calc/Stage3GUI$3.class
package com.pop.calc;
synchronized class Stage3GUI$3 implements javax.swing.event.ListSelectionListener {
void Stage3GUI$3(Stage3GUI, javax.swing.JList, javax.swing.JLabel, javax.swing.JLabel, Stage3GUI$DrawingPanel);
public void valueChanged(javax.swing.event.ListSelectionEvent);
}
Population Calculator/bin/com/pop/calc/Stage3GUI$DrawingPanel.class
package com.pop.calc;
synchronized class Stage3GUI$DrawingPanel extends javax.swing.JPanel {
private final int BAR_WIDTH;
private final int BAR_WIDTH_MARGIN;
private int[] iaGrowthRateHeights;
private int[] iaBarPostions;
private int iOldMin;
private int iOldMax;
private int iNewMin;
private int iNewMax;
private int iAvg;
public void Stage3GUI$DrawingPanel(Stage3GUI, int);
public void setBarGraphData(int[]);
public void paintComponent(java.awt.Graphics);
private int getValueInRange(int);
}
Population Calculator/bin/com/pop/calc/Stage3GUI.class
package com.pop.calc;
public synchronized class Stage3GUI {
private final int MAX_POP;
private final int NUM_GEN;
private javax.swing.JFrame jFrame_MainFrame;
private javax.swing.JTextField[] jTextFieldArray_VariableGrowthRates;
private javax.swing.JLabel jLabel_FinalPopulationValue;
private javax.swing.JLabel jLabel_NumFishDied;
private java.util.Vector vPopData;
public static void main(String[]);
public void Stage3GUI();
private void readFile(String);
private void initialize();
}
Population Calculator/growth.txt
Fish;Pond;10;100,100,80,70,160,75,80,100,50,67
Rats;Shed;6;115,120,125,80,50,70,110,80,50,2
Mice;Barn;8;80,80,50,30,20,10,-5,20,40,10
Bacteria;Petri Dish;300;200,150,100,30,5,50,4,70,50,10
Snakes;Island;12;20,21,22,17,50,60,70,80,20,40
Rabbits;Farm;24;166,150,150,130,140,120,130,150,160,160
Stoats;Forest;10;90,80,90,75,60,15,18,18,17,15
Bats;Belfry;20;50,18,17,20,25,30,15,-10,10,8
Cats;Abandoned House;6;200,150,100,100,80,70,60,10,5,5
Money;Account;1000;2,3,3,2,3,3,5,10,6,5
Population Calculator/src/com/pop/calc/PopData.java
Population Calculator/src/com/pop/calc/PopData.java
package com.pop.calc;
public class PopData 
{
    private String sSpeciesName;
    private String sHabitat;
    private int iStartingPopulation;
    private int[] iaGrowthRates;


    public PopData(String sSpeciesName, String sHabitat,int iStartingPopulation, int[] iaGrowthRates) 
    {
        this.sSpeciesName = sSpeciesName;
        this.sHabitat = sHabitat;
        this.iStartingPopulation = iStartingPopulation;
        this.iaGrowthRates = iaGrowthRates;
    }

    public String getSpeciesName() {
        return sSpeciesName;
    }

    public void setSpeciesName(String sSpeciesName) {
        this.sSpeciesName = sSpeciesName;
    }

    public String getHabitat() {
        return sHabitat;
    }

    public void setHabitat(String sHabitat) {
        this.sHabitat = sHabitat;
    }

    public int getStartingPopulation() {
        return iStartingPopulation;
    }

    public void setStartingPopulation(int iStartingPopulation) {
        this.iStartingPopulation = iStartingPopulation;
    }

    public int[] getGrowthRates() {
        return iaGrowthRates;
    }

    public void setGrowthRates(int[] iaGrowthRates) {
        this.iaGrowthRates = iaGrowthRates;
    }
}
Population Calculator/src/com/pop/calc/Stage1.java
Population...
SOLUTION.PDF

Answer To This Question Is Available To Download

Related Questions & Answers

More Questions »

Submit New Assignment

Copy and Paste Your Assignment Here