A beginner's library for learning about essential Java programming concepts, syntax, APIs, and packages.
Inheritance in Java, Part 1: The extends keywordUse Java's extends keyword to derive a child class from a parent class, invoke parent class constructors and methods, override methods, and more
Marco Verch [CC BY 2.0]
Table of Contents
Show More
Java supports class reuse through inheritance and composition. This two-part tutorial teaches you how to use inheritance in your Java programs. In Part 1 you'll learn how to use the
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 keyword to derive a child class from a parent class, invoke parent class constructors and methods, and override methods. In Part 2 you'll tour class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
5, which is Java's superclass from which every other class inherits.To complete your learning about inheritance, be sure to check out my Java tip explaining when to use composition vs inheritance. You'll learn why composition is an important complement to inheritance, and how to use it to guard against issues with encapsulation in your Java programs.
download
Get the code
Download the source code for example applications in this tutorial. Created by Jeff Friesen for JavaWorld.
Java inheritance: Two examples
Inheritance is a programming construct that software developers use to establish is-a relationships between categories. Inheritance enables us to derive more-specific categories from more-generic ones. The more-specific category is a kind of the more-generic category. For example, a checking account is a kind of account in which you can make deposits and withdrawals. Similarly, a truck is a kind of vehicle used for hauling large items.
Inheritance can descend through multiple levels, leading to ever-more-specific categories. As an example, Figure 1 shows car and truck inheriting from vehicle; station wagon inheriting from car; and garbage truck inheriting from truck. Arrows point from more-specific "child" categories [lower down] to less-specific "parent" categories [higher up].
Jeff FriesenFigure 1. A pair of inheritance hierarchies are rooted in the common vehicle category
This example illustrates single inheritance in which a child category inherits state and behaviors from one immediate parent category. In contrast, multiple inheritance enables a child category to inherit state and behaviors from two or more immediate parent categories. The hierarchy in Figure 2 illustrates multiple inheritance.
Jeff FriesenFigure 2. Hovercraft multiply inherits from land vehicle and water vehicle categories
Categories are described by classes. Java supports single inheritance through class extension, in which one class directly inherits accessible fields and methods from another class by extending that class. Java doesn't support multiple inheritance through class extension, however.
When viewing an inheritance hierarchy, you can easily detect multiple inheritance by the presence of a diamond pattern. Figure 2 shows this pattern in the context of vehicle, land vehicle, water vehicle, and hovercraft.
The extends keyword
Java supports class extension via the
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 keyword. When present, class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 specifies a parent-child relationship between two classes. Below I use class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 to establish a relationship between classes class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9 and class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
0, and then between class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 and class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
2:Listing 1. The class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 keyword specifies a parent-child relationship
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
class Vehicle
{
// member declarations
}
class Car extends Vehicle
{
// inherit accessible members from Vehicle
// provide own member declarations
}
class Account
{
// member declarations
}
class SavingsAccount extends Account
{
// inherit accessible members from Account
// provide own member declarations
}
The
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 keyword is specified after the class name and before another class name. The class name before class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 identifies the child and the class name after class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 identifies the parent. It's impossible to specify multiple class names after class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
4 because Java doesn't support class-based multiple inheritance.These examples codify is-a relationships:
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
0 is a specialized class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9 and class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
2 is a specialized class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1. class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9 and class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 are known as base classes, parent classes, or superclasses. class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
0 and class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
2 are known as derived classes, child classes, or subclasses.Final classes
You might declare a class that should not be extended; for instance for security reasons. In Java, we use the
class CheckingAccount extends Account
{
CheckingAccount[long amount]
{
super["checking", amount];
}
void withdraw[long amount]
{
setAmount[getAmount[] - amount];
}
}
6 keyword to prevent some classes from being extended. Simply prefix a class header with class CheckingAccount extends Account
{
CheckingAccount[long amount]
{
super["checking", amount];
}
void withdraw[long amount]
{
setAmount[getAmount[] - amount];
}
}
6, as in class CheckingAccount extends Account
{
CheckingAccount[long amount]
{
super["checking", amount];
}
void withdraw[long amount]
{
setAmount[getAmount[] - amount];
}
}
8. Given this declaration, the compiler will report an error if someone attempts to extend class CheckingAccount extends Account
{
CheckingAccount[long amount]
{
super["checking", amount];
}
void withdraw[long amount]
{
setAmount[getAmount[] - amount];
}
}
9.Child classes inherit accessible fields and methods from their parent classes and other ancestors. They never inherit constructors, however. Instead, child classes declare their own constructors. Furthermore, they can declare their own fields and methods to differentiate them from their parents. Consider Listing 2.
Listing 2. An class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 parent class
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
Listing 2 describes a generic bank account class that has a name and an initial amount, which are both set in the constructor. Also, it lets users make deposits. [You can make withdrawals by depositing negative amounts of money but we'll ignore this possibility.] Note that the account name must be set when an account is created.
Representing currency values
count of pennies. You might prefer to use a
class AccountDemo
{
public static void main[String[] args]
{
SavingsAccount sa = new SavingsAccount[10000];
System.out.println["account name: " + sa.getName[]];
System.out.println["initial amount: " + sa.getAmount[]];
sa.deposit[5000];
System.out.println["new amount after deposit: " + sa.getAmount[]];
CheckingAccount ca = new CheckingAccount[20000];
System.out.println["account name: " + ca.getName[]];
System.out.println["initial amount: " + ca.getAmount[]];
ca.deposit[6000];
System.out.println["new amount after deposit: " + ca.getAmount[]];
ca.withdraw[3000];
System.out.println["new amount after withdrawal: " + ca.getAmount[]];
}
}
1 or a class AccountDemo
{
public static void main[String[] args]
{
SavingsAccount sa = new SavingsAccount[10000];
System.out.println["account name: " + sa.getName[]];
System.out.println["initial amount: " + sa.getAmount[]];
sa.deposit[5000];
System.out.println["new amount after deposit: " + sa.getAmount[]];
CheckingAccount ca = new CheckingAccount[20000];
System.out.println["account name: " + ca.getName[]];
System.out.println["initial amount: " + ca.getAmount[]];
ca.deposit[6000];
System.out.println["new amount after deposit: " + ca.getAmount[]];
ca.withdraw[3000];
System.out.println["new amount after withdrawal: " + ca.getAmount[]];
}
}
2 to store monetary values, but doing that can lead to inaccuracies. For a better solution, consider class AccountDemo
{
public static void main[String[] args]
{
SavingsAccount sa = new SavingsAccount[10000];
System.out.println["account name: " + sa.getName[]];
System.out.println["initial amount: " + sa.getAmount[]];
sa.deposit[5000];
System.out.println["new amount after deposit: " + sa.getAmount[]];
CheckingAccount ca = new CheckingAccount[20000];
System.out.println["account name: " + ca.getName[]];
System.out.println["initial amount: " + ca.getAmount[]];
ca.deposit[6000];
System.out.println["new amount after deposit: " + ca.getAmount[]];
ca.withdraw[3000];
System.out.println["new amount after withdrawal: " + ca.getAmount[]];
}
}
3, which is part of Java's standard class library.Listing 3 presents a
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
2 child class that extends its class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 parent class.Listing 3. A class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
2 child class extends its class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 parent class
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
The
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
2 class is trivial because it doesn't need to declare additional fields or methods. It does, however, declare a constructor that initializes the fields in its class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 superclass. Initialization happens when class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1's constructor is called via Java's javac AccountDemo.java
javac *.java
1 keyword, followed by a parenthesized argument list.When and where to call super[]
Just as
javac AccountDemo.java
javac *.java
2 must be the first element in a constructor that calls another constructor in the same class, javac AccountDemo.java
javac *.java
3 must be the first element in a constructor that calls a constructor in its superclass. If you break this rule the compiler will report an error. The compiler will also report an error if it detects a javac AccountDemo.java
javac *.java
3 call in a method; only ever call javac AccountDemo.java
javac *.java
3 in a constructor.Listing 4 further extends
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 with a javac AccountDemo.java
javac *.java
7 class.Listing 4. A javac AccountDemo.java
javac *.java
7 child class extends its class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 parent class
javac AccountDemo.java
javac *.java
class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
class CheckingAccount extends Account
{
CheckingAccount[long amount]
{
super["checking", amount];
}
void withdraw[long amount]
{
setAmount[getAmount[] - amount];
}
}
javac AccountDemo.java
javac *.java
7 is a little more substantial than class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
2 because it declares a java AccountDemo
2 method. Notice this method's calls to java AccountDemo
3 and java AccountDemo
4, which javac AccountDemo.java
javac *.java
7 inherits from class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1. You cannot directly access the java AccountDemo
7 field in class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 because this field is declared java AccountDemo
9 [see Listing 2].super[] and the no-argument constructor
If
javac AccountDemo.java
javac *.java
3 is not specified in a subclass constructor, and if the superclass doesn't declare a account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
1 constructor, then the compiler will report an error. This is because the subclass constructor must call a account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
1 superclass constructor when javac AccountDemo.java
javac *.java
3 isn't present.Class hierarchy example
I've created an
account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
4 application class that lets you try out the class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
1 class hierarchy. First take a look at account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
4's source code.Listing 5. account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
4 demonstrates the account class hierarchy
account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
class AccountDemo
{
public static void main[String[] args]
{
SavingsAccount sa = new SavingsAccount[10000];
System.out.println["account name: " + sa.getName[]];
System.out.println["initial amount: " + sa.getAmount[]];
sa.deposit[5000];
System.out.println["new amount after deposit: " + sa.getAmount[]];
CheckingAccount ca = new CheckingAccount[20000];
System.out.println["account name: " + ca.getName[]];
System.out.println["initial amount: " + ca.getAmount[]];
ca.deposit[6000];
System.out.println["new amount after deposit: " + ca.getAmount[]];
ca.withdraw[3000];
System.out.println["new amount after withdrawal: " + ca.getAmount[]];
}
}
The
account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
8 method in Listing 5 first demonstrates class SavingsAccount extends Account
{
SavingsAccount[long amount]
{
super["savings", amount];
}
}
2, then javac AccountDemo.java
javac *.java
7. Assuming class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
1, class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
2, class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
3, and class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
4 source files are in the same directory, execute either of the following commands to compile all of these source files:javac AccountDemo.java
javac *.java
Execute the following command to run the application:
java AccountDemo
You should observe the following output:
account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
Method overriding [and method overloading]
A subclass can override [replace] an inherited method so that the subclass's version of the method is called instead. An overriding method must specify the same name, parameter list, and return type as the method being overridden. To demonstrate, I've declared a
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method in the class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9 class below.Listing 6. Declaring a class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method to be overridden
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
Next, I override
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 in the class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
9 class.Listing 7. Overriding class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 in a class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
9 subclass
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
class Truck extends Vehicle
{
private double tonnage;
Truck[String make, String model, int year, double tonnage]
{
super[make, model, year];
this.tonnage = tonnage;
}
double getTonnage[]
{
return tonnage;
}
void print[]
{
super.print[];
System.out.println["Tonnage: " + tonnage];
}
}
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
9's class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method has the same name, return type, and parameter list as class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9's class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method. Note, too, that class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
9's class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method first calls class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9's class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method by prefixing class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
00 to the method name. It's often a good idea to execute the superclass logic first and then execute the subclass logic.Calling superclass methods from subclass methods
In order to call a superclass method from the overriding subclass method, prefix the method's name with the reserved word
javac AccountDemo.java
javac *.java
1 and the member access operator. Otherwise you will end up recursively calling the subclass's overriding method. In some cases a subclass will mask non-java AccountDemo
9 superclass fields by declaring same-named fields. You can use javac AccountDemo.java
javac *.java
1 and the member access operator to access the non-java AccountDemo
9 superclass fields.To complete this example, I've excerpted a
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
05 class's account name: savings
initial amount: 10000
new amount after deposit: 15000
account name: checking
initial amount: 20000
new amount after deposit: 26000
new amount after withdrawal: 23000
8 method:class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
0The final line,
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
07, calls class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
08's class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method. This method first calls class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9's class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 to output the truck's make, model, and year; then it outputs the truck's tonnage. This portion of the output is shown below:class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
1Use final to block method overriding
Occasionally you might need to declare a method that should not be overridden, for security or another reason. You can use the
class CheckingAccount extends Account
{
CheckingAccount[long amount]
{
super["checking", amount];
}
void withdraw[long amount]
{
setAmount[getAmount[] - amount];
}
}
6 keyword for this purpose. To prevent overriding, simply prefix a method header with class CheckingAccount extends Account
{
CheckingAccount[long amount]
{
super["checking", amount];
}
void withdraw[long amount]
{
setAmount[getAmount[] - amount];
}
}
6, as in class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
14. The compiler will then report an error if anyone attempts to override this method in a subclass.Method overloading vs overriding
Suppose you replaced the
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method in Listing 7 with the one below:class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
2The modified
class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
9 class now has two class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 methods: the preceding explicitly-declared method and the method inherited from class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9. The class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
19 method doesn't override class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
9's class Vehicle
{
private String make;
private String model;
private int year;
Vehicle[String make, String model, int year]
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake[]
{
return make;
}
String getModel[]
{
return model;
}
int getYear[]
{
return year;
}
void print[]
{
System.out.println["Make: " + make + ", Model: " + model + ", Year: " +
year];
}
}
5 method. Instead, it overloads it.You can detect an attempt to overload instead of override a method at compile time by prefixing a subclass's method header with the
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
22 annotation:class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
3Specifying
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
22 tells the compiler that the given method overrides another method. If someone attempted to overload the method instead, the compiler would report an error. Without this annotation, the compiler would not report an error because method overloading is legal.When to use @Override
Develop the habit of prefixing overriding methods with
class Account
{
private String name;
private long amount;
Account[String name, long amount]
{
this.name = name;
setAmount[amount];
}
void deposit[long amount]
{
this.amount += amount;
}
String getName[]
{
return name;
}
long getAmount[]
{
return amount;
}
void setAmount[long amount]
{
this.amount = amount;
}
}
22. This habit will help you detect overloading mistakes much sooner.