Embedded Files
OBJECTIVE
I can:
write constructors for subclasses
Subclasses inherit all the private instance variables in a superclass that they extend, but they cannot directly access them since they are private.
The constructors are not inherited.
How do you initialize private instance variables if you don't have direct access to them in the subclass?
In Java you can put a call to the parent constructor using as the first line in a subclass constructor.
The superclass constructor can be called from the first line of a subclass constructor by using the keyword super and passing appropriate parameters, for example super(); or super(theName); as shown below.
The actual parameters given to super are used to initialize the inherited instance variables, for example the name instance variable in the Person superclass:
The super(theName) in the Employee constructor will call the constructor that takes a String object in the Person class to set the name.
If a class has no constructor in Java, the compiler will add a no-argument constructor.
A no-argument constructor is one that doesn't have any parameters, for example public Person().
If a subclass has no call to a superclass constructor using super as the first line in a subclass constructor then the compiler will automatically add a super() call as the first line in a constructor.
So, be sure to provide no-argument constructors in parent classes or be sure to use an explicit call to super() as the first line in the constructors of subclasses.
Regardless of whether the superclass constructor is called implicitly or explicitly, the process of calling superclass constructors continues until the Object constructor is called since every class inherits from the Object class.
SUMMARY
Subclasses do not have access to the private instance variables in a superclass that they extend.
Constructors are not inherited.
The superclass constructor can be called from the first line of a subclass constructor by using the keyword super and passing appropriate parameters to set the private instance variables of the superclass.
The actual parameters passed in the call to the superclass constructor provide values that the constructor can use to initialize the object's instance variables.
When a subclass's constructor does not explicitly call a superclass's constructor using super, Java inserts a call to the superclass's no-argument constructor.
Regardless of whether the superclass constructor is called implicitly or explicitly, the process of calling superclass constructors continues until the Object constructor is called. At this point, all of the constructors within the hierarchy execute beginning with the Object constructor.
EVIDENCE
1) Complete the following Google Form. This form must be 100% correct and includes released AP practice questions. To stop working and return later, hit submit! You can "edit your response" and continue where you left off.
I.2 Evidence
2) In this challenge, you are given a class called Rectangle that has two instance variables, length and width, and two constructors that initialize them, and a method called draw() that uses nested loops to draw a rectangle (length x width) of stars.
Write a new class called Square that inherits from Rectangle. Is a square a rectangle? Yes! A square is a rectangle where the length and width are equal. Square will inherit length, width, and the draw method. You will write constructors that will call the Rectangle constructors.
A. Make the class Square below inherit from Rectangle
B. Add a Square no-argument constructor that calls Rectangle's constructor using super().
C. Add a Square constructor with 1 argument for a size that calls Rectangle's constructor with 2 arguments using super.
D. Uncomment the objects in the main method to test drawing the squares.
E. Add an area() method to the Rectangle that computes the area of the rectangle. Does it work for squares too? Test it.
F. Add another subclass called LongRectangle which inherits from Rectangle but has the additional condition that the length is always 2x the width. Write constructors for it and test it out.
Below are the three files that you will need for this challenge. Make sure to have a Main.java file, Rectangle.java file, and Square.java file.
public class Main
{
public static void main(String[] args)
{
Rectangle r = new Rectangle(3,5);
r.draw();
// D. Uncomment these to test
// Square s1 = new Square();
// s1.draw();
// Square s = new Square(3);
// s.draw();
}
}
class Rectangle
{
private int length;
private int width;
public Rectangle()
{
length = 1;
width = 1;
}
public Rectangle(int l, int w)
{
length = l;
width = w;
}
public void draw()
{
for(int i=0; i < length; i++)
{
for(int j=0; j < width; j++)
System.out.print("* ");
System.out.println();
}
System.out.println();
}
}
// A. Make the class square inherit from Rectangle
public class Square
{
// B. Add a Square no-argument constructor
// C. Add a Square constructor with 1 argument for a side
}
Report abuse