You have to design your own Java console application for any valid problem that your application
must solve. Your solution can include solving a business problem, a new idea, or a game. Your
application must use concepts such as arrays, loops, inheritance, constructors, and information
hiding. Output must be shown in the form of a report using the console. You must also write unit
tests to validate that your code achieves the desired result.
In your solution, make use of as many concepts and components dealt with in this course, but pay
special attention to the following learning units:
• Learning Unit 1: Advanced arrays
• Learning Unit 2: Introduction to Inheritance
in java
Problem: Designing a library management system using Java console application.
Solution:
1. Create a class called Book with the following attributes: title, author, publication year, and availability status (boolean).
2. Create a class called User with the following attributes: name, age, and borrowedBooks (array of Book objects).
3. Create another class called Library with the following attributes: books (array of Book objects), users (array of User objects), and totalNumberOfBooks (int).
4. Implement the following methods in the Library class:
- addBook(): to add a book to the library.
- removeBook(): to remove a book from the library.
- displayAvailableBooks(): to display the list of available books.
- displayBorrowedBooks(): to display the list of borrowed books.
- borrowBook(): to allow a user to borrow a book.
- returnBook(): to allow a user to return a book.
- addUser(): to add a user to the library.
- removeUser(): to remove a user from the library.
- displayUsers(): to display the list of users.
5. Use loops to iterate over arrays and perform the required operations.
6. Use constructors to initialize objects with initial values.
7. Use inheritance to create the following classes:
- FictionBook (subclass of Book): with an additional attribute called genre.
- NonFictionBook (subclass of Book): with an additional attribute called topic.
8. Use information hiding by making attributes private and providing getters and setters for accessing/modifying their values.
9. Write unit tests to validate the functionality of the code.
Example Code:
```java
public class Book {
private String title;
private String author;
private int publicationYear;
private boolean availability;
// Constructor
public Book(String title, String author, int publicationYear) {
this.title = title;
this.author = author;
this.publicationYear = publicationYear;
this.availability = true;
}
// Getters and setters
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getPublicationYear() {
return publicationYear;
}
public void setPublicationYear(int publicationYear) {
this.publicationYear = publicationYear;
}
public boolean isAvailability() {
return availability;
}
public void setAvailability(boolean availability) {
this.availability = availability;
}
}
public class User {
private String name;
private int age;
private Book[] borrowedBooks;
// Constructor
public User(String name, int age, Book[] borrowedBooks) {
this.name = name;
this.age = age;
this.borrowedBooks = borrowedBooks;
}
// Getters and setters
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Book[] getBorrowedBooks() {
return borrowedBooks;
}
public void setBorrowedBooks(Book[] borrowedBooks) {
this.borrowedBooks = borrowedBooks;
}
}
public class Library {
private Book[] books;
private User[] users;
private int totalNumberOfBooks;
// Constructor
public Library(Book[] books, User[] users, int totalNumberOfBooks) {
this.books = books;
this.users = users;
this.totalNumberOfBooks = totalNumberOfBooks;
}
// Methods
public void addBook(Book book) {
// Add book to the library
}
public void removeBook(Book book) {
// Remove book from the library
}
public void displayAvailableBooks() {
// Display list of available books
}
public void displayBorrowedBooks() {
// Display list of borrowed books
}
public void borrowBook(Book book, User user) {
// Allows a user to borrow a book
}
public void returnBook(Book book, User user) {
// Allows a user to return a book
}
public void addUser(User user) {
// Add user to the library
}
public void removeUser(User user) {
// Remove user from the library
}
public void displayUsers() {
// Display list of users
}
}
public class FictionBook extends Book {
private String genre;
// Constructor
public FictionBook(String title, String author, int publicationYear, String genre) {
super(title, author, publicationYear);
this.genre = genre;
}
// Getter and setter for genre
public String getGenre() {
return genre;
}
public void setGenre(String genre) {
this.genre = genre;
}
}
public class NonFictionBook extends Book {
private String topic;
// Constructor
public NonFictionBook(String title, String author, int publicationYear, String topic) {
super(title, author, publicationYear);
this.topic = topic;
}
// Getter and setter for topic
public String getTopic() {
return topic;
}
public void setTopic(String topic) {
this.topic = topic;
}
}
// Unit tests
public class LibraryTest {
// Write unit tests to validate the functionality of the Library class
}
```
This solution uses the concepts of arrays (for managing books and users), loops (for iterating over arrays), inheritance (for creating FictionBook and NonFictionBook subclasses), constructors (for initializing objects), and information hiding (by making attributes private and providing getters and setters). The output is displayed in the console as a report. Unit tests are also written to validate the code.
Sure! Let's design a console application for a library management system using Java. This application will allow librarians to add books, search for books, and display the information of all books in the library. We will use concepts such as arrays, loops, inheritance, constructors, and information hiding. Here's a step-by-step guide to implementing this solution:
Step 1: Create a Book class
- The Book class will have private instance variables such as title, author, and ISBN.
- Include a constructor that initializes the book's title, author, and ISBN.
- Implement getters and setters for each instance variable.
Step 2: Create a Library class
- The Library class will have an array to store Book objects, as well as other necessary variables.
- Include a constructor that initializes the array and other variables.
- Implement methods to add a book, search for a book, and display all books in the library.
- Use loops to iterate through the array and perform the desired operations.
Step 3: Inherit from the Book class
- Create a subclass, such as Magazine, that inherits from the Book class.
- Add additional instance variables and methods specific to magazines.
- Override appropriate methods from the Book class, if necessary.
Step 4: Implement unit tests
- Write unit tests using a testing framework (e.g., JUnit) to validate the functionality of your code.
- Test each method in the Library class to ensure they produce the expected results.
Step 5: Implement a console application
- Create a main method in a separate class to serve as the entry point of the application.
- Instantiate a Library object and perform operations such as adding books, searching for books, and displaying all books.
- Use the console to receive user input, and display the results in a formatted report.
That's it! By following these steps, you will be able to design a Java console application for a library management system that incorporates concepts such as arrays, loops, inheritance, constructors, and information hiding. Remember to write unit tests to validate your code and ensure it meets the desired requirements.
Sure! I can give you an example of a Java console application that incorporates arrays, loops, inheritance, constructors, and information hiding. Let's create a simple inventory management system for a store.
First, we'll define a base class called "Product" that represents a generic product. It will have properties such as name, price, and quantity. We'll also have a constructor to initialize these properties and getter methods to access them. Here's the code for the Product class:
```java
public class Product {
private String name;
private double price;
private int quantity;
public Product(String name, double price, int quantity) {
this.name = name;
this.price = price;
this.quantity = quantity;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
public int getQuantity() {
return quantity;
}
}
```
Next, we'll create a derived class called "Inventory" that represents the store's inventory system. It will have an array to store multiple products and methods to add products, display the inventory, and check if a product is available. Here's the code for the Inventory class:
```java
public class Inventory {
private Product[] products;
private int count;
public Inventory(int capacity) {
products = new Product[capacity];
count = 0;
}
public void addProduct(Product product) {
if (count < products.length) {
products[count] = product;
count++;
} else {
System.out.println("Inventory is full!");
}
}
public void displayInventory() {
System.out.println("-------- Inventory --------");
for (Product product : products) {
if (product != null) {
System.out.println("Name: " + product.getName());
System.out.println("Price: $" + product.getPrice());
System.out.println("Quantity: " + product.getQuantity());
System.out.println("---------------------------");
}
}
}
public boolean checkProductAvailability(String productName) {
for (Product product : products) {
if (product != null && product.getName().equals(productName)) {
return true;
}
}
return false;
}
}
```
Finally, we can create a main class called "InventoryManagementSystem" to interact with the inventory system. We can initialize some products, add them to the inventory, display the inventory, and check product availability. Here's the code for the main class:
```java
public class InventoryManagementSystem {
public static void main(String[] args) {
Inventory inventory = new Inventory(5);
// Create some products
Product p1 = new Product("Laptop", 999.99, 5);
Product p2 = new Product("Phone", 599.99, 10);
Product p3 = new Product("Keyboard", 49.99, 20);
// Add products to inventory
inventory.addProduct(p1);
inventory.addProduct(p2);
inventory.addProduct(p3);
// Display inventory
inventory.displayInventory();
// Check product availability
System.out.println("Is 'Laptop' available? " + inventory.checkProductAvailability("Laptop"));
System.out.println("Is 'Mouse' available? " + inventory.checkProductAvailability("Mouse"));
}
}
```
To test our code, we can also write unit tests using a testing framework like JUnit. We can create test cases to validate the functionalities of our inventory management system.
This example demonstrates the use of arrays to store multiple products in the inventory, loops to iterate over the products, inheritance to create a derived class, constructors to initialize object properties, and information hiding by making the product properties private and providing getter methods to access them.
I hope this example helps you understand how to incorporate these concepts into a Java console application. Let me know if you have any further questions!