1.ABANG

2.SHARVESSH

3.RAJ

4.DAMIA

5.ISHA

1. ZHAO CHENBO 227220

2. ⁠LI RONG 226816

3. ⁠ZHONG ZIHANG 227210

4. ⁠GUO GAOMING 226246

5. ⁠SHU QI 226972

6. Zhang tengyin 227184

1. Nazira

2. ⁠Ghaidaa

3. ⁠Ayuni

4. ⁠Farah

5. ⁠Najla

1.Akmal

2.Ikmal

3.Mirzan

4.Wan Harith

5.Zhang Yunhe

6Dai Shangxi

1. Izzah

2. Filza

3. Alfian

4. Iman

5. Hazim

1. Sharman

2. Navein

3. Manish

4. Ravi Dhanis Al Fayad

5. Ahda Dzia Ulhaq

You are required to design a simple employee management system using abstract classes and inheritance.

1. Create an abstract class named Employee with the following:

• Private attributes: name (String) and id (int)

• A constructor to initialize the attributes

• Getter and setter methods for both attributes

• A toString() method that returns a string with the employee’s name and ID

• An abstract method named calculateSalary() that returns a double

2. Create a subclass named FullTimeEmployee that extends Employee, and:

• Add a private attribute: monthlySalary (double)

• Provide constructor, getter, and setter for monthlySalary

• Implement the calculateSalary() method (which just returns the monthly salary)

• Override the toString() method to also include the monthly salary

  
  

3. In your main method (inside TestEmployee class), create an object of FullTimeEmployee and display:

• The result of the toString() method

• The result of the calculateSalary() method

• Interface class

• Classes for the payment methods

In some of these classes there will be several methods including getter,setter and toString() method. The interface class will be the superclass.

For the main method, ask the user for input and display the results.

// Abstract class

abstract class Employee {

// Attributes

private String name;

private int id;

// Constructor

public Employee(String name, int id) {

this.name = name;

this.id = id;

}

// Abstract method

public abstract double calculateSalary();

// Getter and Setter

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;.

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

// toString method

public String toString() {

return "Employee Name: " + name + ", ID: " + id;

}

}

// Concrete subclass

class FullTimeEmployee extends Employee {

private double monthlySalary;

public FullTimeEmployee(String name, int id, double monthlySalary) {

super(name, id);

this.monthlySalary = monthlySalary;

}

// Implement abstract method

public double calculateSalary() {

return monthlySalary;

}

// Getter and Setter

public double getMonthlySalary() {

return monthlySalary;

}

public void setMonthlySalary(double monthlySalary) {

this.monthlySalary = monthlySalary;

}

// Override toString to include salary

public String toString() {

return super.toString() + ", Monthly Salary: RM" + monthlySalary;

}

}

// Main class

public class TestEmployee {

public static void main(String[] args) {

FullTimeEmployee emp1 = new FullTimeEmployee("Adam Hakimi", 101, 3000.0);

System.out.println(emp1.toString());

System.out.println("Calculated Salary: RM" + emp1.calculateSalary());

}

}

You are required to complete the following tasks:

1.Create an abstract class Animal with:

• Private fields: name (String), age (int)

• Constructor to initialize name and age

• Abstract method: makeSound()

• Concrete method: eat() that prints "[name] is eating."

• Getter and setter methods for all fields

• Override the toString() method to return:
  "Animal[name=..., age=...]"

  2.Create two subclasses: Dog and Cat that extend Animal:

  • Dog should have an additional field: breed (String)

  • Cat should have an additional field: color (String)

  • Both subclasses must override the makeSound() method:

    • Dog: prints "Woof!"

    • Cat: prints "Meow!"

  • Both subclasses must override toString() and include their own additional fields using super.toString()

    3.Create a class AnimalTest that:

    • Creates a Cat object and a Dog object (using Animal as the reference type)

    • Calls their eat(), makeSound(), and toString() methods

    • Prints the results to the console

• An abstract class Employee with common attributes (name, salary) and an abstract method calculateBonus().

• Two subclasses: FullTimeEmployee and PartTimeEmployee, which extend Employee and implement calculateBonus() differently.

• Each class must have multiple methods related to their behavior.

• Include constructors (with and without arguments).

• Include getter and setter methods.

• Override the toString() method to display employee details.

• Create a Department class that uses composition or aggregation to relate to multiple Employee objects like this

private String name;

private int age;

// Construct Methods

public Animal(String name, int age) { this.name = name; this.age = age; }

// Abstract Methods

public abstract void makeSound();

// Regular Methods

public void eat() {

System.out.println(name + " is eating.");

}

// Getter and Setter

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;

}

// toString Method

@Override

public String toString() {

return "Animal[name=" + name + ", age=" + age + "]"; }

}

public class Dog extends Animal {

private String breed;

public Dog(String name, int age, String breed) {

super(name, age);

this.breed = breed;

}

@Override

public void makeSound() {

System.out.println("Woof!");

}

public String getBreed() {

return breed;

}

public void setBreed(String breed) {

this.breed = breed;

}

@Override

public String toString() {

return super.toString() + ", breed=" + breed;

}

}

public class Cat extends Animal {

private String color;

public Cat(String name, int age, String color) {

super(name, age);

this.color = color;

}

@Override

public void makeSound() {

System.out.println("Meow!");

}

public String getColor() {

return color;

}

public void setColor(String color) {

this.color = color;

}

@Override

public String toString() {

return super.toString() + ", color=" + color;

}

}

public class AnimalTest {

public static void main(String[] args) {

Animal cat = new Cat("Mimi", 2, "White");

Animal dog = new Dog("Buddy", 4, "Golden Retriever");

cat.eat();

cat.makeSound();

System.out.println(cat.toString());

dog.eat();

dog.makeSound();

System.out.println(dog.toString());

}

}

Scenario:

You are hired to design a Payment Processing System. The system must handle different types of payments such as Credit Card, PayPal, and Crypto Payment. All payment methods must provide a processPayment() method to handle the payment. Each payment method should store and manage the payer’s name.

---

Requirements:

1. Define an interface PaymentMethod with the method processPayment(double amount).

2. Create a superclass Payer with:

A private attribute name.

A no-argument constructor that sets the name to "Unknown".

A constructor with an argument to set the payer’s name.

Getter and setter for the name attribute.

A toString() method that returns "Payer Name: <name>".

3. Create two subclasses that extend Payer and implement PaymentMethod:

CreditCardPayment

PayPalPayment

4. In each subclass:

Override processPayment(double amount) to display a message like:

"Processing Credit Card payment of $<amount> by <payer name>".

Override toString() to include the payer name and the payment method.

5. Write a PaymentDemo class to:

Create a CreditCardPayment object with the payer name "Alice".

Create a PayPalPayment object with the payer name "Bob".

Process payments of $150.75 for Alice and $99.99 for Bob.

Display the toString() details for both.

---

Expected Output:

Processing Credit Card payment of $150.75 by Alice

Processing PayPal payment of $99.99 by Bob

Payer Name: Alice, Payment Method: Credit Card

Payer Name: Bob, Payment Method: PayPal

• Create an abstract class called Product with the following:

Protected variables: String name, double price, int quantity

• A constructor with arguments to initialize the variables

Abstract method: double calculateTotalPrice()

• A regular method: void displayInfo()

Getter and Setter methods for all variables

toString() method to show product info in a readable format

• Create a subclass called PerishableProduct that extends Product and adds:

One more variable: int expiryDays

A constructor that uses super(...) to call the parent class

• Getter and Setter for expiryDays

Override the calculateTotalPrice() method:

If expiryDays <= 3, give a 20% discount

• Otherwise, no discount

Create a Main class to:

Create one object of PerishableProduct

Display all product information using toString() and displayInfo()

• Show the total price after discount using calculateTotalPrice()

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

// Abstract Superclass

abstract class Employee {

protected String name;

protected double salary;

public Employee() {}

public Employee(String name, double salary) {

this.name = name;

this.salary = salary;

}

public abstract double calculateBonus();

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public double getSalary() { return salary; }

public void setSalary(double salary) { this.salary = salary; }

public String toString() {

return "Name: " + name + "\nSalary: RM" + salary;

}

}

// Full-Time Employee

class FullTimeEmployee extends Employee {

private int yearsOfService;

public FullTimeEmployee() {}

public FullTimeEmployee(String name, double salary, int yearsOfService) {

super(name, salary);

this.yearsOfService = yearsOfService;

}

public int getYearsOfService() { return yearsOfService; }

public void setYearsOfService(int yearsOfService) { this.yearsOfService = yearsOfService; }

@Override

public double calculateBonus() {

return 0.10 salary yearsOfService;

}

public void applyLeave(int days) {

System.out.println(name + " applied for " + days + " days of leave.");

}

@Override

public String toString() {

return super.toString() + "\nType: Full-Time\nBonus: RM" + calculateBonus();

}

}

// Part-Time Employee

class PartTimeEmployee extends Employee {

private int hoursWorked;

public PartTimeEmployee() {}

public PartTimeEmployee(String name, double salary, int hoursWorked) {

super(name, salary);

this.hoursWorked = hoursWorked;

}

public int getHoursWorked() { return hoursWorked; }

public void setHoursWorked(int hoursWorked) { this.hoursWorked = hoursWorked; }

@Override

public double calculateBonus() {

return 10.0 * hoursWorked;

}

public void logHours(int hours) {

System.out.println(name + " logged " + hours + " extra hours.");

}

@Override

public String toString() {

return super.toString() + "\nType: Part-Time\nBonus: RM" + calculateBonus();

}

}

// Department Class

class Department {

private String departmentName;

private List<Employee> employees;

public Department(String departmentName) {

this.departmentName = departmentName;

this.employees = new ArrayList<>();

}

public void addEmployee(Employee e) {

employees.add(e);

}

public void showAllEmployees() {

System.out.println("\nDepartment: " + departmentName);

for (Employee e : employees) {

System.out.println("---------------------");

System.out.println(e.toString());

}

}

}

// Main Class

public class oopLabActivity {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

Department dept = new Department("IT");

System.out.print("How many employees do you want to enter? ");

int numEmployees = scanner.nextInt();

scanner.nextLine(); // consume newline

for (int i = 1; i <= numEmployees; i++) {

System.out.println("\nEnter details for employee #" + i);

System.out.print("Enter name: ");

String name = scanner.nextLine();

System.out.print("Enter salary: RM");

double salary = scanner.nextDouble();

scanner.nextLine();

System.out.print("Is the employee Full-Time or Part-Time? (F/P): ");

String type = scanner.nextLine().trim().toUpperCase();

if (type.equals("F")) {

System.out.print("Enter years of service: ");

int years = scanner.nextInt();

scanner.nextLine(); // consume newline

FullTimeEmployee fte = new FullTimeEmployee(name, salary, years);

dept.addEmployee(fte);

} else if (type.equals("P")) {

System.out.print("Enter hours worked: ");

int hours = scanner.nextInt();

scanner.nextLine(); // consume newline

PartTimeEmployee pte = new PartTimeEmployee(name, salary, hours);

dept.addEmployee(pte);

} else {

System.out.println("Invalid type. Skipping this employee.");

}

}

// Display employees

dept.showAllEmployees();

scanner.close();

}

}

import java.util.Scanner;

import java.util.ArrayList;

abstract class Product {

protected String name;

protected double price;

protected int quantity;

public Product(String name, double price, int quantity) {

this.name = name;

this.price = price;

this.quantity = quantity;

}

public abstract double calculateTotalPrice();

public void displayInfo() {

System.out.println("\nProduct Info:");

System.out.println("Name: " + name);

System.out.println("Price: RM" + price);

System.out.println("Quantity: " + quantity);

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

public int getQuantity() {

return quantity;

}

public void setQuantity(int quantity) {

this.quantity = quantity;

}

}

class PerishableProduct extends Product {

private int expiryDays;

public PerishableProduct(String name, double price, int quantity, int expiryDays) {

super(name, price, quantity);

this.expiryDays = expiryDays;

}

@Override

public double calculateTotalPrice() {

double total = price * quantity;

if (expiryDays <= 7) {

total *= 0.5;

} else {

total *= 0.8;

}

return total;

}

@Override

public String toString() {

return super.toString() + "\nExpiry in: " + expiryDays + " days";

}

}

public class firstTry {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

ArrayList<PerishableProduct> inventory = new ArrayList<>();

String choice;

do {

System.out.print("Enter product name: ");

String name = input.nextLine();

System.out.print("Enter product price: ");

double price = input.nextDouble();

System.out.print("Enter quantity: ");

int quantity = input.nextInt();

System.out.print("Enter days until expiry: ");

int expiryDays = input.nextInt();

input.nextLine();

PerishableProduct product = new PerishableProduct(name, price, quantity, expiryDays);

inventory.add(product);

System.out.print("\nDo you want to add another item? (y/n): ");

choice = input.nextLine().toLowerCase();

} while (choice.equals("y"));

// === Inventory Output ===

double grandTotal = 0;

int totalItems = 0;

System.out.println("\n=== Inventory Details ===");

for (PerishableProduct item : inventory) {

System.out.println("\n--- Product: " + item.getName() + " ---");

item.displayInfo();

double itemTotal = item.calculateTotalPrice();

System.out.printf("Total price for this item: RM%.2f\n", itemTotal);

grandTotal += itemTotal;

totalItems += item.quantity;

}

// === Final Summary ===

System.out.println("\n=== Purchase Summary ===");

System.out.println("Total number of items bought: " + totalItems);

System.out.printf("Total price for all items: RM%.2f\n", grandTotal);

input.close();

}

}

import java.util.Scanner;

interface PaymentInterface {

void makePayment();

String getPaymentDetails();

}

class CreditCardPayment implements PaymentInterface {

private double amount;

private String cardNumber;

public CreditCardPayment(double amount, String cardNumber) {

if (amount <= 0) {

throw new IllegalArgumentException("Amount must be positive.");

}

if (cardNumber == null || cardNumber.length() < 5) {

throw new IllegalArgumentException("Invalid credit card number.");

}

this.amount = amount;

this.cardNumber = cardNumber;

}

public double getAmount() {

return amount;

}

public void setAmount(double amount) {

if (amount <= 0) {

throw new IllegalArgumentException("Amount must be positive.");

}

this.amount = amount;

}

public String getCardNumber() {

return cardNumber;

}

public void setCardNumber(String cardNumber) {

this.cardNumber = cardNumber;

}

public void makePayment() {

System.out.println("Paid $" + amount + " using Credit Card ending with " +

cardNumber.substring(cardNumber.length() - 4));

}

public String getPaymentDetails() {

return "Credit Card Payment of $" + amount;

}

public String toString() {

return "CreditCardPayment{amount=$" + amount + ", cardNumber=" +

cardNumber.substring(cardNumber.length() - 4) + "}";

}

}

class PayPalPayment implements PaymentInterface {

amount

private double amount;

private String email;

public PayPalPayment(double amount, String email) {

if (amount <= 0) {

throw new IllegalArgumentException("Amount must be positive.");

}

if (email == null || !email.contains("@")) {

throw new IllegalArgumentException("Invalid PayPal email.");

}

this.amount = amount;

this.email = email;

}

public double getAmount() {

return amount;

}

public void setAmount(double amount) {

if (amount <= 0) {

throw new IllegalArgumentException("Amount must be positive.");

}

this.amount = amount;

}

public String getEmail() {

return email;

}

public void setEmail(String email) {

this.email = email;

}

public void makePayment() {

System.out.println("Paid $" + amount + " using PayPal account: " + email);

}

public String getPaymentDetails() {

return "PayPal Payment of $" + amount;

}

public String toString() {

return "PayPalPayment{amount=$" + amount + ", email=" + email + "}";

}

}

public class PaymentApp12 {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

try {

System.out.print("Enter payment method (credit/paypal): ");

String method = scanner.nextLine().toLowerCase();

System.out.print("Enter payment amount: ");

double amount = scanner.nextDouble();

scanner.nextLine(); // consume newline

PaymentInterface payment;

if (method.equals("credit")) {

System.out.print("Enter credit card number: ");

String cardNumber = scanner.nextLine();

payment = new CreditCardPayment(amount, cardNumber);

}

else if (method.equals("paypal")) {

System.out.print("Enter PayPal email: ");

String email = scanner.nextLine();

payment = new PayPalPayment(amount, email);

}

else {

throw new IllegalArgumentException("Unsupported payment method.");

}

System.out.println("\n--- Payment Summary ---");

payment.makePayment();

System.out.println(payment.toString());

System.out.println("Details: " + payment.getPaymentDetails());

} catch (IllegalArgumentException e) {

// Handle input errors such as invalid amount or method

System.out.println("Input error: " + e.getMessage());

} catch (Exception e) {

// Handle other unexpected exceptions

System.out.println("Unexpected error: " + e.getMessage());

}

scanner.close();

}

}

void processPayment(double amount);

}

public class Payer {

private String name;

// No-arg constructor

public Payer() {

this.name = "Unknown";

}

// Constructor with argument

public Payer(String name) {

this.name = name;

}

// Getter

public String getName() {

return name;

}

// Setter

public void setName(String name) {

this.name = name;

}

// toString method

public String toString() {

return "Payer Name: " + name;

}

}

public class CreditCardPayment extends Payer implements PaymentMethod {

public CreditCardPayment(String name) {

super(name);

}

@Override

public void processPayment(double amount) {

System.out.println("Processing Credit Card payment of $" + amount + " by " + getName());

}

@Override

public String toString() {

return super.toString() + ", Payment Method: Credit Card";

}

}

public class PayPalPayment extends Payer implements PaymentMethod {

public PayPalPayment(String name) {

super(name);

}

@Override

public void processPayment(double amount) {

System.out.println("Processing PayPal payment of $" + amount + " by " + getName());

}

@Override

public String toString() {

return super.toString() + ", Payment Method: PayPal";

}

}

public class PaymentDemo {

public static void main(String[] args) {

CreditCardPayment alicePayment = new CreditCardPayment("Alice");

PayPalPayment bobPayment = new PayPalPayment("Bob");

alicePayment.processPayment(150.75);

bobPayment.processPayment(99.99);

System.out.println(alicePayment.toString());

System.out.println(bobPayment.toString());

}

}

void processPayment(double amount);

}

public class Payer {

private String name;

// No-arg constructor

public Payer() {

this.name = "Unknown";

}

// Constructor with argument

public Payer(String name) {

this.name = name;

}

// Getter

public String getName() {

return name;

}

// Setter

public void setName(String name) {

this.name = name;

}

// toString method

public String toString() {

return "Payer Name: " + name;

}

}

public class CreditCardPayment extends Payer implements PaymentMethod {

public CreditCardPayment(String name) {

super(name);

}

@Override

public void processPayment(double amount) {

System.out.println("Processing Credit Card payment of $" + amount + " by " + getName());

}

@Override

public String toString() {

return super.toString() + ", Payment Method: Credit Card";

}

}

public class PayPalPayment extends Payer implements PaymentMethod {

public PayPalPayment(String name) {

super(name);

}

@Override

public void processPayment(double amount) {

System.out.println("Processing PayPal payment of $" + amount + " by " + getName());

}

@Override

public String toString() {

return super.toString() + ", Payment Method: PayPal";

}

}

public class PaymentDemo {

public static void main(String[] args) {

CreditCardPayment alicePayment = new CreditCardPayment("Alice");

PayPalPayment bobPayment = new PayPalPayment("Bob");

alicePayment.processPayment(150.75);

bobPayment.processPayment(99.99);

System.out.println(alicePayment.toString());

System.out.println(bobPayment.toString());

}

}