面向对象的三大特性之继承性

继承是多态的前提，如果没有继承，就没有多态

• 要理解后成是师徒关系，师傅的武功，大徒弟和小徒弟，都能够继承。而如果理解成父子关系的话，金钱的继承只能各分一半
• 共性抽取，把共同的特点抽取到父类（基类）里面
• 师父在这里称为父类，基类，超类，可拥有父类的内容，徒弟在这里叫做子类，派生类，可拥有自己专有的内容
  

继承的格式
定义父类的格式

public class 父类名称{}

定义子类的格式

public class 子类名称 extends 父类名称{}

员工是父类

public class Employee
{
	public void method()
	{
	System.out.println("方法执行")；
}	
}

教师是子类

public class Teacher extends Employee
{

}

助教是子类

public class Assisatant extends Employee
{

}

主方法

public class a{
	public static void main(String[] args)
	{
	//创建一个子类对象
	Teacher teacher=new Teacher();
	//可调用父类的方法
	teacher.method();
	//创建助教的对象
	Assistant assistant=new Assistant();
	assistant.method();
}
}

如果出现变量重名，等号左边是谁就优先用谁，方法属于谁，优先用谁，没有则向上找
父类成员变量

public class Fu{
	int numFu=10;
	int num=100;

	public void methodFu(){
	//用的是父类的num
	System.out.println(num);
}
}

子类

public class Zi extends Fu{
	int numZi=20;
	int num=200;
	public void methodZi(){
	//用的是子类的num
	System.out.println(num);
}
}

主方法

public class a{
	public static void main(String[] args)
	{
	Fu fu=new Fu();//创建父类的东西，只能使用父类的元素
	System.out.println(fu.numFu)//只能使用父类的东西

	Zi zi=new Zi();
	System.out.println(zi.numFu);//10
	System.out.println(zi.numZi);//20

//左边是子类，所以调用的就是zi的num，输出200
	System.out.println(zi.num);
	//方法是子类的，优先调用子类，没有再向上找（直接调用）
	zi.methodZi();//输出200
	//这个方法是在父类定义的（间接调用父类里的内容），并且因为methodFu()是属于父类的，所以输出的是父类的num
	zi.methodFu();//输出100
}
}

当方法中也有相同名字的变量

• 局部变量，直接写成员变量名
• 本类的成员变量，this.成员变量名
• 父类的成员变量，super.成员变量

父类

public class Fu{
	int numFu=10;
	int num=10;

	public void methodFu(){
	//用的是父类的num
	System.out.println(num);
}
}

子类

public class Zi extends Fu{
	int numZi=20;
	int num=20;
	public void methodZi(){
	//用的是子类的num
	int num30;
	##method里的局部变量
	System.out.println(num);//30
	##Zi里的成员变量
	System.out.println(this.num);//20
	##父类里的成员变量
	System.out.println(super.num);//10
}
}

主方法

public class a{
	public static void main(String[] args)
	{
	Zi zi=new Zi();
	zi.method();
}
}

方法重名的时候

• 创建的对象是谁就优先用谁，如果没有则向上找

子类

public class Zi extends Fu{
	int numZi=20;
	int num=20;
	public void method(){
	System.out.println("重名方法执行");
}
}

public class Fu{
	int numZi=20;
	int num=20;
	public void method(){
	System.out.println("重名方法执行");
}
}

主方法

public class a{
	public static void main(String[] args)
	{
	Zi zi=new Zi();
	//创建的是子类对象优先用的是子类方法
	zi.method();
}
}

方法的重写 override

• 子类覆盖父类

重写(overide),方法的名称一样，参数列表也一样，覆盖
重载(overload)，方法的名称一样，参数列表不一样

方法重写的注意事项

• 保证父子类之间方法的名称相同，参数列表也相同
• 子类方法的返回值范围必须小于等于父类方法的返回值范围
• 子类方法的权限必须大于等于方法的权限修饰符
  public>protected＞(default)什么都不写>private

子类

public class Zi extends Fu{
	public void method()
	{
	
}
}

public class Fu{
	##就算不写也是覆盖重写，写上作用是用来检验是否是有效的注解，安全检测。
	@override
	public void method()
	{
	
}
}

使用场景

• 新的和旧的有共性的内容，使用覆盖重写

旧手机的showNum()只有一个功能

class Phone {
	public void sendMessage(){
	System.out.println("发短信");
}
	public void call(){
	System.out.println("打电话");
}
	public void showNum(){
	System.out.println("来电显示号码");
}
}

新手机的showNum通过@override,增加功能，并且使用关键字super调用旧类里的方法

//智能手机类
class NewPhone extends Phone {
//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
	public void showNum(){
//调用父类已经存在的功能使用super
	super.showNum();
//增加自己特有显示姓名和图片功能
	System.out.println("显示来电姓名");
	System.out.println("显示头像");
}
}
public class ExtendsDemo06 {
public static void main(String[] args) {
// 创建子类对象
	NewPhone np = new NewPhone()；
// 调用父类继承而来的方法
	np.call();
// 调用子类重写的方法
	np.showNum();
}
}

子类与父类构造方法的关系

• 先调用父类方法，再调用子类方法

class Fu {
private int n;
##无参构造
	public Fu(){
	System.out.println("父类无参构造");
}
##有参构造
public Fu(int num){
	System.out.println("父类有参构造");
}
}

class Zi extends Fu {
Zi(){
// super（），调用父类构造方法
	super();
	//super调用父类只能是要用一次
	//super(20);
	System.out.println("Zi（）");
}
}
public class ExtendsDemo07{
public static void main (String args[]){
	Zi zi = new Zi();
}
}