老王学Java

继承中方法的覆盖重写
应用场景

代码显示

//本来的老款手机
public class Phone {

	public void call(){
		System.out.println("打电话");
	}
	
	public void send(){
		System.out.println("发短信");
	}
	public void show(){
		System.out.println("显示号码");
	}
}

// 定义一个新款手机，使用老手机作为父类
public class NewPhone extends Phone{
	
	@Override
	public void show(){
//		System.out.println("显示号码");
		super.show();//把父类的show方法拿过来重复利用
		//自己的子类来添加更多内容
		System.out.println("显示姓名");
		System.out.println("显示头像");
		
	}

}

//请记住，尽量不区修改老的类（父类），向要新工能就继承它在
//添加新东西，对于已经有的功能要想该的话，就用覆盖重写Override
public class Demo01Phone {

	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();
		
	}
}

继承关系中，父子类构造方法的访问特点
1,(先用父类对象的内容，才能有子类的对象内容)子类构造方法当中，有一个默认隐含的“super()；”调用。
所以一定是先调用的父类构造，后执行的子类构造。(子类必须要调用父类的构造方法)

2，子类构造可以通过“super”关键字来调用父类重载功能。

3，super的父类构造调用，必须是子类的构造方法的第一个语句。不能一个子类构造调用多次super构造。

4，子类必须调用父类方法，不写则赠送一个（super()）。写了则用写的指定的super调用，
super只能有一个，还必须是第一个。

创建一个父类

public class Fu {
 
	public Fu(){//无参构造方法
		System.out.println("父类构造方法：");
	}
	
	public Fu(int num){
		System.out.println("父类有参构造方法：");
	}
}

创建一个子类

public class Zi extends Fu {
	
	public Zi(){//无参构造方法
		
//		super();// 在调用父类无参构造方法，不写就默认赠送一个
		super(10);//在调用父类重载的构造方法，通过super往里传参，
		//谁能对的上我就用谁
		System.out.println("子类构造方法：");
	}

	public void method(){
//		super();//错误写法!只有子类构造方法，才能调用父类构造方法。
	}
}

public class Demo01Constructor {

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

super关键字的三种用法：

1，在子类的成员方法中，访问父类的成员变量。、
2，在子类的成员方法中，访问父类的成员发方法。
3,在子类的构造方法中，访问父类的构造方法。

先创建父类

public class Fu {

	int num = 10;
	
	
	public void method(){
		System.out.println("父类方法");
	}
}

在创建子类

public class Zi extends Fu{

	int num = 20;
	
	//访问父类的构造方法
	public Zi(){
		super();
	}
	
	public void methodzi(){
		System.out.println(super.num);//父类中的num
	}
	public void method(){
		super.method();//访问父类中的method
		System.out.println("子类方法");
	}
}

this关键字：
super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：

1，在本类的成员方法中，访问本类的成员变量。
2，在本类的成员方法中，访问本类的另一个成员方法。
3，在本类构造方法中，访问本类的另一个构造方法。
早第三种用法当中要注意：
A，this(…)调用也必须是构造方法的第一个语句。唯一一个。
B，super和this两种构造调用，不能同时使用。（因为他们都是唯一的，二者不能同时使用）

创建一个父类

public class Fu {

	int num = 30;
}
``
创建一个子类：

public class Zi extends Fu{

int num = 20;

public Zi(){

// super();//这一行不在赠送
// this();//这不叫另一个，这叫自己调自己。错误
this(123);//本类的无参构造，调用本类的有参构造。
//就是构造的方法的重载调用。
// this(1, 2);//错误写法

}

public Zi(int n){
	this(1, 2);//一个参数的可以调用两个参数的。没有问题
}

public Zi(int n, int m){
	
}

public void showNum(){
	int num = 10;
	System.out.println(num);//局部变量
	System.out.println(this.num);//本类中的成员变量
	System.out.println(super.num);//父类中的成员变量
}


public void methodA(){
	System.out.println("AAA");
}

public void methodB(){

// methodA();调用
this.methodA();//在本类 而不是在父类
System.out.println(“BBB”);
}

}

super  与this 关键字图解

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200730161233264.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODYwMTYyNA==,size_16,color_FFFFFF,t_70#pic_center)

public class Fu {

int num = 10;
public void method(){//成员方法
	System.out.println("父类方法");
}

}

public class Zi extends Fu {

int num = 20;

@Override
public void method(){
	super.method();//调用了父类方法
	System.out.println("子类方法");
}

public void show(){
	int num = 30;
	System.out.println(num);//30
	System.out.println(this.num);//20
	System.out.println(super.num);//10
}

}

public class Demo {

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

}

Java继承的三个特点
用图来说明
![在这里插入图片描述](https://img-blog.csdnimg.cn/2020073016444195.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80ODYwMTYyNA==,size_16,color_FFFFFF,t_70)