I have a class Rectangle laid out like this:
package Inheritance;
/**
*
* #author Jacob
*/
public class Rectangle {
final private int length;
final private int width;
public Rectangle (int l, int w)
{
length = l;
width = w;
}
public int getLength ()
{
return length;
}
public int getWidth ()
{
return width;
}
#Override
public String toString ()
{
return String.format ("Rectangle (%dX%d)", length, width);
}
}
I then need to create class square in the following way:
ad Square:
Square extends Rectangle /
No fields are declared in class Square /
It has a parameterized constructor with (only) one parameter /
The parameter is used to initialize both fields of Rectangle /
It has a method called getSide to expose the side-length of the square /
Override the toString method so that it will return a String of the following form: / Square(side) e.g. Square(4)
The values for the sides are going to be hard coded. Rectangle is going to have a width of 4. In order to get the side of the square to be 4 do I create an instance of rectangle and call the method getWidth and set that as the side length. Thats how I would think to do it but in that case I would only be using one of the fields so, My question is how do I initialize both fields? Can I call Rectangle and make length and width equal or is there some other way I should do it?
Here is the code for my Square class:
public class Square {
public Square (int side)
{
super(side, side);
}
public int getSide ()
{
return side;
}
#Override
public String toString ()
{
return String.format ("Square (%d)", side);
}
}
For the line super(side, side) I get the error constructor Object in class Object cannot be applied to given types. Required no arguments, found int, int. For my return statements I get that it cannot find the variable side.
The values for the sides are going to be hard coded.
I assume that you mean that you will hardcode the values for the width and length when you create a Rectangle and Square object (for example in main()). These values should absolutely not be hardcoded any where in the Rectangle and Square classes.
Rectangle is going to have a width of 4. In order to get the side of the square to be 4 do I create an instance of rectangle and call the method getWidth and set that as the side length.
Not at all. Rather, Square should have its own constructor which calls the Rectangle constructor with the same value for both the width and length:
public Square(int side) {
super(side, side); // Set the width and length to the same value.
}
Related
Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 2 months ago.
Improve this question
public class Wall {
private double width;
private double height;
public Wall() {}
public Wall(double width, double height) {
this.setHeight(height); // using method to set the required fields. //This method is called with unexpected behavior.
this.setWidth(width); // This is not getting called?
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
if (width <= 0) {
this.width = 0;
System.out.println("INVALID VALUE - The width of the wall is updated to :" + 0.0);
} else {
this.width = width;
System.out.println("The width of the wall is updated to :" + width);
}
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
if (height <= 0) {
this.height = 0;
System.out.println("INVALID VALUE - The width of the wall is updated to :" + 0.0);
} else {
this.height = height;
System.out.println("The height of the wall is updated to :" + height);
}
}
public double getArea() {
return width * height;
}
}
//OUTPUT
The width of the wall is updated to :10.0 \\ Expected
INVALID VALUE - The width of the wall is updated to :0.0 \\ not expected
//OUTPUT when parameter order in constructor is reversed
INVALID VALUE - The width of the wall is updated to :0.0 \\expected
The height of the wall is updated to :10.0 \\expected
The goal was to avoid code repetition and I chose to use the setter method in constructor. Also assuming since I am using methods and providing appropriate parameters, the order of the parameter should not matter.
I am not sure if it is supposed to work that way. I see that the method is being called with unexpected behavior.
Few doubts I have regarding the above
Not all methods are getting called in the constructor
Can these setter methods be static and perform operation on the object being created?
What would be the right way to do this?
Thank you
I see that the method is being called with unexpected behavior.
setHeight() actually performs as expected but it is not implemented as you'd expect it. You probably copied it from setWidth() and forgot to change the message so it would print "INVALID VALUE - The width of the wall is updated to : xxx".
the order of the parameter should not matter
The order in which you define the parameters doesn't matter from a technical point of view (unless you have a vargs parameter which needs to be last). However the order of definition leads to the requirement of providing values in the same order when calling the constructor.
Example: Wall(double width, double height) defines the 1st parameter is width and the 2nd is height.
Assume the following:
double width = 5.0;
double height = 7.0;
Wall w = new Wall(height, width);
Here, the names of the parameters don't matter but order does, i.e. w now has a width of 7 and a height of 5 even though the parameters were named otherwise.
What shouldn't matter in most cases is the order in which you call the setters inside the constructor - as long as they're independent.
This means the following 2 should be equivalent:
public Wall(double width, double height) {
this.setHeight(height);
this.setWidth(width);
}
public Wall(double width, double height) {
this.setWidth(width);
this.setHeight(height);
}
When would order matter? If setters were depending on it - not a good style though. Suppose setHeight() would check that height > width. Now if you'd not call setWidth() first setHeight() might behave differently. However, I repeat: this it not good style and should be avoided!
Not all methods are getting called in the constructor
Not sure what you're referring to but constructors don't have to call any method nor do you have to call all the setters there. It really depends on what you want to achieve.
Use constructors for mandatory parameters and setters for mutable ones (and potentially optional). Mutable parameters are those that could be changed after constructing an object, immutable ones should not change - there shouldn't be any setter for those (ideally declare those final and the compiler will complain about setters for those).
Summary:
mandatory + immutable parameters: use constructor only
mandatory + mutable parameters: use constructor which can call setters
optional + mutable parameters: use setters
optional + immutable parameters: use constructor only, potentially via constructor overloads
Can these setter methods be static and perform operation on the object being created?
No, setters should never be static because you'd need to pass the object anyway and thus it's cleaner to just have the setters there.
However, a constructor can call static methods if necessary. Suppose you have a condition to check that width < height which you'd want to call in the constructor and the setters. This could then look like this (simplified and lacking a lot of best practices to keep things simple):
//example of constructor calling the static method
public Wall(double width, double height) {
//check the condition on the input parameters
if( !checkCondition(width, height) ) {
throw new IllegalArgumentException("width >= height");
}
this.setHeight(height);
this.setWidth(width);
}
//example of setter calling the static method
public void setWidth(double width) {
//only set if the condition is met
if(checkCondition(width, this.height) {
//rest of your code
} else {
System.err.println("width would be < height, thus not updating width");
}
}
private static boolean checkCondition(double width, double height) {
return width < height;
}
I have coded a program using separate parts to find & display the area and perimeter of a rectangle. I am now supposed to create a void to display the length, width, area and perimeter. However, I can't seem to get it to display when I run the program. I will pop in my code and then the instructions of the task underneath in case I haven't explained it well enough.
public class Rectangle
{
public static void main(String[] args)
{
System.out.println (area(10,15));
System.out.println (perimeter(10, 15));
}
/**
* Returns the area of a rectangle
*/
public static int area (int length, int width)
{
return length * width;
}
/**
* Returns the perimeter of the rectangle
*/
public static int perimeter (int length, int width)
{
return 2 * (length + width);
}
public static void printRectangleDetails(int length, int width, int area, int perimeter)
{
System.out.println ("The length of the rectangle is " + length);
System.out.println ("The width of the rectangle is " + width);
System.out.println ("The area of the rectangle is " + area);
System.out.println ("The perimeter of the rectangle is " + perimeter);
}
}
The task information:
"Write a method called printRectangleDetailswhich, when given the height and width of a rectangle, prints four lines of output stating the height, width, area, and perimeter of the rectangle. The output should include suitable text explaining what the numbers area. Add suitable comments to the new method.printRectangleDetails()is a different kind of method fromareaand perimeter. It performs some actions (printing output) but does not return any result when it is called. Its output type must therefore be voidto show that it does not return a value, and it is an example of a void method. A call to a void method can be used as a standalone statement in your program. However, because a void method does not return a value, it cannot be used where an expression with a value is expected. Methods which return a value (non-void methods) can be used as both standalone statements and as expressions."
Edit - I have now seen this on the instructions "Replace the code in the main method with suitable calls of your printRectangleDetails()method." does this mean I should change the void main(String[] args) section to printRectangleDetails() & if so, how would I do this?
Other methods can be called inside methods, you are passing an int area and an int perimeter in your printRectangleDetails parentheses however, you do not have to do this. Your printRectangleDetails method should only know the width and height, and inside the method functions then it will call the other methods area(width, height) and perimeter(width, height) and pass the width and height to them.
For the Edit question, you do not have to change the main(String[] args), but since your new method printRectangleDetails already prints all the info of the rectangle including area and perimeter, then all you have to do is replace any methods inside main with a single call to printRectangleDetails.
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 5 years ago.
Improve this question
I am a newbie in Java. I have done a sample program that is finding the area of a rectangle. The code is below.
package rectangle;
public class Rectangle {
int length, width;
int rectArea() {
int area = length * width;
return (area);
}
}
class RectArea {
public static void main(String[] args) {
int area1;
Rectangle rect1 = new Rectangle();
rect.length = 14;
rect.width = 13;
area1 = rect.rectArea();
System.out.println("Area1=" + area1);
}
}
In the above code length and width are variables which declare in class Rectangle. Now area is also a variable which holds the data length * width and this areavariable is also declared in class Rectangle
We can access length and width variables from another class named RectArea by using the dot operator. But why can't we access area variable which is declared in Rectangle class from the RectArea class (using dot operator) directly to evaluate the value of Rectangle?
That is, why we can't use the below code to evaluate the value of a newly created object rect1 from RectArea class.
area1 = rect1.area;
System.out.println("Area1="+ area1);
Or why can't we access the area variable which is declared in Rectangle class from RectArea class using the above code?
area is not the class level variable. Its a local variable in rectArea method, thus, it will not be visible outside the method and won't be accessible via dot operator like class variables
area is not class variable, it is inside method and you can not access method variable as these are local and visible to method only.
There are local variables and instance (class) variables. The class variables are like length and width and they can be used within the whole class.
But with local variables they can only be used within the method/block of code where you have declared them. In this case area is declared in the method and is only available in the method.
Once the code jumps out of the method (return ) area no longer exists.
I have fixed the code below so that it does work:
int length, width, area;
void getData(int x, int y)
{
length=x;
width=y;
}
int rectArea()
{
area=length*width;
return area;
}
}
class RectArea{
public static void main(String[] args) {
int area1, area2;
Rectangle rect1 =new Rectangle();
Rectangle rect2 =new Rectangle();
rect1.length=14;
rect1.width=13;
area1=rect1.length*rect1.width;
rect2.getData(13,14);
area2=rect2.rectArea();
System.out.println("Area1="+ area1);
System.out.println("Area1="+ area2);
System.out.println("Area1="+ rect2.area);
}
}
area is a local variable of the method rectArea. It is not accessible outside the class or even inside the class, except for the same method.
If you want area to be accessible outside, why don't you try something like this:
public class Rectangle {
int length, width, area;
void getData(int x, int y) {
length = x;
width = y;
area = length * width;
}
}
I’ve never used a separate file for a driver in Java. I’m used to just using a main method. I’ve used separate files in Python but Java is new. Below is my code for each class (“Rectangle” and “Driver”), each from separate files.
Update with the methods changed to static: Don’t pay attention to the change in class names or formatting…I’m just tweaking so it will work with MyProgrammingLab. I still have to add in parameters for length and width being between 0.0 and 20.0 only (easy if-else statements).
import java.util.Scanner;
public class Driver{
public static void main(String[] args) {
Scanner input = new Scanner( System.in);
System.out.print("Enter length of rectangle:");
double length = input.nextDouble();
System.out.print("Enter width of rectangle:");
double width = input.nextDouble();
Rectangle Perimeter = new Rectangle(length, width);
Perimeter.getPerimeter();
Rectangle Area = new Rectangle(length, width);
Area.getArea();
System.out.printf("Area: %.1f, Perimeter: %.1f",Rectangle.getArea(),Rectangle.getPerimeter());
}
}
final class Rectangle {
private static double mLength;
private static double mWidth;
public Rectangle(double length, double width){
mLength = length;
mWidth = width;
}
public double getLength(){
return mLength;
}
public double getWidth(){
return mWidth;
}
public static double getArea(){
double area = mWidth*mLength;
return area;
}
public static double getPerimeter(){
double perimeter = (mWidth*2)+(mLength*2);
return perimeter;
}
}
It makes more sense to create a Rectangle object with it's length & width, so use your overloaded Rectangle constructor by passing the length and width arguments (entered by user) as shown below:
Rectangle Perimeter = new Rectangle(length, width);
the constructor Rectangle() is undefined. Can anyone help?
The important point is that when you have an overloaded constructor like in your Rectangle class (where there are no default i.e., no argument constructors written), you can't create an object using new Rectangle();, this is because compiler doesn't add the default constrcutor automatically for you. I suggest look here for more details on this.
Also, if you wanted to print the Rectangle object with length & width details, you need to override toString() method from java.lang.Object method as shown below:
public class Rectangle {
private double mLength;
private double mWidth;
//add your code here as is
#Override
public String toString() {
return "Rectangle [mLength=" + mLength + ", mWidth=" + mWidth + "]";
}
}
The default constructor is provided by compiler if there are no constructor written explicitly.
But if you explicitly write any constructor in the class, then whenever you call a constructor, be it no-argument or with arguments, it will always look for explicitly defined constructor in class.
And, this is logically correct since, if you want to block creation of objects without any data in it, adding a constructor with argiment is the way to go.
So either explicitly write a no argument constructor in Rectangle and use setter to set its attributs, or just use the argument constructor in your method.
Add to Rectangle.class an empty constructor :
public Rectangle() {
}
Or Use constructor declared with parameters in your method
Rectangle rectangle = new Rectangle(length, width);
In your case you are using the rectangle object wrong.
I think what you looking to do is this :
Rectangle rectangle = new Rectangle(length , width );
System.out.printf("Area: %.1f, Perimeter: %.1f",rectangle.getArea() ,rectangle.getPerimeter());
Hi I had this assignment for my class:
Implement a class named Box that will have the following attributes and methods:
int length, width, height
String color
Constructor method that:
will initialize the 3 integers to 10, 8, 6
will initialize the color to “black”
A setter and getter method for each of the 4 attributes
A method to get the volume of the box
A method to get the surface area of the box (all six sides)
I have all my getters and setters for length width and color. My only problem now is that for volume it will not calculate properly if I set the values to be different.
It only takes the initialized values. Any Ideas to go about it? My code is below for the class. example I could .setLength(7) and instead of printing the total 7*8*6, it prints out the total of 10*8*6.
public class Box
{
private int height = 6;
public void se(int height){
this.height=height;
}
public int getHeight(){
return height;
}
private int width = 8;
public void setWidth(int width){
this.width=width;
}
public int getWidth(){
return width;
}
private int length= 10;
public void setLength(int length){
this.length=length;
}
public int getLength(){
return length;
}
private String color="Black";
public void setColor(String color){
this.color=color;
}
public String getColor(){
return color;
}
private int vol=length*width*height;
public void setVol(int vol){
this.vol=vol;
}
public int getVol(){
return vol;
}
}
Get rid of the vol property and the setVol setter; that's not part of the spec for the class and is the root cause of your problems. Rewrite getVol to compute the volume from the length, width, and height each time it is called.
Your current design doesn't work because vol is not recalculated whenever length, width, or height is changed. You could keep your current set of fields and rewrite the dimension setters to recalculate the vol property each time one is called. That would speed up the getVol getter method at the cost of greater complexity for the class design and slower setter methods. It's a trade-off that you can make or not, as you see fit. However, you need to get rid of the setVol method, because when you set the volume, there's no way to know how to set the dimensions so that the values are consistent.
You need to create a getter function for vol
e.g.
public int getVol () {
vol=length*width*height;
return vol;
}
of course the setting of the intermediate vol is not necessary.
and you could just
return length*width*height;
This ensure that the current vol is always correctly calculated.