继承
继承
继承是多态的前提，没有继承就没有多态。继承主要解决的是问题是：共性抽取。
父类：也可以叫基类、超类。只能使用父类的东西，没有任何子类的内容。
子类：也可以叫派生类。既能使用父类的又能使用自己的。
继承关系的特点：
- 子类可以拥有父类的"内容"。
- 子类还可以拥有自己专有的内容。
定义父类的格式：(一个普通的类定义) 定义子类的格式：
public class 父类名称{ public class 子类名称 extends 父类名称{
...... ......
} }
在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问方式有两种：
- 直接通过子类对象访问成员变量: 等号左边是谁，就优先用谁，没有则往上找。
- 间接通过成员方法访问成员变量：该方法是与谁就优先用谁，没有则向上找
package test;
public class Fu {
int numFu=10;
int num=100;
public void methonFu(){
System.out.println(num);
}
}
package test;
public class Zi extends Fu {
int numZi=20;
int num=200;
public void methondZi(){
System.out.println(num);
}
}
package test;
public class Extends {
public static void main(String[] args) {
Fu fu = new Fu();
System.out.println(fu.numFu);//10
Zi zi = new Zi();
System.out.println(zi.numZi);//20
System.out.println(zi.numFu);//10
//等号左边是谁，就优先用谁
System.out.println(zi.num);//Zi zi = new Zi();对象zi左边是Zi类，所以用该类下的200
System.out.println(zi.numFu);//10,没有在Zi中找到numFu,则向上到Fu中找，如果都没有，则编译报错
System.out.println("===============");
//这个方法是子类的，优先用子类，没有再向上找
zi.methondZi();//200
//这个方法是在父类中定义的
zi.methonFu();//100
}
}
区分子类方法中重名的三张变量
- 局部变量：直接写成员变量名
- 本类的成员变量：this.变量名
- 父类的成员变量：super.成员变量名
public class Fu{
int num=10;
}
public class Zi extends Fu{
int num=20;
public void method(){
int num=30;
System.out.println(num);//30,局部变量
System.out.println(this.num);//20,本类的成员变量
System.out.println(super.num);//10,父类的成员变量
}
}
继承中成员方法的访问特点
在父子的继承关系中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。
注意事项：无论是成员方法还是成员变量，如果没有则向上找父类的，绝对不会向下找子类的，
重写(Override):在继承关系中，方法的名称一样，参数列表也一样。也叫覆盖，覆写。
重载（Overload）：方法的名称一样，参数列表不一样。
方法覆盖重写的特点：创建的是子类对象，则优先用子类的方法。
方法覆盖重写的注意事项：
-
必须保证父子类之间的方法的名称相同，参数列表也相同。
@override:写下方法前面，用来见得是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
-
子类方法的返回值必须小于等于父类方法的返回值范围。
java.lang.Object类是所有类的公共最高父类(祖宗类),java.lang.String就算Object的子类。 -
子类方法的权限必须大于等于父类方法的权限修饰符。
public>protected>(default)>private方法的修饰符：子类的范围更大
方法的返回值：父类的范围更大
备注：(default)不是关键字，而是什么都不写，留空。
package test;
public class Fu {
public(或者private) Object methond(){
}
}
package test;
public class Zi extends Fu {
@Override
public String(或者Object) methond(){
}
}
方法覆盖：在保存原来的方法功能的前提下进行增加其他功能。
package test;
public class Phone {
public void call(){
System.out.println("打电话");
}
public void send(){
System.out.println("发短信");
}
public void show(){
System.out.println("显示号码");
}
}
package test;
public class newPhone extends Phone{
@Override
public void show() {
super.show();
//自己添加更多内容
System.out.println("显示姓名");
System.out.println("显示头像");
}
}
package test;
public class DemoPhone {
public static void main(String[] args) {
Phone phone = new Phone();
phone.call();
phone.send();
phone.show();
System.out.println("===========");
newPhone newPhone = new newPhone();
newPhone.call();
newPhone.send();
newPhone.show();
}
}
/*打电话
发短信
显示号码
===========
打电话
发短信
显示号码
显示姓名
显示头像*/
继承中构造方法的访问特点
继承关系中构造方法的访问特点：
-
子类构造方法当中有一个默认隐含的"super()"调用，所以一定是先调用的父类构造，后执行的子类构造。
-
可以通过super关键字来子类构造调用父类重载构造
-
super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：子类调用父类构造方法，不写则赠送super();写了则用写的知道的super调用。super只能有 一个，还必须是第一个。
package test; public class Fu { public Fu{ System.out.println("父类无参构造！") } public Fu(int num){ System.out.println("父类有参构造！") } }package test; public class Zi { public Zi{ //super();隐含默认调用父类无参构造方法。 super(20);//因为父类创建了一个有参构造方法，所以这里的super()也要有参，不然报错。而且要写上无参构造方法。 System.out.println("子类无参构造方法！") } }public class DemoConstructor{ public static void main(String[] args){ Zi zi=new Zi(); } } /*父类构造！ 子类构造！*/
super的用法
- 在子类的成员方法中，访问父类的成员变量。super.父类成员变量;
- 在子类的成员方法中，访问父类的成员方法。super.父类成员方法;
- 在子类的构造方法中，访问父类的构造方法。super();
spuer关键字用来访问父类内容，而this关键字用来访问本类内容。
this的用法
- 在本类的成员方法中，访问本类的成员变量。 this.本类成员变量
- 在本类的成员方法中，访问本类的另一个成员方法。this.本类成员方法
- 在本类的构造方法中，访问本类的另一个构造方法。
- 要注意this(...)调用也必须是构造方法的第一个语句，唯一一个。
- super和this两种构造调用，不能同时使用。
浙公网安备 33010602011771号