Search results for 'omer'

Dreams Travel Agency Java GUI Both parts

Field of Dreams Travel Agency has begun offering travel packages to baseball fans wanting to attend major league baseball games. The company offers a package allowing a fan to attend games in four cities of his or her choice, including transportation by car, tickets, lodging, and food. Assume that the fan lives in the city hosting one of the 30 major league baseball teams. The fan will travel from his or her home to the city of one of the teams of his choice, then will proceed to the city of one of the other teams and so on until all teams have been visited. Then, the fan will return home. Create a Java program that will compute the minimum cost of the trip. Your cost will be the cost of transportation (fuel cost per gallon/ miles per gallon * number of miles between ballparks), cost of tickets, cost of lodging, and cost of food. Ask the user his home city, which cities he wants to visit, the price of fuel, the fuel economy of his vehicle, the cost of lodging per day and the cost of food per day.  Your program will compute the costs of all 24 possible routings and choose the minimum cost route. Mark up the minimum cost by 20% to arrive at the cost that will be quoted to the customer.
For this week, you need only to create the GUI using Java Swing and create the basic classes that will accept the inputs from the user. We will create the functionality of these classes in the second assignment.
We will discuss strategies for preparing this program in the first week of class and you can create the program in the second week of class. That is done and I have a program with no function so here is the second part: Expand the model classes you created in the first assignment. Implement the functionality that will use the inputs offered by the user and prepare a quote for the customer according to the requirements specified in the first assignment. Upon clicking a Quote button on the GUI, the program should post a dialog box with the quote. Upon clicking the Print Quote button, write the quote out to a text file. This program was built on NETBEANS

Penn Foster Exam 40254500 Construction Company Java Program

Write an application for a construction company to handle a customer's order to build a new home. Use separate ButtonGroups to allow the customer to select one of four models, the number of bedrooms, and a garage type. Assume that the models are the Aspen, $100,000; the Brittany, $120,000; the Colonial, $180,000; or the Dartmoor, $250,000. Assume that any model can have two, three, or four bedrooms and that each bedroom adds $10,500 to the base price. Assume that the garage type can be zero-, one-, two-, or three-car, and that each car adds $7,725 to the price. Save the file as JMyNewHome.java.

ITS 320 Assignment 7 BankAccount Java Program

Create a class called BankAccount. The BankAccount class should contain a String to store the customer name and a double to store the account balance. The BankAccount class should have 2 constructors as follows:

public BankAccount(String name, double balance) throws NegativeAmountException
{
// set name and balance
// make sure balance is not negative
// throw exception if balance is negative
}

public BankAccount(String name) throws NegativeAmountException
{
// set name and use 0 balance
}

As can be seen, the first constructor throws a NegativeAmountException if the balance being used to create the bank account is negative. You will have to create this exception class yourself.

The BankAccount class should also contain methods to make a deposit, make a withdrawal, get the current balance, and print a bank account statement. The interfaces for these methods should appear as follows:

// update balance by adding deposit amount
// make sure deposit amount is not negative
// throw exception if deposit is negative
public void deposit(double amount) throws NegativeAmountException

// update balance by subtracting withdrawal amount
// throw exception if funds are not sufficient
// make sure withdrawal amount is not negative
// throw NegativeAmountException if amount is negative
// throw InsufficientFundsException if balance < amount
public void withdraw(double amount) throws InsufficientFundsException, NegativeAmountException

// return current balance
public double getBalance()

// print bank statement including customer name
// and current account balance
public void printStatement();

Use the BankAccount class as the superclass for a SavingsAccount class. In addition to the behaviors of a BankAccount, a SavingsAccount also accumulates interest, therefore the SavingsAccount class contains a double that is populated with the current interest rate. In addition to its constructors (you decide what the constructors should be), the SavingsAccount class should contain the following methods:

// post monthly interest by multiplying current balance
// by current interest rate divided by 12 and then adding
// result to balance by making deposit
public void postInterest()

// print bank statement including customer name
// and current account balance (use printStatement from
// the BankAccount superclass)
// following this also print current interest rate
public void printStatement()

Once these two classes are completed, create a driver class called FinalExam containing a main method that tests the SavingsAccount class. Within the driver test class, create a SavingsAccount object and then use it to make deposits, withdrawals, and to post the monthly interest.

To make the program simpler, you can incorporate the initial data for the Savings Accounts directly in the program (e.g., no need to prompt for the account holder name or starting balance). The only things you need to prompt for are the deposit amount and the withdrawal amount. Also, to simplify the task, the only exceptions that you should handle are the NegativeAmountException and the InsufficientFundsException. If either of these exception conditions occurs, print an appropriate error message and terminate the application. You can simply re-throw any IOExceptions from the main.

Travel Agents System Java Program

You are to develop program in Java for a small travel agents. The company arranges holidays from four UK airports to five international destinations. Users need to find flight times and costs for journeys between these destinations. The system also provides information on hotels at the destinations (name of hotel and cost per person per night). Information on hotels can only be added, or loaded from file, when the program is running. The following table (Table 1) provides the airport names, destinations, costs and flight times for the journeys Table 1 Information for the travel agents program – the two values represent cost (£) and flight time (hours) respectively – you can make up your own (realistic values) if you wish

Airport/Destination | New York |Dahab | Rome |Sydney |Tokyo
East Midlands |200/5.0 |150/4.0 |100/1.0 |500/22.0 |400/12.0
Birmingham |190/4.8 |140/3.5 |95/1.1 |480/22.5 |380/12.5
Heathrow |195/4.9 |140/3.6 |95/1.1 |490/23.0 |390/12.5
Manchester |210/5.5 |145/3.7 |110/1.2 |470/22.7 |370/12.6

(the above is a data table, where there is a line, represents the cell)

Your program should have a main menu with four options – Time, Price, Hotels and End (which terminates the program). The Hotels option takes the user to another (Hotel) menu with the following six options – View Hotels; Add Hotel; Delete Hotel; Save Hotels; Retrieve Hotels; Exit (back to the previous menu). Note that your program should include appropriate error trapping – for example, entering an invalid date (eg 30 February).
Functionality for each of these menu options is explained below:
Time – Provides the flight time presented in hours.
Price – The cost of travelling from an airport to a given destination (both selected by the user). Note, if the customer is travelling on the last day of the month the fare should be increased by 5% (and display a message to say that this has been done). The system will therefore need to ask the user the date of travel. It should not simply ask the user if it is the end of the month – but work this out from a date provided by the user.
Hotels – Takes the user to a Hotels Information Menu.
Hotels menu
View Hotels – The user selects a destination and the system displays all available hotels at that destination including the overnight cost per person. If there are no hotels for a destination it should display a message to say so.
Add Hotel – Allows the user to add a hotel for a given destination. This should add to the list of existing hotels for that destination (if there are any). For example, I might add 'Belle Vue' as a hotel in Sydney at a cost of £50 per person per night.
Delete Hotel – Allows the user to delete a hotel from a list of hotels at a destination.
Save Hotels – save all the information on all hotels to a single file in a format of your choosing.
Retrieve Hotels – read in all the information on hotels from a user selected file (a file saved using the previous option). This should overwrite any existing hotel data in the program when it is running.

Marking
The more functionality you add to the program the higher your mark. Begin by getting the menu options in place then add functionality to your program in the following order (make sure that earlier parts of the system are working properly before moving on). Your program should also be structured in an object oriented way. You should try to identify and implement a number of classes for this program.

Minimum pass (40%)
The flight time between any airport and destination;
The cost of travel between any airport and destination;
Increased cost of travel on the last day of the month and a message to say this has been applied;

40%-70%
View hotels – users can view information on all hotels at a chosen destination; Add hotel – the ability for users to add hotels for a destination;
Sort hotels – users can sort all hotels alphabetically;

Documentation
Your coursework should be submitted with appropriate documentation. You should include class diagrams, designs, functionality not completed, functionality working, test plans, evaluation, and program listings. Make sure you include an explanation of how your code should be run (eg. which file should be compiled and run and anything I need to know about using the program – a user guide).

CIS355A Week 4 iLab Quick Fast Car Care Application

iLAB STEPS
Step 1: Quick Fast Car Care Application
Quick Fast Car Care is a small business that specializes in oil changes and car washes. Their strategic advantage is providing quick service. To provide quick service, this owner wants a new application that will calculate services provided to customers. The table below has the services and the cost of these services.

Oil Change Cost
Bronze $20
Silver $25
Gold $30

Car Wash Cost
Basic $5
Better $10
Best $15

Your manager wants you to create a prototype Java application using menus that will calculate the cost of a customer getting an oil change, car wash, or both. This application should add the appropriate amount to the total cost when services are provided. When the total menu item is selected, a message box should display the services purchased and the total amount. Allow the client to use the clear menu item to wipe out the memory and start fresh for a new customer. The exit menu item should close the application. Use the screen designs below to model your application.

CIS355A Week 4 Course Project Flooring Application Analysis and Design

Developing a graphical user interface in programming is paramount to being successful in the business industry. This project incorporates GUI techniques with other tools that you have learned about in this class.
Here is your assignment: You work for a flooring company. They have asked you to be a part of their team because they need a computer programmer, analyst, and designer to aid them in tracking customer orders. Your skills will be needed in creating a GUI program that calculates the flooring cost and stores the order in the database.
The project has three components: an analysis and design document, the project code, and a user manual. The analysis and design document is due Week 4. The code and user manual are due in Week 7. It is suggested that you begin working on the code in Week 5, which should give you ample time to complete the project. You will find that the lectures and lab assignments will prepare you for the Course Project.

Guidelines
Your application must include at least three tabs. The user will choose wood flooring or carpet, enter the length and width of the floor, as well as the customer name and address. The application will compute the area of the floor and the cost of the flooring considering that wood floor is $20 per square foot and carpet is $10 per square foot. A summary should be displayed, either in a tab or another window, listing the customer name and address, floor selection, area, and cost. This information should also be stored in the MySQL database table. The program should validate that all information is entered and that the length and width are numeric values. Any numeric or currency values must be formatted appropriately when output. Recommendations for the components used for input are
• radio buttons—flooring type (wood or carpet);
• text fields—customer name, customer address, floor length, and floor width; and
• buttons—calculate area, calculate cost, submit order, display order summary, display order list.
The MySQL database table is called flooring and has the following description.
Field Type
CustomerName varchar(30)
CustomerAddress varchar(50)
FlooringType varchar(10)
FloorArea Double
FloorCost Double
In addition to entering new customer orders, your application should list all customer orders stored in the database. These will be viewed as a list, in a text area, and will not be updated by the user.

Analysis and Design (Due Week 4)
In Week 4, you will complete the analysis and design for the project. You will use the guidelines described above and the grading rubric below to complete this document. You will create the following items.
1. Request for new application
2. Problem analysis
3. List and description of the requirements
4. Interface storyboard or drawing
5. Design flowchart or pseudocode
The analysis and design document will be a single MS Word document, which contains all descriptions and drawings. See the grading rubric below for the analysis and design document, due in Week 4.
Item Points Description
Request for New Application 2.5 A table containing: date of the request, name of the requester (your professor), the purpose of the request, the title of the application (create your own title), and brief description of the algorithms used in the application
Problem Analysis 2.5 Analyze the problem to be solved, and write in a few words what is the problem and what is being proposed to solve the problem
List and Description of Requirements 5 A description of the items that will be implemented in order to construct the proposed solution
Interface Storyboard or Drawing 5 A picture or drawing of what the application will look like; must include the image of each section of the application in detail
Design Flowchart or Pseudocode 5 A sketch of the flow of the application or the pseudocode of the application

CIS355A Week 6 iLab Swing and Database Connection

iLAB OVERVIEW
Scenario/Summary
Develop one application using JTabbedPanes and JFrames and another application that connects to a MySQL database.
Deliverables
1. JavaPizza
2. ContactList

iLAB STEPS
Step 1: JavaPizza
Develop an application using a JTabbedPane to order a pizza. You will need to ask the customer for their name and phone number. You will ask for the size (choose one) and toppings (choose many) and compute the total. After computing the total, provide a button to display the order summary, which includes the name, phone number, size, toppings, and total. The prices are listed below. Screenshots of a possible solution are included. Your application must include four tabs and open a new window when the button is clicked.
• Small:  8.00
• Medium: 10.00
• Large: 12.00
Each topping is 2.00 extra.
 
JavaPizza    Points    Description
Standard header included    1    Must contain program's name, student name, and description of the program
Program compiles    1    Program does not have any error
Program executes    1    Program runs without any error
Created the JTabbedPane with four tabs    4    The JTabbedPane is displayed with the four required tabs and components on each tab
Total is calculated correctly    5    The total on the last tab is calculated correctly based on information supplied.
Order summary window displayed correctly    8    The order summary window is displayed with a JTextArea, including all information from the four tabs.
Subtotal    20      
 
Step 2: Contact List
Develop a Java application to add a contact into the contact table, and display all contacts in the contact table. The contact table contains two columns, FullName, and PhoneNumber. Both values are text data. Use JOptionPanes to ask for the contact data, and display a confirmation message when the contact is added. Display the list of contacts in the console. Screenshots of a possible solution are included.
 
ContactList    Points    Description
Standard header included    1    Must contain program's name, student name, and description of the program
Program compiles    1    Program does not have any error
Program executes    1    Program runs without any error
Created the JOptionPanes for input    6    Two JOptionPanes are displayed to retrieve input
JOptionPane displayed upon insert    4    A JOptionPane is display to confirm the contact was added
ContactList shown in console    7    The list of contacts is displayed in the console under a heading contact list .
Subtotal    20

PRG 421 Week 1 Individual Analyze Assignment Analyzing a Java Program Containing Abstract and Derived Classes

"Analyzing a Java™ Program Containing Abstract and Derived Classes"
The purpose of creating an abstract class is to model an abstract situation.
Example:
You work for a company that has different types of customers: domestic, international, business partners, individuals, and so on. It well may be useful for you to "abstract out" all the information that is common to all of your customers, such as name, customer number, order history, etc., but also keep track of the information that is specific to different classes of customer. For example, you may want to keep track of additional information for international customers so that you can handle exchange rates and customs-related activities, or you may want to keep track of additional tax-, company-, and department-related information for business customers.
Modeling all these customers as one abstract class ("Customer") from which many specialized customer classes derive or inherit ("International Customer," "Business Customer," etc.) will allow you to define all of that information your customers have in common and put it in the "Customer" class, and when you derive your specialized customer classes from the abstract Customer class you will be able to reuse all of those abstract data/methods.This approach reduces the coding you have to do which, in turn, reduces the probability of errors you will make. It also allows you, as a programmer, to reduce the cost of producing and maintaining the program.
In this assignment, you will analyze Java™ code that declares one abstract class and derives three concrete classes from that one abstract class. You will read through the code and predict the output of the program.
Read through the linked Java™ code carefully.
Predict the result of running the Java™ code. Write your prediction into a Microsoft® Word document, focusing specifically on what text you think will appear on the console after running the Java™ code.
In the same Word document, answer the following question:
Why would a programmer choose to define a method in an abstract class, such as the Animal constructor method or the getName() method in the linked code example, as opposed to defining a method as abstract, such as the makeSound() method in the linked example?

Supporting Material: Week One Analyze Assignment Text File
/**********************************************************************
* Program: PRG/421 Week 1 Analyze Assignment
* Purpose: Analyze the coding for an abstract class
* and two derived classes, including overriding methods
* Programmer: Iam A. Student
* Class: PRG/421r13, Java Programming II
* Instructor:
* Creation Date: December 13, 2017
*
* Comments:
* Notice that in the abstract Animal class shown here, one method is
* concrete (the one that returns an animal's name) because all animals can
* be presumed to have a name. But one method, makeSound(), is declared as
* abstract, because each concrete animal must define/override the makeSound() method
* for itself--there is no generic sound that all animals make.
**********************************************************************/

package mytest;

// Animal is an abstract class because "animal" is conceptual
// for our purposes. We can't declare an instance of the Animal class,
// but we will be able to declare an instance of any concrete class
// that derives from the Animal class.
abstract class Animal {
// All animals have a name, so store that info here in the superclass.
// And make it private so that other programmers have to use the
// getter method to access the name of an animal.

private final String animalName;
// One-argument constructor requires a name.
public Animal(String aName) {
animalName = aName;
}

// Return the name of the animal when requested to do so via this
// getter method, getName().
public String getName() {
return animalName;
}

// Declare the makeSound() method abstract, as we have no way of knowing
// what sound a generic animal would make (in other words, this
// method MUST be defined differently for each type of animal,
// so we will not define it here--we will just declare a placeholder
// method in the animal superclass so that every class that derives from
// this superclass will need to provide an override method
// for makeSound()).
public abstract String makeSound();
};

// Create a concrete subclass named "Dog" that inherits from Animal.
// Because Dog is a concrete class, we can instantiate it.
class Dog extends Animal {
// This constructor passes the name of the dog to
// the Animal superclass to deal with.
public Dog(String nameOfDog) {
super(nameOfDog);
}

// This method is Dog-specific.
@Override
public String makeSound() {
return ("Woof");
}
}

// Create a concrete subclass named "Cat" that inherits from Animal.
// Because Cat is a concrete class, we can instantiate it.
class Cat extends Animal {
// This constructor passes the name of the cat on to the Animal
// superclass to deal with.
public Cat(String nameOfCat) {
super(nameOfCat);
}

// This method is Cat-specific.
@Override
public String makeSound() {
return ("Meow");
}
}

class Bird extends Animal {
// This constructor passes the name of the bird on to the Animal
// superclass to deal with.
public Bird (String nameOfBird) {
super(nameOfBird);
}

// This method is Bird-specific.
@Override
public String makeSound() {
return ("Squawk");
}
}

public class MyTest {
public static void main(String[] args) {
// Create an instance of the Dog class, passing it the name "Spot."
// The variable aDog that we create is of type Animal.
Animal aDog = new Dog("Spot");
// Create an instance of the Cat class, passing it the name "Fluffy."
// The variable aCat that we create is of type Animal.
Animal aCat = new Cat("Fluffy");
// Create an instance of (instantiate) the Bird class.
Animal aBird = new Bird("Tweety");
//Exercise two different methods of the aDog instance:
// 1) getName() (which was defined in the abstract Animal class)
// 2) makeSound() (which was defined in the concrete Dog class)
System.out.println("The dog named " + aDog.getName() + " will make this sound: " + aDog.makeSound());
//Exercise two different methods of the aCat instance:
// 1) getName() (which was defined in the abstract Animal class)
// 2) makeSound() (which was defined in the concrete Cat class)
System.out.println("The cat named " + aCat.getName() + " will make this sound: " + aCat.makeSound());
System.out.println("The bird named " + aBird.getName() + " will make this sound: " + aBird.makeSound());
}
}

ITSD424 Unit 1 Famous Favorite Subs

We are developing this application
1. User will choose from menu item
2. User will review ordered items
3. Each item will have a unit price
4. Order details will show unit price plus total price
5. Use will Press order button to place order

For this Unit
Assignment Description
At this point, you are ready to start developing Java code to ask questions on customer information and the sub sandwich that customers want to order. You are only concerned with the functionality to request and provide feedback on what the customer entered.
Your main focus is on defining your classes and abstract classes and utilizing the concept of inheritance and polymorphism for the final sub the customer orders. You will first prompt for the customer name and delivery address, like in this sample that prompts for the customer name:

Then, you will prompt for the beverage, sub bread, sub type, and sub size.
You should present a message echoing back all of the information that the customer entered, similar to the following example presenting the customer’s name with a message:

Make sure you prompt for the four attributes (beverage, bread, type, and size) that you will need to request from the customer to define for the final sub and beverage selection. Also, be sure to comment all of your code to demonstrate that you understand what the code is doing.