Chapter 10

Question 1

Inheritance

Answer 1

• allows us to define one class as an extension of another
• solution to duplication
• instead of defining certain classes independently, we first define a class that contains everything they have in common

Question 2

Superclass

Answer 2

Class that’s extended by another class

Question 3

Subclass

Answer 3

-Class that extends (inherits from) another class.
-It inherits all fields and methods from its superclass

Question 4

Inheritance is a what kind of relationship?

Answer 4

-is-a relationship
-subclass is a specialization of a superclass
-ie. “a message post is a post” and “a photo post is a post”

Question 5

Inheritance hierarchy

Answer 5

-classes that are linked through inheritance relationships form an inheritance hierarchy
-ie. a poodle is a dog, which is a mammal, which is an animal

Question 6

Inheritance is an ___ technique that lets us categorize classes of objects under certain criteria and helps us specify the characteristics of these classes

Answer 6

abstraction

Question 7

How is inheritance expressed in Java in the superclass?

Answer 7

• nothing different

public class Post
{
private String username; // username of the post’s author
private long timestamp;
private int likes;
private ArrayList<String> comments;
// Constructors and methods omitted.
}</String>

Question 8

How is inheritance expressed in Java in the subclasses?

Answer 8

-keyword extends defines the inheritance relationship
-only defines the fields unique to the class objects - the fields from the superclass (Post) are inherited and do not need to be listed here

public class MessagePost extends Post
{
private String message;
// Constructors and methods omitted.
}

Question 9

Inheritance and access rights

Answer 9

-members defined as public in either the superclass or subclass portions will be accessible to objects of other classes, but members defined as private will be inaccessible.
-a subclass cannot access private members of its superclass
-if a subclass method needed to access or change private fields in its superclass, then the superclass would need to provide appropriate accessor and/or mutator methods

Question 10

What does the keyword “super” do?

Answer 10

-it’s a call from the subclass constructor to the constructor of the superclass
-its effect is that the Post constructor is executed as part of the MessagePost constructor’s execution
-message post created- MessagePost constructor is called- which as its first statement calls the Post constructor - which initializes post’s fields- then returns to MessagePost constructor- which initializes remaining field defined in the MessagePost class
-for the above to work, those parameters need for the initialization of the post fields are passed on to the superclass constructor as parameters to the super call

Question 11

Superclass constructor

Answer 11

-The constructor of a subclass must always invoke the constructor of its superclass as its first statement
-if source code does not include such a call, Java will attempt to insert a call automatically
- super();
-ie.
public MessagePost(String author, String text)
{
super(author);
message = text;
}

Question 12

super():
inserting this call automatically works only if…

Answer 12

-the superclass has a constructor w/o parameters (because the compiler cannot guess what parameter values should be passed) - otherwise an error will be reported

Question 13

T/F: if you do not write a call to a superclass constructor, the superclass constructor will not be executed

Answer 13

F - if you do not write a call to a superclass constructor, the Java compiler will insert a superclass call automatically, to ensure that the superclass fields are properly initialized
-but, it’s a good idea to always include explicit superclass calls in the constructors.

Question 14

inheritance allows us to __ previously written classes in a new context

Answer 14

-reuse
-one of the great benefits we get from the inheritance facility

Question 15

abstract classes

Answer 15

Classes that are not intended to be used to create instances , but whose purpose is exclusively to serve as superclasses for other classes

Question 16

Advantages of inheritance

Answer 16

1. Avoiding code dupes
2. Code reuse
3. Easier Maintenance
4. Extendibility

Question 17

Subtype

Answer 17

-As an analog to the class hierarchy, types form a type hierarchy. The type defined by a subclass definition is a subtype of the type of its superclass.
-Classes define types - the type of object created from class MessagePost is MessagePost
-classes may have subclasses
-thus the types defined by the classes can have subtypes
-so MessagePost is a subtype of type Post

Question 18

Variables and subtypes

Answer 18

Variables may hold objects of their declared type or of any subtype of their declared type
ie:
Car myCar = new Car();

Question 19

Are these allowed?
Vehicle v1 = new Vehicle();
Vehicle v2 = new Car();
Vehicle v3 = new Bicycle();

Answer 19

Yes

Question 20

Substitution

Answer 20

Subtype objects may be used wherever objects of a supertype are expected.

Question 21

Is this allowed?
Car c1 = new Vehicle();

Answer 21

no
// this is an error!
-The variable is declared to be able to store cars.
-A vehicle may or may not be a car

Question 22

Is this allowed?
Car c2 = new Bicycle();

Answer 22

no
// this is an error!
A bicycle is not a car- the type Bicycle is not a subtype of Car

Question 23

We can pass an object of type MessagePost to a method that has a parameter of type Post, how?

Answer 23

definition of addPost method:
public void addPost(Post post)

use method to add message posts and photo posts to the feed:
NewsFeed feed = new NewsFeed();
MessagePost message = new MessagePost(. . .);
PhotoPost photo = new PhotoPost(. . .);
feed.addPost(message);
feed.addPost(photo);

Question 24

Polymorphic variables

Answer 24

-literally many shapes
-a variable can hold objects of different types (namely, the declared types or any subtype of the declared type)

Question 25

type loss

Answer 25

ie. the type of the object in v is actually Car, but the compiler does not know this. - it translates code line by line, so looks at last line with the error in isolation without knowing what’s stored in variable v
-this is actually allowed, if it was executed in sequence:
Vehicle v;
Car c = new Car();
v = c; // correct
c = v; // error

Question 26

Avoid type loss with__

Answer 26

-a cast operator
-ie
c = (Car) v;
-consists of the type name (car) written in parenthesis in front of a variable of an expression
-so compiler believes object is a Car and will not report error

Question 27

Which would result in errors?
Vehicle v;
1. Car c;
2. Bicycle b;
3. c = new Car();
4. v = c; // okay
5. b = (Bicycle) c; // compile time error!
6. b = (Bicycle) v; // runtime error!

Answer 27

5 and 6 because compiler notices that Car and Bicycle do not form a subtype/supertype relationship, so c can never hold a Bicycle object

Question 28

Casting should be avoided wherever possible, because___

Answer 28

-can lead to runtime errors
-in almost all cases when you use a cast, you could restructure your code to avoid this cast and end up with a better-design program
-this usually involves replacing the cast with a polymorphic method call