Question

Create a class called Employee that includes three instance variables- \(a\) first name (type String), a last name (type String) and a monthly salary (double). Provide 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, do not set its value. Write a test app 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

The Employee class is defined with a constructor, getters, and setters. The EmployeeTest class demonstrates creating Employee objects, calculating yearly salaries, giving a raise, and displaying new yearly salaries.

Step-by-step solution

Defining the Employee Class

Start by creating a Java class named Employee. Include the three private instance variables: firstName (type String), lastName (type String), and monthlySalary (type double).

Creating the Constructor

Define a constructor for the Employee class that takes three parameters to initialize the instance variables. Use 'this' keyword to refer to instance variables.

Implementing Get and Set Methods

Generate getter and setter methods for each instance variable. Ensure that the set method for monthlySalary checks if the input is positive before setting the value.

Defining the EmployeeTest Class

Create a class named EmployeeTest. In the main method, instantiate two Employee objects with their initial state using the constructor.

Calculating Yearly Salaries

In the EmployeeTest class, write code to calculate and display the yearly salary for each Employee object by multiplying the monthlySalary by 12.

Applying a Raise and Recalculating Salaries

Implement a code snippet in the EmployeeTest class that increases the Employee's monthlySalary by 10%, recalculates the yearly salary, and displays it.

Key concepts

Class and Object

In Java, a class is a blueprint from which individual objects are created. It encapsulates data for the object and methods to manipulate that data. For example, the Employee class in the given exercise defines a type of object that has a first name, a last name, and a monthly salary.

A object is an instance of a class. When you create an Employee object, you are creating an instance with its own specific values for the attributes defined in the class. The process of creating an object from a class is known as instantiation. In the EmployeeTest class, two instances of Employee are created, each with its distinct data.

Encapsulation

Encapsulation is a fundamental principle of object-oriented programming that restricts direct access to some of an object's components, which is a means of preventing unauthorized access and misuse. It is like putting the internal state of an object inside a protective shell. The Employee class demonstrates encapsulation by making its instance variables private, which means they cannot be directly accessed from outside the class.

Encapsulation ensures that the internal representation of an object is hidden from the outside. Instead, interactions are possible through public methods, often called getter and setter methods, which provide a controlled way to access and modify the hidden data.

Constructor

A constructor in Java is a special method that is called when an object is instantiated. It sets up the initial state of the object by initializing its attributes. In the Employee class, a constructor with three parameters is provided to initialize the first name, last name, and monthly salary of an employee. The this keyword is important within a constructor because it helps distinguish between class instance variables and parameters that are passed into the constructor, especially when they have the same names.

Instance Variables

Instance variables are the attributes of an object, and each object has its own set of instance variables. These variables hold the data that is unique to each object. In the Employee class, the instance variables include firstName, lastName, and monthlySalary. These variables should be declared as private to adhere to the encapsulation principle; this prevents other classes from directly altering the state of an object.

Getter and Setter Methods

Getter and setter methods are public methods that provide access to an object's private data. The getter method returns the value of a private variable, whereas the setter method allows you to modify it. Following encapsulation best practices, the Employee class uses these methods to control access to its private variables. For example, the setter method for monthlySalary includes a check to ensure that the salary is not set to a negative value, thus protecting the object's state from invalid data.

Control Structures

Control structures dictate the flow of execution in a program. There are different types, including if-else statements, for loops, and while loops, which allow developers to implement logic that makes decisions, repeats operations, or executes code based on certain conditions.

In the context of the Employee class, control structures could be used within the setter methods to validate input, such as ensuring a positive salary before it is set. Additionally, loops might be used in the EmployeeTest class to iterate through an array of Employee objects, apply the salary raise, or calculate and display yearly salaries.