Laboratory‎ > ‎

### Java

The following is a list of Java programming assignments done by Seunghoon Kim for UIUC-CS125 Introduction to Computer Science in Spring 2003. To be used for personal references only.

## CS125 MP1: Spacing

A program for performing various calculations involving the floor space in a building. This version of the solution makes use of casting.

### Spacing.java

```// Class: Spacing
// Seunghoon Kim
// 2/13/2003

// CS 125 MP 1
// Building Space Calculations

public  class Spacing
{
// Method: main
//    - controls main execution of program
public static void main(String[] args)
{
int buildingsize;
int groundfloor;
int rooms;
int otherfloor;
double avgarea;
double percent;

// prints out the name of the program
System.out.println("Building Area Calculation Program");
System.out.println("+++++++++++++++++++++++++++++++++");
// asks for the size of the building
System.out.print("Enter the number of square feet in the building: ");
// stores the input as    a variable buildingsize
// asks for the size of the ground floor
System.out.print("Enter the number of square feet on ground floor: ");
// stores the input as    a variable groudfloor
// asks for the number of rooms in the building
System.out.print("How many rooms does the building have?: ");
// stores the input as a variable rooms

// calculation of average area per room
avgarea = (double) buildingsize/rooms;
// size of the floors other than the ground floor
otherfloor = buildingsize - groundfloor;
// calculation of percentage of the area other floors are occupying in the building
percent = (double) otherfloor/buildingsize*100;

// prints out a blank line
System.out.println();
// prints out the average area per room
System.out.println("There is an average of " + avgarea + " square feet per room.");
// prints out the area of the floors other than the ground floor
System.out.println(otherfloor + " of the " + buildingsize + " square feet of the building are on floors other than the
ground floor.");
// prints out the percentage of area of other floors in the building
System.out.println("This is " + percent + "% of the total area.");

// end of the program
}
}```

### Spacing.class

```/* default package */

public class Spacing extends java.lang.Object
{
/* Constructors */
public Spacing() {
}

/* Methods */
public static void main(java.lang.String[]) {
}

}```

## CS125 MP2: Property Taxes

This program calculates the property tax that is owed on a piece of property. Depending on whether it has a building on the property, the size of the building, and floors the building has will affect the amount of the property tax.

### PropertyTax.java

```public class PropertyTax
{
public static void main(String[]args)
{

int propsize;
char building;
int bldgsize = 0;
int bldgflr = 0;
char taxpay;
char correct;
int taxclass;
int proptax = 0;

System.out.println("Property Tax Calculation Program");
System.out.println("++++++++++++++++++++++++++++++++");
System.out.println();

do
{
System.out.print("Enter size of the property: ");
System.out.print("Is there a building? (Y/N): ");

if (building == 'Y')
{
System.out.print("Enter size of building: ");
System.out.print("Enter number of floors: ");
}

System.out.print("Annual or quarterly bill? (A/Q): ");
System.out.print("Is the above information correct? (Y/N): ");

} while (correct == 'N');

// For the categories of tax classes, numbers are used instead of alphabets,
// in order to make the process a bit simpler.
if (propsize < 10000)
taxclass = 1;
else if (propsize < 18000)
taxclass = 2;
else
taxclass = 3;

if (bldgsize > 7500)
taxclass = taxclass + 2;
else if (bldgsize >= 3000)
taxclass++;

if (taxclass == 1)
proptax = 1000;
if (taxclass == 2)
proptax = 1500;
if (taxclass == 3)
proptax = 2500;
if (taxclass == 4)
proptax = 4000;
if (taxclass == 5)
proptax = 5000;

if (bldgflr == 2)
proptax = proptax + 500;
if (bldgflr == 3)
proptax = proptax + 600;
if (bldgflr > 3)
proptax = proptax + 730;

if (taxpay == 'Q')
System.out.println("The quarterly tax bill is: \$" + (proptax/4) + ".");
else
System.out.println("The annual tax bill is: \$" + proptax + ".");

}
}```

### PropertyTax.class

```/* default package */

public class PropertyTax extends java.lang.Object
{
/* Constructors */
public PropertyTax() {
}

/* Methods */
public static void main(java.lang.String[]) {
}

}```

## CS125 MP3: Building Construction

A program for adding buildings to an existing map of the area, and keeping a record of the order in which the buildings are added to the area.

### Construction.java

```public class Construction
{
public static void main(String[] args)
{
char[][] area = new char[7][9];
char inputbldg;
char bldgtype;
int row;
int column;
int[][] record = new int[62][2];
int count = 0;

System.out.println("Map Generator for Beachfront Property");
System.out.println("+++++++++++++++++++++++++++++++++++++");
System.out.println();

System.out.print("Do you have a building to input? (Y/N): ");

while (inputbldg == 'Y')
{
System.out.print("[H]otel or [P]rivate residence?: ");

if (bldgtype == 'P')
{
System.out.print("   Row of house: ");
System.out.print("   Column of house: ");

if ((area[row][column] == 'H') || (area[row][column] == 'P'))
System.out.println("That land is taken; you get a tent instead.");
else
{
area[row][column] = 'P';
System.out.println("House permit is granted.");

record[count][0] = row;
record[count][1] = column;
count = (count+1);
}

}

if (bldgtype == 'H')
{
System.out.print("   Row of hotel: ");
System.out.print("   Left column of hotel: ");

if ((area[row][column] == 'P') || (area[row][column] == 'H') || (area[row][(column+1)] == 'P') ||
(area[row][(column+1)] == 'H'))
System.out.println("At least one of those spots is occupied!");
else
{
area[row][column] = 'H';
area[row][(column+1)] = 'H';
System.out.println("Hotel construction is approved.");

record[count][0] = row;
record[count][1] = column;
count = (count+1);
}

}
System.out.println();
System.out.print("Do you have a building to input? (Y/N): ");
}

//Construction history
int limit = (count-1);
System.out.println("Here is the construction history: ");
System.out.println();

for(count=0; count<=limit; count++)
{
row = record[count][0];
column = record[count][1];

if (area[row][column] == 'P')
System.out.println("Residence at (" + row + ", " + column + ") : Private");
if (area[row][column] == 'H')
System.out.println("Residence at (" + row + ", " + column + ") : Hotel");
}
System.out.println();

//Building map
System.out.println("Here is the building map:");
System.out.println();
System.out.println("XXXXXXXXXXXXXXXXXXXXX");
for(row=0; row<=6; row++)
{
System.out.print("X ");
for(column=0; column<=8; column++)
{
if (area[row][column] == 'P')
System.out.print("P ");
else if (area[row][column] == 'H')
System.out.print("H ");
else
System.out.print("  ");
}
System.out.println("X");
}
System.out.println("XXXXXXXXXXXXXXXXXXXXX");

}
}```

### Construction.class

```/* default package */

public class Construction extends java.lang.Object
{
/* Constructors */
public Construction() {
}

/* Methods */
public static void main(java.lang.String[]) {
}

}```

## CS125 MP4: Land Purchase Control

### PurchaseControl.java

A class whose methods assist with various phases of the land-purchase process

```public class PurchaseControl
{

// processSelection
//	- parameters : menuChoice - integer variable selected by the user in menuSelection
//		       map - 2-D array of PlotOfLand info
//	- return value : 2-D array of PlotOfLand info(map)
//	- takes in integer value menuChoice(1-3), and depending on that value,
//		it makes different method calls
public static PlotOfLand[][] processSelection(int menuChoice, PlotOfLand[][] map)
{
map = MapManipulation.createMap();
purchasePlotOfLand(map);
else
MapManipulation.printMap(map);

return map;
}

// obtainCoordinates
//	- parameters : map - 2-D array of PlotOfLand info
//		       size - char value indicating whether the plot size is small or large
//	- return value : reference to a CoordPair object
//	- asks the user for coordinates of plot, and calls method checkCoords in MapManipulation
//		to test if that space is available, and returns the coordinates of approved plot location
//		otherwise, it returns (-1,-1) which is the error code
public static CoordPair obtainCoordinates(PlotOfLand[][] map, char size)
{
CoordPair mappoint;
mappoint = new CoordPair();
char again = 'Y';
boolean endloop = false;

if (size == 'S')
{
do{
System.out.println("Enter coordinates of plot: ");
System.out.print("   row: ");
System.out.print("   column: ");

endloop = MapManipulation.checkCoords(map,mappoint);

if (endloop == false)
{
System.out.println("You cannot place your plot there. ");
System.out.println("Choose new coordinates? (Y/N): ");
}
}while((again == 'Y')&&(endloop == false));
}

else if (size == 'L')
{
do{
int temprow = 0;
int tempcolumn = 0;

System.out.println("Enter lower left coordinates of plot: ");
System.out.print("   row: ");
System.out.print("   column: ");

for (int i=0; i < 2; i++)
{
mappoint.xValue = temprow + i;
for (int j=0; j < 2; j++)
{
mappoint.yValue = tempcolumn + j;
endloop = MapManipulation.checkCoords(map,mappoint);
if (endloop == false)
{
j = 2;
i = 2;
}
}
}

if (endloop == false)
{
System.out.println("You cannot place your plot there. ");
System.out.print("Choose new coordinates? (Y/N): ");
}
else
{
mappoint.xValue = mappoint.xValue-1;
mappoint.yValue = mappoint.yValue-1;
}

}while((again == 'Y')&&(endloop == false));
}

if (again == 'N')
{
mappoint.xValue = -1;
mappoint.yValue = -1;
}

return mappoint;
}

// purchasePlotOfLand
//	- parameters : map - 2-D array of PlotOfLand info
//	- return value : none
//	- declares and initializes an PlotOfLand variable pt, receives coordinate values from the method
//		obtainCoordinates and sets them into pt.lowerLeft, once all the instance variables are set,
//		calls made to the method writeLotToMap in the class MapManipulation
public static void purchasePlotOfLand(PlotOfLand[][] map)
{
PlotOfLand pt;
pt = new PlotOfLand();
pt.lowerLeft = new CoordPair();
char tempSize;

System.out.print("Do you wish a small or large plot? (S/L): ");

while ((tempSize != 'S')&&(tempSize != 'L'))
{
System.out.println("That is not a legal choice!");
System.out.print("Enter a new selection: ");
}

pt.lowerLeft = obtainCoordinates(map, tempSize);

if (tempSize == 'S')
pt.sizeType = new String("small");
if (tempSize == 'L')
pt.sizeType = new String("large");

if ((pt.lowerLeft.yValue >= 0)&&(pt.lowerLeft.xValue >= 0))
{
System.out.print("Enter customer ID: ");
MapManipulation.writeLotToMap(map, pt);
}
}

//    - return value : integer holding legal menu selection
//    - obtains a legal choice from menu and returns it
{
System.out.println("Select an option from menu: ");
System.out.println("   [1] Initialize Map");
System.out.println("   [2] Purchase Land Plot");
System.out.println("   [3] Print Map");
System.out.println("   [4] Quit");
System.out.print("Enter selection: ");
while ((selection < 1) || (selection > 4))
{
System.out.println("That is not a legal choice!");
System.out.print("Enter a new selection: ");
}
return selection;
}
}```

### PurchaseControl.class

```/* default package */

public class PurchaseControl extends java.lang.Object
{
/* Constructors */
public PurchaseControl() {
}

/* Methods */
public static PlotOfLand[][] processSelection(int, PlotOfLand[][]) {
}

public static CoordPair obtainCoordinates(PlotOfLand[][], char) {
}

public static void purchasePlotOfLand(PlotOfLand[][]) {
}

}

}```

### MapManipulation.java

A class whose methods manipulate a two-dimensional array representing a building layout map.

```public class MapManipulation
{
// class variable unsold
public static PlotOfLand unsold;

// createMap
//	- parameters : none
//	- return value : a 2-D array of PlotOfLand references(map)
//	- asks for the row and column numbers, and creates a 2-D array of type PlotOfLand and returns
public static PlotOfLand[][] createMap()
{
int rows = 0;
int columns = 0;

while((rows < 1)||(columns < 1))
{
System.out.print("Enter number of rows: ");
System.out.print("Enter number of columns: ");
if((rows < 1)||(columns < 1))
System.out.println("You must enter positive numbers!");
}

PlotOfLand[][] map;
map = new PlotOfLand[rows][columns];

for(int i=0; i < rows; i++)
{
for(int j=0; j < columns; j++)
{
map[i][j] = new PlotOfLand();
map[i][j] = unsold;
}
}

return map;
}

// writeLotToMap
//	- parameters : map - 2-D array of PlotOfLand info
//		       pt - a reference to one PlotOfLand object
//	- return value : none
// 	- takes in the PlotOfLand variable pt that holds all the information about specific
//		location in the map array, and puts in the values held in instance variable pt
//		into the specific location in the map array
public static void writeLotToMap(PlotOfLand[][] map, PlotOfLand pt)
{
if (pt.sizeType.equals("small"))
map[pt.lowerLeft.xValue][pt.lowerLeft.yValue] = pt;
else if (pt.sizeType.equals("large"))
{
map[pt.lowerLeft.xValue][pt.lowerLeft.yValue] = pt;
map[pt.lowerLeft.xValue][(pt.lowerLeft.yValue+1)] = pt;
map[(pt.lowerLeft.xValue+1)][pt.lowerLeft.yValue] = pt;
map[(pt.lowerLeft.xValue+1)][(pt.lowerLeft.yValue+1)] = pt;
}
}

// checkCoords
//    - parameters : map - two-dimensional array of PlotOfLand info
//                 : mapPoint - two-dimensional coordinate in map
//    - return value : a boolean indicating whether or not the
//                       coordinate is available for sale in the map
//    - if the parameter coordinate is both an actual map coordinate, and
//         is the coordinate of an unsold plot in the map, return true.
//         Otherwise (i.e. if the coordinate is either off the map or is
//         in use by a purchased plot) then return false.
public static boolean checkCoords(PlotOfLand[][] map, CoordPair mapPoint)
{
boolean status;
if ((mapPoint.xValue < 0) || (mapPoint.xValue >= map.length) ||
(mapPoint.yValue < 0) || (mapPoint.yValue >= map[0].length))
status = false;
else if (map[mapPoint.xValue][mapPoint.yValue] != unsold)
status = false;
else
status = true;

return status;
}

// printMap
//    - prints out map information in a formatted fashion
public static void printMap(PlotOfLand[][] map)
{
for (int i = 0; i < 4 * map[0].length + 3; i++)
System.out.print('X');
System.out.println();

for (int i = 0; i < map.length; i++)
{
System.out.print("X ");
for (int j = 0; j < map[0].length; j++)
{
if (map[i][j].sizeType.equals("unsold"))
System.out.print("--- ");
else if (map[i][j].sizeType.equals("large"))
System.out.print(map[i][j].customerID + " ");
else
System.out.print(map[i][j].customerID + " ");
}
System.out.println('X');
}

for (int i = 0; i < 4 * map[0].length + 3; i++)
System.out.print('X');
System.out.println();
}
}```

### MapManipulation.class

```/* default package */

public class MapManipulation extends java.lang.Object
{
/* Fields */
public static PlotOfLand unsold;

/* Constructors */
public MapManipulation() {
}

/* Methods */
public static PlotOfLand[][] createMap() {
}

public static void writeLotToMap(PlotOfLand[][], PlotOfLand) {
}

public static boolean checkCoords(PlotOfLand[][], CoordPair) {
}

public static void printMap(PlotOfLand[][]) {
}

}```

## CS125 MP5: Building Residence Information System

### Building.java

A class implementing a collection of rooms of various kinds

```public class Building
{

protected static Room[] RoomArr;
protected static int rooms;

// Building
//    - constructor
//    - initializes object to default Building
public Building()
{
RoomArr = new SingleResident[2];
rooms = 0;
}

// Building
//    - constructor
//    - parameter : OldCollection - Building class variable
//    - copies Building class variable OldCollection to
//          a new Building class variable
public Building(Building OldCollection)
{
rooms = OldCollection.rooms;
RoomArr = new SingleResident[(OldCollection.RoomArr.length * 2)];
for(int i=0; i<=(OldCollection.RoomArr.length); i++)
RoomArr[i] = OldCollection.RoomArr[i];
}

// appendRoom
//	 - parameter : paramRoom - Room class variable
//    - no return value
//    - copies paramRoom into a room array RoomArr
public static void appendRoom(Room paramRoom)
{
RoomArr[rooms] = paramRoom.copy();
rooms++;
}

// printAll
//    - prints out info to screen
public static void printAll()
{
for(int i=0; i<rooms; i++)
RoomArr[i].print();
System.out.println();
}

}```

### Room.java

A class representing a room, numbered as if in some building of some kind

```public class Room
{
// Room
//    - constructor
//    - initializes object to default room
public Room()
{
roomNumber = 0;
roomSize = 0;
}

// Room
//    - constructor
//    - parameters : paramRoomNumber - the number of this room
//                 : paramRoomSize - the size of this room
//    - initializes office to have the parameter room number and
//          size; assumption about parameters is that both are
//          non-negative
public Room(int paramRoomNumber, int paramRoomSize)
{
roomNumber = paramRoomNumber;
roomSize = paramRoomSize;
}

// getRoomNumber
//    - return value : an integer storing a room number
//    - returns the room number of this room
public int getRoomNumber()
{
return roomNumber;
}

// getRoomSize
//    - return value : an integer storing the room size
//    - returns the room size of this room
public int getRoomSize()
{
return roomSize;
}

// print
//    - prints out info to screen
public void print()
{
System.out.println("Room number: " + roomNumber);
System.out.println("Size of room: " + roomSize);
}

// copy
//    - return type: a reference to another Room object
//    - creates and returns a copy of this object
public Room copy()
{
return new Room(roomNumber, roomSize);
}

private int roomNumber;   // room number of room
private int roomSize;     // size of room
}```

### SingleResident.java

A subclass of room that inherits everything in room class and adds resident's name

```public class SingleResident extends Room
{

private String ResidentName;

// Room
//    - constructor
//    - initializes object to default room
public SingleResident()
{
super();
ResidentName = "";
}

// Room
//    - constructor
//    - parameters : paramRoomNumber - the number of this room
//                 : paramRoomSize - the size of this room
//    - initializes office to have the parameter room number and
//          size; assumption about parameters is that both are
//          non-negative
public SingleResident(int paramRoomNumber, int paramRoomSize, String paramResidentName)
{
super(paramRoomNumber, paramRoomSize);
ResidentName = paramResidentName;
}

// getResidentName
//    - return value : a string storing the resident's name
//    - returns the resident's name occupying this room
public String getResidentName()
{
return ResidentName;
}

// print
//    - prints out info to screen
public void print()
{
super.print();
System.out.println("Resident's name: " + ResidentName);
}

// copy
//    - return type: a reference to another Room object
//    - creates and returns a copy of this object
public Room copy()
{
int tempRoomNumber = super.getRoomNumber();
int tempRoomSize = super.getRoomSize();
return new SingleResident(tempRoomNumber, tempRoomSize, ResidentName);
}

}```

## CS125 MP6: Real Estate Development and Controller

### Controller.java

An object of this class serves as the controller for our building-purchase program, dealing with user interaction and starting subparts of the program until the user finally decides to quit.

```import java.io.*;

public class Controller
{
// Controller
//    - constructor
//    - initializes object to default values -- no customers,
//        buildings, or developments, and default administrator
//        access, which is "not an administrator"
public Controller()
{
developments = new String[0];
clients = new int[0];
edifices = new Building[0];
}

// operate
//    - this method is the main program loop, in that once
//       this method is called, it does not return until the
//       user decides to quit. This method is responsible for
//       acquiring user input from the menu and activating the
//       appropriate actions based on user input. In addition,
//       whether or not the user is an administrator is
//       determined at the start of this method, so that the
//       other methods will all know what choices are available
//       to this user.
public void operate()
{
System.out.println("Welcome to the Building Purchasing Controller.");
System.out.print("Are you an administrator? (Y/N): ");
else
System.out.println();

boolean quittingNotWanted = true;
do
{

purchaseBuilding();
viewCustomerHistory();
quittingNotWanted = false;

} while (quittingNotWanted);

System.out.println("That is all!");
}

//    - return value : a character that is a legal menu choice
//                       for the status of the user
//    - prints out menu of user selections, with the menu being
//       appropriate to whether the user is an administrator
//       or not. Then, prompts for a menu selection. The method
//       will reprompt repeatedly as long as the user's selection
//       is illegal; once a legal selection is made, that selection
//       is returned.
{
System.out.println("Please select one of the following options:");
System.out.println("   [P] Purchase a Building");
System.out.println("   [V] View Customer History");
System.out.println("   [Q] Quit Controller");

do
{
System.out.print("Enter choice: ");
if (     (menuChoice == 'P') ||
else
System.out.println("That is not a legal menu choice!");
System.out.println();

}

private void purchaseBuilding()
{
System.out.print("Enter customer ID: ");
int[] tempCust = new int[clients.length+1];
for(int i=0; i<clients.length; i++)
tempCust[i] = clients[i];
tempCust[(clients.length)] = custID;
clients = tempCust;

System.out.print("Enter development name: ");
Development projPurchase = new Development(developName);

System.out.println("What type of building do you want?: ");
System.out.println("   [1] House");
System.out.println("   [2] Small Office");
System.out.println("   [3] Large Office");
System.out.print("Enter choice: ");

Building[] tempBuild = new Building[edifices.length+1];
for(int j=0; j<edifices.length; j++)
tempBuild[j] = edifices[j];
if (typeBldg == 1)
tempBuild[(edifices.length)] = new House(custID);
else if (typeBldg == 2)
tempBuild[(edifices.length)] = new SmallOffice(custID);
else if (typeBldg == 3)
tempBuild[(edifices.length)] = new LargeOffice(custID);
edifices = tempBuild;

Pair gridVal = projPurchase.getDimensions();
int gridX = gridVal.getX();
int gridY = gridVal.getY();

// map drawing
for(int k=0; k <= gridX; k++)
System.out.print("*");
System.out.println("*");
for(int i = gridY-1; i >= 0; i--)
{
System.out.print("*");
for(int j=0; j < gridX; j++)
{
GridLocation temp = projPurchase.getGridLocation(j, i);
if (temp.canHoldBuilding() == false)
System.out.print(" ");
else
{
LotLocation Ltemp = (LotLocation) projPurchase.getGridLocation(j, i);
if (Ltemp.getBuildingIndex() < 0)
System.out.print("Y");
else
System.out.print(" ");
}
}
System.out.println("*");
}
for(int k=0; k <= gridX; k++)
System.out.print("*");
System.out.println("*");

System.out.println("Enter lower left corner of choice: ");
System.out.print("   Enter x coordinate: ");
System.out.print("   Enter y coordinate: ");

projPurchase.write(developName);

// code added here in a later section of MP
}

// *********************** View methods *************************

private void viewCustomerHistory()
{
printDevelopment();
// code added here in a later section of MP
}

//    - controls the selection and running of the program's
//         administration tools; when user chooses to quit
//         the administration tools section of the program,
//         the program returns from this method back to the main
{

boolean quittingNotWanted = true;
do
{

initializeDevelopment();
printDevelopment();
quittingNotWanted = false;

} while (quittingNotWanted);
}

//    - return value : a character representing a legal selection from
//        user to make a selection from the menu. Reprompting will
//        occur as long as an illegal choice is entered. Once a legal
//        choice is entered, the choice will be returned.
{
System.out.println("Please select one of the following options:");
System.out.println("   [I] Initialize a Development");
System.out.println("   [V] View Development Purchases");

do
{
System.out.print("Enter choice: ");
else
System.out.println("That is not a legal menu choice!");
System.out.println();

}

// initializeDevelopment
//    - prompts the user for a database name and a land layout
//         file name, and creates a new database with the land layout
//         info and no buildings. If the user selects a database name of
//         an already existing database, they will have the chance to
//         change it if they want, or to keep the name they chose and
//         thus clear the pre-existing database. Also, if the user
//         enters a land layout file name that does not exist, the user
//         will have the chance to select a new one or quit the
//         initialization process entirely.
private void initializeDevelopment()
{
int overlapPoint = -1;
System.out.print("Enter name of database to initialize: ");
do
{
for(int i=0; i<developments.length; i++)
{
if (developments[i].equals(developFile))
{
overlapPoint = i;
}
else
}

{
String[] temp = new String[developments.length+1];
for(int j=0; j<developments.length; j++)
temp[j] = developments[j];
temp[(developments.length)] = developFile;
developments = temp;
}

else
{
char overWrite;
System.out.print("Already Exists! clear it or select again? (C/S): ");

if (overWrite == 'C')
{
//String[] temp = new String[developments.length+1];
//for(int j=0; j<overlapPoint; j++)
//    temp[j] = developments[j];
//for(int j=overlapPoint; j<developments.length-1; j++)
//    temp[j] = developments[(j+1)];
//temp[(developments.length)] = developFile;
//developments = temp;

}
else if (overWrite == 'S')
{
System.out.print("Enter name of database to initialize: ");
}
}

boolean fileExist = false;

System.out.print("Enter name of land layout description file: ");

do{

File testFile = new File(LandFile);
if (testFile.exists())
{
fileExist = true;
Development Project = new Development(developFile);
Project.importLandLayout(LandFile);
Project.write(developFile);
}
else
{
System.out.println("That database does not exist.");
System.out.print("Select again or quit? (S/Q): ");
{
fileExist = false;
System.out.print("Enter name of land layout description file: ");
}
else
fileExist = true;
}
}while (!fileExist);

}

// printDevelopment
//    - obtains a development project name from the user and
//       prints out the information about that development
//       project. The user will have the option of giving up
//       trying to enter a name, if the name they've entered already
//       is not the name of an existing project.
private void printDevelopment()
{
String namePrint;

do
{
System.out.print("Enter name of database to print: ");

File testFile = new File(namePrint);
if (testFile.exists())
{
}
else
{
System.out.println("The name of the project you entered does not exist.");
System.out.print("Select again or quit? (S/Q): ");
if (notQuit!='S')
}

// you will write this code; most likely you will want some
//  helper methods too (they might perhaps be helper methods
//  also used by initializeDevelopment() as well, or maybe not.
//  That is up to you.
}

private String[] developments;
private int[] clients;
private Building[] edifices;
}```

### Development.java

A class whose objects represent land development projects in progress

```public class Development
{
// Development
//    - constructor
//    - parameters : name - name of this development project
//    - initializes object to have parameter name and no
//        buildings or area size
public Development(String name)
{
area = null;
edifices = null;
developmentName = name;
}

// getGridLocation
//    - parameters : xVal - x coordinate of grid location
//                 : yVal - y coordinate of grid location
//    - return value : a reference to a grid location in this
//        development
//    - returns reference to the grid location at the parameter
//       coordinate. No error checking is done at all.
GridLocation getGridLocation(int xVal, int yVal)
{
return area[xVal][yVal];
}

Pair getDimensions()
{
return new Pair(area.length, area[0].length);
}

//    - parameters : edifice - the building to be added
//                 : xLoc - the x location of the building's lower left corner
//                       (i.e. corner with smallest x and smallest y values)
//                 : yLoc - the y location of the building's lower left corner
//                       (i.e. cornewr with smallest x and smallest y values)
//    - assumes that, for this building's dimensions, there are only
//           LotLocation objects everywhere in the "area" GridLocation array
//           for all the cells where this building should be added -- the
//           lower left corner and any other cells. Inserts builing into
//           development.
public void addBuilding(Building edifice, int xLoc, int yLoc)
{
LotLocation tempLot = new LotLocation(xLoc, yLoc);
int indexNum;
if (edifices == null)
indexNum = 0;
else
indexNum = this.edifices.length;

Building[] tempBuild = new Building[indexNum+1];
for(int j=0; j<indexNum; j++)
tempBuild[j] = this.edifices[j];
tempBuild[indexNum] = edifice;
this.edifices[] = tempBuild[];

Pair Dim = edifice.getDimensions();
int bldgType = Dim.getY();
((LotLocation) area[xLoc][yLoc]).setBuilding(edifice, indexNum);
if (bldgType == 2 || bldgType == 4)
{
((LotLocation) area[xLoc+1][yLoc]).setBuilding(edifice, indexNum);
((LotLocation) area[xLoc][yLoc+1]).setBuilding(edifice, indexNum);
((LotLocation) area[xLoc+1][yLoc+1]).setBuilding(edifice, indexNum);
}
if (bldgType == 4)
{
((LotLocation) area[xLoc][yLoc+2]).setBuilding(edifice, indexNum);
((LotLocation) area[xLoc][yLoc+3]).setBuilding(edifice, indexNum);
((LotLocation) area[xLoc+1][yLoc+2]).setBuilding(edifice, indexNum);
((LotLocation) area[xLoc+1][yLoc+3]).setBuilding(edifice, indexNum);
}

}

// print
//    - prints out details of every location in development grid
public void print()
{
for (int i = 0; i < area.length; i++)
for (int j = 0; j < area[0].length; j++)
area[i][j].printDescription();
}

// importLandLayout
//    - parameters : landFileName - the name of the file we
//                     want to import land information from
//    - imports information from a file with name equal to the
//          parameter String; initializes development project
//          using imported information.
public void importLandLayout(String landFileName)
{

area = new GridLocation[numRows][numCols];
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numCols; j++)
area[i][j] = new LotLocation(i, j);

for (int i = 1; i <= numInfo; i++)
{
GridLocation temp = new GridLocation();
if (theKind == 'W')
temp = new WaterLocation();
else if (theKind == 'F')
temp = new ForestLocation();
else if (theKind == 'S')
temp = new SandLocation();
else if (theKind == 'G')
temp = new GrassLocation();

area[temp.getXLocation()][temp.getYLocation()] = temp;
}
fileHandle.closeFile();
}

// write
//    - writes the information of this development into a
//      file with the approprate name -- specifically, the
//      name of this development
public void write(String fileName)
{
WriteFile fileHandle = new WriteFile(fileName);

if(edifices!=null)
{
fileHandle.println(edifices.length);
int bldgType = 0;
int CustID = 0;
for(int i=0; i<edifices.length; i++)
{
Pair Dim = edifices[i].getDimensions();
bldgType = Dim.getY();

if (bldgType == 1)
fileHandle.println("House");
else if (bldgType == 2)
fileHandle.println("Small Office");
else if (bldgType == 4)
fileHandle.println("Large Office");

CustID = edifices[i].getCustomerID();
fileHandle.println(CustID);
}
}
else
fileHandle.println("0");

fileHandle.println(area.length);
fileHandle.println(area[0].length);
GridLocation temp = new GridLocation();
for(int i=0; i<area.length; i++)
{
for(int j=0; j<area[0].length; j++)
{
temp = getGridLocation(i,j);
temp.write(fileHandle);
}
}
fileHandle.closeFile();
}

//    - reads the information for this development from a file
//       named for this development
{

Building[] edifices = new Building[numBldg];

for(int i=0; i<edifices.length; i++)
{
Building temp = null;

if (typeBldg.equals("House")==true)
temp = new House(CustID);
else if (typeBldg.equals("Small Office")==true)
temp = new SmallOffice(CustID);
else if (typeBldg.equals("Large Office")==true)
temp = new LargeOffice(CustID);

edifices[i] = temp;
}

area = new GridLocation[numRows][numCols];

for(int i=1; i<=(numRows*numCols); i++)
{
GridLocation temp = new GridLocation();
if (theKind.equals("WaterLocation")==true)
temp = new WaterLocation();
else if (theKind.equals("ForestLocation")==true)
temp = new ForestLocation();
else if (theKind.equals("SandLocation")==true)
temp = new SandLocation();
else if (theKind.equals("GrassLocation")==true)
temp = new GrassLocation();
else if (theKind.equals("LotLocation")==true)
temp = new LotLocation();

area[temp.getXLocation()][temp.getYLocation()] = temp;
}
fileHandle.closeFile();

}

private GridLocation[][] area;
private String developmentName;
private Building[] edifices;
}```