inheritance super overrides printMethod in Superclass override重写父方法
Core Java Web Page http://horstmann.com/corejava.html
[
inheritance
]
package v1ch05.inheritance; import java.time.LocalDate; public class Employee { private String name;
private double salary;
private LocalDate hireDay; public Employee(String name, double salary, int year, int month, int day) {
this.name = name;
this.salary = salary;
hireDay = LocalDate.of(year, month, day);
} public String getName() {
return name;
} public double getSalaary() {
return salary;
} public LocalDate getHireDay() {
return hireDay;
} public void raiseSalary(double byPercent) {
double raise = salary * byPercent / 100;
salary += raise;
}
}
package v1ch05.inheritance; public class Manager extends Employee {
private double bouns; public Manager(String name, double salary, int year, int month, int day) {
super(name, salary, year, month, day);
bouns = 0;
} public double getSalary() {
double baseSalary = super.getSalaary();
return baseSalary + bouns;
} public void setBouns(double b){
bouns = b;
}
}
package v1ch05.inheritance; public class ManagerTest {
public static void main(String[] args) {
// construct a Manager object
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBouns(5000); Employee[] staff = new Employee[3]; // fill the staff array qwith Manager and Employee objects
staff[0] = boss;
staff[1] = new Employee("harry Hacker", 5000, 1989, 10, 1);
staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15); // print out information about all Emplyee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalaary() + "");
}
}
super
Using the Keyword super (The Java™ Tutorials > Learning the Java Language > Interfaces and Inheritance) https://docs.oracle.com/javase/tutorial/java/IandI/super.html
Using the Keyword super
Accessing Superclass Members
If your method overrides one of its superclass's methods, you can invoke the overridden method through the use of the keyword super
. You can also use super
to refer to a hidden field (although hiding fields is discouraged). Consider this class, Superclass
:
public class Superclass { public void printMethod() {
System.out.println("Printed in Superclass.");
}
}
Here is a subclass, called Subclass
, that overrides printMethod()
:
public class Subclass extends Superclass { // overrides printMethod in Superclass
public void printMethod() {
super.printMethod();
System.out.println("Printed in Subclass");
}
public static void main(String[] args) {
Subclass s = new Subclass();
s.printMethod();
}
}
Within Subclass
, the simple name printMethod()
refers to the one declared in Subclass
, which overrides the one in Superclass
. So, to refer to printMethod()
inherited from Superclass
, Subclass
must use a qualified name, using super
as shown. Compiling and executing Subclass
prints the following:
Printed in Superclass.
Printed in Subclass
Subclass Constructors
The following example illustrates how to use the super
keyword to invoke a superclass's constructor. Recall from the Bicycle
example that MountainBike
is a subclass of Bicycle
. Here is the MountainBike
(subclass) constructor that calls the superclass constructor and then adds initialization code of its own:
public MountainBike(int startHeight,
int startCadence,
int startSpeed,
int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
Invocation of a superclass constructor must be the first line in the subclass constructor.
The syntax for calling a superclass constructor is
super();
or:
super(parameter list);
With super()
, the superclass no-argument constructor is called. With super(parameter list)
, the superclass constructor with a matching parameter list is called.
Note: If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error.
Object
does have such a constructor, so if Object
is the only superclass, there is no problem.If a subclass constructor invokes a constructor of its superclass, either explicitly or implicitly, you might think that there will be a whole chain of constructors called, all the way back to the constructor of Object
. In fact, this is the case. It is called constructor chaining, and you need to be aware of it when there is a long line of class descent.
最新文章
- Tips for Planning Your Business Startup
- Linux内核--网络栈实现分析(二)--数据包的传递过程(上)
- Unity3D脚本中文系列教程(十)
- PHP - PHPExcel操作xls文件
- 写了几天的博客-feel
- bzoj 2705: [SDOI2012]Longge的问题 歐拉函數
- Linux学习笔记29——IPC状态命令
- 在线提取PDF中图片和文字
- Cocos2dx 3.1.1 学习笔记整理(4):事件监听与Action的初步使用
- 用Python发送邮件
- ●BZOJ 1934 [Shoi2007]Vote 善意的投票
- java读取.properties配置文件的几种方法
- html5自带表单验证
- hdu6397 Character Encoding 母函数解约束条件下多重集
- e870. 获取默认外观的数据
- C#提高--------------获取方法返回值的自定义特性(Attribute)
- TensorFlow函数(七)tf.argmax()
- java基础18 String字符串和Object类(以及“equals” 和 “==”的解析)
- 【LOJ】#2127. 「HAOI2015」按位或
- NodeJs-Linux环境初步