Question

Create a class called Employee that includes three pieces of information as instance variables - a first name (type String), a last name (type String) and a monthly salary (double). Your class should have a constructor that initializes the three instance variables. Provide a set and a get method for each instance variable. If the monthly salary is not positive, set it to \(0.0 .\) Write a test application named EmployeeTest that demonstrates class Employee's capabilities. Create two Employee objects and display each object's yearly salary. Then give each Employee a \(10 \%\) raise and display each Employee's yearly salary again.

Short answer

Create a class `Employee` with proper constructor, getters, and setters; then test it with `EmployeeTest` by showing yearly salaries before and after a 10% raise.

Step-by-step solution

Define the Employee Class Structure

Start by defining a basic class structure for `Employee` in your chosen programming language (e.g., Java, Python). This will include instance variables for first name, last name, and monthly salary.

Initialize Instance Variables with a Constructor

Create a constructor in the `Employee` class that takes three parameters (first name, last name, monthly salary) and initializes the instance variables. Ensure that if the monthly salary is negative or zero, it should be set to `0.0`.

Implement Getters and Setters

Write a getter and setter for each instance variable in the `Employee` class. Ensure the setter for monthly salary includes validation to prevent negative values by setting the salary to `0.0` if a negative value is provided.

Calculate Yearly Salary

Create a method in the `Employee` class to return the yearly salary, calculated as `monthly salary x 12`. This can be a simple method that multiplies the current monthly salary by 12 and returns the result.

Implement EmployeeTest Class

In a separate class named `EmployeeTest`, create main logic to instantiate two `Employee` objects. Use the constructor to set initial values for first name, last name, and monthly salary.

Display Initial Yearly Salaries

Use the previously defined method to calculate and display the yearly salary for each `Employee` object created in the `EmployeeTest` class.

Apply a 10% Salary Raise

Modify each `Employee`'s monthly salary to reflect a 10% increase. This can be done by multiplying their current monthly salary by `1.10` and updating the instance variable using the setter method.

Display Yearly Salaries After Raise

After applying the raise, calculate and display the updated yearly salary for each `Employee` object. This should use the same method as before to correctly show the new values.

Key concepts

Instance Variables

In Java classes, instance variables are the blueprint for each object created from the class. Imagine instance variables as fields or attributes that store important data about the object. In our `Employee` class example, the instance variables include the first name, last name, and monthly salary of an employee.
These variables are given data values unique to each object, which enables them to maintain specific states or behaviors.
An instance variable is declared within a class but outside any method, and is accessed with `this` keyword in instance methods to differentiate them from local variables.
Common characteristics include:

• Being declared at the class level.
• Each object has its own copy of instance variables.
• They determine object-specific data as opposed to data shared among all class instances.

Constructor Method

The constructor is a special method used to initialize objects of a class. It's the place where instance variables get their first assigned values. Think of a constructor as the setup or preparation work needed whenever an `Employee` is created in our class example.
In Java, constructors have the same name as the class and do not return a type—this is a key characteristic distinguishing them from other methods.
Here's what a typical constructor does:

• Initializes instance variables, ensuring each object starts with valid data values.
• Validates inputs, such as checking for negative salaries and setting them to zero.
• Establishes essential object state right from creation, avoiding uninitialized objects.

Setters and Getters

Setters and getters are methods that encapsulate instance variables, offering an interface to modify and access those variables' values safely.
Getters (also known as accessor methods) enable you to obtain the value of a private instance variable, while setters (also known as mutator methods) allow you to modify it. In our Employee class, setters validate input, such as ensuring the salary isn't negative.
Benefits of using setters and getters include:

• Encapsulation: Protecting the data by limiting how it can be changed.
• Input validation: Setting rules, like salary not being negative.
• Maintaining control over how variables are accessed or modified.

Salary Calculation

In our `Employee` class, salary calculation involves computing the yearly earnings based on the stored monthly salary. This is generally done through a simple method that multiplies the monthly salary by twelve.
The calculation method is crucial for deriving meaningful financial information from the base data. In our test, the yearly salary effectively shows the employee's total compensation over a year, highlighting how pay adjustments occur.
Here's a breakdown of salary-related operations:

• Calculating yearly salary: Multiply monthly income by \(12\) to project annual earnings.
• Implementing raises: Adjust salary by a percentage, such as a \(10\%\) increase using \(1.1\times\text{current salary}\).
• Using getter methods to obtain up-to-date salary information.

Object-Oriented Programming

Object-Oriented Programming (OOP) is a paradigm that uses objects and classes to design software. In Java, everything revolves around objects—instances of classes which group together data and behavior.
Our `Employee` class example highlights OOP principles like encapsulation, where data fields are bundled together with methods operating on them.
OOP enhances productivity and code reusability, allowing developers to build flexible and scalable solutions by modeling real-world entities as objects.
Core concepts of OOP include:

• Encapsulation: Encapsulating data fields in a class and exposing only the necessary parts through methods.
• Inheritance: Allowing a new class to inherit features from another, fostering code reuse.
• Polymorphism: Enabling objects of different classes to be treated as objects of a common superclass.
• Abstraction: Hiding complex implementation details, exposing only needed functionality.