一、方法重写
1、定义：子类写了一个方法名称、形参列表与父类的某个方法一样的方法去覆盖父类的该方法。
2、方法重写的注意事项：
（1）建议加上：@Override注解，可以校验重写是否正确，同时可读性好。
（2）子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限。
（3）重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
（4）私有方法、静态方法不能被重写。
总结：声明不变，重新实现。
package org.example.extends5override;
public class Test {
public static void main(String[] args) {
Cat cat = new Cat();
cat.cry();
}
}
class Animal {
public void cry() {
System.out.println("动物在叫");
}
}
class Cat extends Animal {
//方法重写：方法名称、形参列表必须一样，这个方法就是方法重写
@Override//方法重写的校验注解（标志），要求方法名称和形参列表必须与被重写方法一致，否则报错。
//更安全，可读性好，更优雅
public void cry() {
System.out.println("猫在叫");
}
}3、方法重写的应用场景
子类重写Object类的toString（）方法，以便返回对象的内容。
package org.example.extends5override;
public class Test2 {
public static void main(String[] args) {
Student s = new Student("张三", 18, "男");
//注意1：直接输出对象，默认调用Object类的toString()方法（可以省略不写调用toString()方法）,返回对象的地址信息
System.out.println(s);
//System.out.println(s.toString());
//注意2：输出对象的地址实际上没有什么意义，开发中更希望输出对象时看到对象的内容信息，所以子类需要重写Object类的toString()方法，
// 以便以后输出对象时默认就近调用子类重写的toString()方法
}
}
class Student{
private String name;
private int age;
private String sex;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
public Student() {
}
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
二、子类构造器
1、子类构造器的特点：子类中的全部构造器，都必须先调用父类的构造器，再执行自己的。
package org.example.extends6constructor;
public class Test {
public static void main(String[] args) {
//目标：认识子类构造器的特点
//子类构造器必须先调用父类的构造器，再执行自己的构造器
Zi zi = new Zi();
}
}
class Zi extends Fu{
public Zi(){
//super();//默认存在的，写不写都有，调用父类的无参数构造器
super(10);//指定调用父类的有参数构造器
System.out.println("子类无参构造器");
}
}
class Fu{
public Fu(){
System.out.println("父类无参构造器");
}
public Fu(int a){
System.out.println("父类有参构造器");
}
}
2、super(...)调用父类有参数构造器的常见应用场景：
为对象中包含父类这部分的成员变量进行赋值。
代码演示如下：
package org.example.extends6constructor;
//父类
public class People {
private String name;
private String sex;
public People(){
}
public People(String name,String sex){
this.name = name;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
package org.example.extends6constructor;
//子类
public class Teacher extends People {
private String skills;
public Teacher() {
}
public Teacher(String name,String sex, String skills) {
super(name, sex);
this.skills = skills;
}
public String getSkills() {
return skills;
}
public void setSkills(String skills) {
this.skills = skills;
}
}
package org.example.extends6constructor;
public class Test2 {
public static void main(String[] args) {
Teacher t = new Teacher("张三", "男", "Java");
System.out.println(t.getName());
System.out.println(t.getSex());
System.out.println(t.getSkills());
}
}
当主类创建Teacher类的对象t时，会自动执行Teacher类的有参构造器对t赋值。由于Teacher类继承了People类，因此对象t是由Teacher类和People类两张设计图共同完成的，有三个属性：name、sex、skill。
调用Teacher类的无参构造器时，会先调用父类People类的无参构造器。但由于主类中用有参构造器对对象赋值，故无参构造器没有使用到。
调用Teacher类的有参构造器时，会先调用父类People类的无参构造器，因此要写super(name,sex);来指定调用父类的有参构造器。
我们可以将super(name,sex);注释掉来验证这一点：
