Java Code Problem 1) a) Object-oriented languages like Java are designed to make
ID: 3792694 • Letter: J
Question
Java Code Problem
1)
a) Object-oriented languages like Java are designed to make it easy for programmers to implement software versions of real-world objects. In learning Java, an important skill to master is the ability to represent an object in code. Objects that we model are described using Java classes, so we have chosen to begin this lab by modeling a very simple, everyday object: a door.
Write the code to create a class that models a door object. Don’t worry about the internal details just yet. Just give the class a name and an empty body for the moment. We will add more to the class shortly.
b) When modeling an object as a class, we also need to describe the properties or attributes an object possesses. An everyday object that we wish to model in software always has one or more properties that describe it. For instance a door object might have a name like “Front” or “Side” to distinguish it from other doors. Another property that could describe a door is its state: “open” or “closed”. Properties of objects are described in code by using nouns like “state” or “name” to create instance variables that hold values.
Add instance variables to your Door class body for the name of the door and its state. Experience has shown that we almost always want to limit the visibility of instance variables to code inside the same class, so make the access modifiers of state and name private. And because the state and name properties have values like “open” or “front”, let the instance variables you create be of type String.
c) Objects also have operations which can be invoked on the object and which may change the object in some way. For instance, the operations for a door object could be “open” and “close”. An operation on an object corresponds to a Java method and is described in code by using a verb like “open” or “close”. Invoking a method may change the value of an instance variable. For example, invoking close() would change the value of the state variable from “open” to “closed”.
Declare methods for open and close. Because we usually want to allow free access to the methods a class contains, make the access modifier for each method public.
d) Now that we have a Door class, we would like to be able to create some Door objects. Java constructors are components of a class whose purpose is to create objects of the given class and to initialize the instance variables of the object. Java provides a default constructor for every class and the Door class is no exception. Unfortunately, the default constructor that Java provides initializes the state and name variables to null. This is unacceptable.
Add a constructor for the Door class that passes two parameters: the name of the door and its initial state. Because we want to use the constructor outside of the class, make the access modifier for the constructor public.
e) It is often convenient to have accessor methods that operate on a single instance variable. Here is an accessor method for the name variable:
public String getName()
{
return name;
}
The word String in front of getName() indicates that the method returns a String when it is invoked. The body is simple and just returns the value of name.
Add this method to your class and write a similar accessor method for the instance variable state.
f) Many instance variables in a class will have corresponding mutator methods that allow you to change the value of the variable. Here is a mutator method for the name variable:
public void setName(String newName)
{
name = newName;
}
The word void in front of setName() indicates that the method does not return a value when it is invoked. The body is simple and copies the value of the parameter newName to instance variable name.
Add this method to the class and write a similar mutator method for the instance variable state.
g) Compile and run the code below:
/**
A class to test the Door class.
*/
public class DoorTester
{
/**
Tests the methods of the Door class
@param args not used
*/
public static void main(String[] args)
{
Door frontDoor = new Door("Front", "open");
System.out.println("The front door is " + frontDoor.getState());
System.out.println("Expected: open");
Door backDoor = new Door("Back", "closed");
System.out.println("The back door is " + backDoor.getState());
System.out.println("Expected: closed");
// Use the mutator to change the state variable
backDoor.setState("open");
System.out.println("The back door is " + backDoor.getState());
System.out.println("Expected: open");
// Add code to test the setName mutator here
}
}
Create a third Door object called “sideDoor” the name property “Side” and an initial state of “closed”. Verify that the object was properly created. Use the mutator to change the state of object sideDoor to “open”. Verify that the mutator is working.
h) Consider the variable state in the class Door and the variable newState in the mutator for state. What kind of variable is state? What kind of variable is newState? When do these variables exist?
i)Consider the line below which was taken from the main method in 1.7 above.
backDoor.setState("open");
What is the implicit parameter that is passed by this method call? What is the explicit parameter?
Explanation / Answer
public class Door {
String name;
String state;
String open="open";
String close="close";
Door(){
}
Door(String name,String state){
setname(name);
setstate(state);
}
public void setstate(String state) {
this.state=state;
}
public void setname(String name) {
this.name=name;
}
public String getname(){
return name;
}
public String getstate(){
return state;
}
public String open(){
state=open;
return state;
}
public String close(){
state=close;
return state;
}
public String tostring(){
return "name of Door is:"+getname()+"and state is:"+getstate();
}
}
allmain.java
import java.util.*;
public class allmain {
public static void main(String[] args) {
Door frontDoor = new Door("Front", "open");
System.out.println("The front door is " + frontDoor.getstate());
System.out.println("Expected: open");
Door backDoor = new Door("Back", "closed");
System.out.println("The back door is " + backDoor.getstate());
System.out.println("Expected: closed");
backDoor.setstate("open");
System.out.println("The back door is " + backDoor.getstate());
System.out.println("Expected: open");
Door sidedoor =new Door("side","closed");
System.out.println("the side door is:"+sidedoor.getstate());
sidedoor.open();
System.out.println("the side door state changed to:"+sidedoor.getstate());
System.out.println(sidedoor.tostring());
}
}
output:
The front door is open
Expected: open
The back door is closed
Expected: closed
The back door is open
Expected: open
the side door is:closed
the side door state changed to:open
name of Door is:sideand state is:open
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.