继承
继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
生活中的继承形如:
例如兔子和老虎都会睡觉、吃东西(公共的方法),只不过吃的东西(即属性)不一样、吃的方式(即方法)也会不同。
如果不使用继承,那么在兔子类、老虎类里我们需要分别定义各自的eat方法以及food属性,这无疑增加重复的代码,导致代码的复用性差。
但是有了继承,我们可以通过子类继承父类的方式,使子类能够拥有父类非private的属性和方法。
继承的好处:
- 提高了代码的复用性。
- 让类和类之间产生了关系,给第三个特征多态提供了前提。
继承的注意点:
- java支持单继承(一个子类只能有一个父类);Java支持多层继承(A继承B,B继承C,C继承D);不直接支持多继承(一个子类继承多个父类),对C++中的多继承机制进行了改良。可以用如下图片表示。
- 子类与父类成员变量相同时,如果需要获取父类的成员变量,要用super调用父类。super代表的是一个父类空间。
- 子类方法重写父类方法时,子类权限必须大于等于父类的方法权限。
- 静态方法只能重写静态方法,或者被静态重写。(这个时候主要依赖于类,而不再是对象了)
代码
- 父类(Animal)
父类属性用到了封装,所以子类如果想使用父类属性只能用父类中的get方法。(super好像不行,待测试)
class Animal{
//封装
private String name;
private String food;
//初始化构造函数
public Animal() {};//不带参
public Animal(String name, String food) {//带参构造函数
this.setName(name);
this.setFood(food);
}
void eat() {
System.out.println(getName()+" is eating "+getFood());
}
void sleep() {
System.out.println(getName()+" is sleeping.");
}
//静态方法只能重写静态或者被静态重写。
static void show() {
System.out.println("叫");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
}
- 子类(Tiger)
Tiger类用到了重写,那么什么时候需要重写?
答:当需要对父类中的某一功能方法进行扩展时,就需要用到重写操作。所以,重写操作一定会保证子类和父类的该方法名字相同、参数的个数与类型相同、返回值也一样,这才是正确的重写操作。
重写和重载的区别也十分重要,菜鸟教程官网的介绍很详细了,这里直接引用。
class Tiger extends Animal{
public Tiger() {};
public Tiger(String name, String food) {
this.setName(name);
this.setFood(food);
}
//重写老虎的eat()方法,因为我们需要对子类方法进行一个扩展。
public void eat() {
System.out.print("We gotta make a hunt firstly! Watch out! ");
System.out.println(getName()+" killed "+getFood()+" and ate it.");
}
//测试super关键字对父类的引用
public void superTest() {
super.eat();
}
}
主函数里测试:
Tiger tiger1 = new Tiger("tiger1", "chicken");
tiger1.eat();
tiger1.superTest();
- 子类(Rabit)
Rabit类和Tiger类在继承的时候用了两种不同的写法,Rabit类显得更简洁。
class Rabit extends Animal{
public Rabit() {};
public Rabit(String name, String food) {
super(name, food);
}
}
主函数里测试:
Animal animal = new Animal("animal", "food");
animal.eat();
Rabit rabit1 = new Rabit("rabit1", "carrot");
rabit1.eat();
Rabit rabit2 = new Rabit();
rabit2.setName("rabit2");
rabit2.setFood("grass");
rabit2.eat();
继承中子类、父类构造函数的特点
在子类构造对象时,会发现访问子类构造函数时,父类构造函数也会被访问。
原因:子类的构造函数第一行有一个默认的隐式语句。super();
public class InheritanceDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
new Zi();
}
}
class Fu{
Fu(){
System.out.println("A, Fu Run");
}
}
class Zi extends Fu{
Zi(){
//子类的构造函数第一行有一个默认的隐式语句。super()
//super();
System.out.println("Zi Run");
}
}
- 那如果执行子类中的带参构造函数,是否会调用父类的不带参构造函数呢?
运行结果显示,这种情况依然会执行父类的不带参构造函数。
public class InheritanceDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
new Zi(4);
}
}
class Fu{
Fu(int x){
System.out.println("Fu Run"+ x);
}
Fu(){
System.out.println("Fu Run");
}
}
class Zi extends Fu{
Zi(int x){
//super(4);
System.out.println("Zi Run"+ x);
}
Zi(){
//子类的构造函数第一行有一个默认的隐式语句。super()
//super();
System.out.println("Zi Run");
}
}
- 那如果是执行子类的带参构造函数,如何调用父类中的带参构造函数?
可以通过super(带参);来实现
class Zi extends Fu{
Zi(int x){
super(4);
System.out.println("Zi Run"+ x);
}
Zi(){
//子类的构造函数第一行有一个默认的隐式语句。super();
//super();
System.out.println("Zi Run");
}
}
总结
子类的构造函数(不管是带参的还是不带参的)一旦被调用,都会调用父类的不带参构造函数。但是子类的带参构造函数被调用,不会引起父类的带参构造函数被调用,如果想,可以用super(带参)实现。
为什么子类实例化的时候要访问父类中的构造函数呢?
那是因为子类继承了父类,获取到了父类中内容(属性),所以在使用父类内容之前,要先看父类是如何对自己的内容进行初始化的。
注意:super语句必须要定义在子类构造函数的第一行,因为父类的初始化动作需要先完成。