Java寒假学习Day15:方法的重写（Override）

1.什么是方法的重写？

在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的 重置、覆盖 。在程序执行时，子类的方法将覆盖父类的方法。

2.方法重写的要求？

①. 子类重写的方法 必须 和父类被重写的方法具有相同的 方法名称、参数列表

②. 子类重写的方法的返回值类型 不能大于 父类被重写的方法的返回值类型

③. 子类重写的方法使用的访问权限 不能小于 父类被重写的方法的访问权限

    子类不能重写父类中声明为 private 权限的方法

④. 子类方法抛出的异常不能大于父类被重写方法的异常

/*
 * 方法的重写(override / overwrite)
 * 
 * 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
 * 
 * 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
 * 
 * 3. 重写的规定：
 * 			方法的声明： 权限修饰符  返回值类型  方法名(形参列表) throws 异常的类型{
 * 						//方法体
 * 					}
 * 			约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
 * 		① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
 *      ② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
 *      	>特殊情况：子类不能重写父类中声明为private权限的方法
 *      ③ 返回值类型：
 *      	>父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
 *      	>父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
 *      	>父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
 *		④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
 *	**********************************************************************
 *		子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。	
 *
 * 面试题：区分方法的重载与重写
 */

3.super&this关键字

3.1关于super和this关键字

/*
 * super关键字的使用
 * 1.super理解为：父类的
 * 2.super可以用来调用：属性、方法、构造器
 * 
 * 3.super的使用：调用属性和方法
 * 
 *   3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用
 *   父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
 *   3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的
 *   使用"super.属性"的方式，表明调用的是父类中声明的属性。
 *   3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的
 *   使用"super.方法"的方式，表明调用的是父类中被重写的方法。
 * 
 * 4.super调用构造器
 * 	 4.1  我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
 *   4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
 *   4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
 *   4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
 *   4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器
 */

3.2Java中的测试

Person类（父类）

package SuperTest;

public class Person {
	
	String name;
	int age;
	String id;//身份证号
	
	//this关键字构造器
	public Person() {
		System.out.println("hello");
	}
	public Person(String name,int age) {
		this();//
		this.name = name ;
		this.age = age ;
	}
	public Person(String name,int age,String id) {
		this(name,age);//
		this.id = id;
	}
	
	
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void think() {
		System.out.println("思考");
	}
}

Student类（子类）

package SuperTest;

public class Student extends Person{
	String major;
	String id;//学生证号
	
	//this关键字构造器
	public Student(String major/*只涉及到子类的属性*/) {
		this.major = major;
	}
	//super关键字构造器
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Student(String name, int age, String id) {//涉及到父类的属性
		super(name, age, id);
		// TODO Auto-generated constructor stub
	}

	public Student(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}
	//有父类有子类的构造
	public Student(String name,int age,String id,/*父类的*/String major/*子类的*/) {
		super(name,age,id);//super调用父类的
		this.major = major;//直接赋值
//		this(major);//调用子类中的major参数构造器，结果失败，原因：this()必须放在首行
	}
	
	
	@Override
	public void eat() {
		System.out.println("吃点好的");
	}
	
	

	public void study() {
		System.out.println("学生可以学习");
        eat();//默认是子类重写后的eat
        this.eat();//调用的子类Override后的eat
        super.eat();//调用的是父类自带的eat
	}
	
	public void show() {//super关键字
		System.out.println("id = "+id);//默认的是子类的id
		System.out.println("身份证号 = "+super.id);//获取的是父类的id
		System.out.println("学生证号 = "+this.id);//获取的是子类的id
	}
}

super&this关键字测试类

package SuperTest;

public class SuperTest {
	public static void main(String[] args) {
		Student s = new Student();
		s.eat();//调用的是子类Override后的eat（）方法
		s.think();//调用的是父类的think（）方法
		s.show();//结果在Student的show（）方法中有写
	}
}