Java基础：继承、方法重写

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

• extends：扩展，子类是父类的扩展

• Java中只有单继承

• final修饰的类不能被继承

• 选中类，Ctrl+H：打开继承树

• private：私有子类无法使用

• 继承是类与类间的一种关系

• 继承中一个子类（派生类），一个父类（基类），子类继承父类

• 子类和父类之间，从意义上讲应该有“is a”的关系

父类：

//在Java中，所有类默认继承Object类 (extands Object)
//Person，人：父类
public class Person {
    public void say(){
        System.out.println("say");
    }
}

子类：

//学生是人的子类、派生类
//子类继承父类，会拥有父类的所有方法（修饰符允许
public class Student extends Person{
}

main函数：

public class Application {
    public static void main(String[] args) {
        Student s = new Student();
        s.say();//子类可以使用父类的方法
    }
}

• Object类
  • 所有类默认继承Object类，可以调用里面的方法

super

super是访问父类的属性或方法，与this类似

父类：

//Person，人：父类
public class Person {
    public Person() {
        System.out.println("Person无参");
    }

    //private私有的东西无法被继承
    protected String name = "chachan53";
    public void print(){
        System.out.println("Person");
    }
}

子类：

//学生是人的子类、派生类
//子类继承父类，会拥有父类的所有方法（修饰符
public class Student extends Person{

    private String name = "me";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }

    public void test(String name){
        System.out.println(name);//传入的参数cha
        System.out.println(this.name);//me
        System.out.println(super.name);//chachan53
    }
}

main函数：

public class Application {
    public static void main(String[] args) {
        Student s = new Student();
        s.test("cha");
        s.test1();
    }
}

• 构造器调用

//Person，人：父类
public class Person {
    public Person() {
        System.out.println("Person无参");
    }
}

//学生是人的子类、派生类
//子类继承父类，会拥有父类的所有方法（修饰符
public class Student extends Person{
    public Student() {
        //super();隐藏代码，自动调用了父类的无参构造
        //调用（super，this）构造器必须在子类的第一行，父子有参无参要对应
        System.out.println("Student无参");
    }
}

//main函数
public class Application {
    public static void main(String[] args) {
        Student s = new Student();
    }
}

此时输出结果为：

Person无参
Student无参

子类在调用无参构造时自动调用了父类的无参构造。

子类构造器中有隐藏代码super();，自动调用了父类的无参构造

调用（super，this）构造器必须在子类的第一行，父子有参无参要对应

• super注意点：
  • super调用父类的构造方法，必须在构造方法的第一个
  • super必须只能出现在子类的方法或构造方法中
  • super和this不能同时调用构造方法。
• 对比this：
  • 代表对象不同
    • this：调用自身对象
    • super：对父类对象的应用
  • 前提
    • this：没继承也能用
    • super：只能在继承条件才可以使用
  • 构造方法
    • this()：本类的构造
    • super()：父类的构造

方法重写

静态方法：父类b的引用指向了子类A

方法的调用只和定义的数据类型有关

//父类
public class B {
    public static void test(){
        System.out.println("B->test()");
    }
}

//子类
public class A extends B{
    public static void test(){
        System.out.println("A->test()");
    }
}

//Application
public class Application {
    public static void main(String[] args) {
        //方法的调用只和定义的数据类型有关
        A a = new A();
        a.test();//A

        //父类b的引用指向了子类A
        B b = new A();
        b.test();//B
    }
}

非静态

• 重写：需要有继承关系，子类重写父类的方法

  • 方法名相同
  • 参数列表相同
  • 修饰符：范围可以扩大但不能缩小（public>protected>(default)>private)
  • 抛出的异常：范围可以缩小但不能扩大（ClassNotFoundException->Exception(大)）

• 重写：子类的方法和父类必须一致，方法内的方法体不同

• 重写原因：

  • 父类的功能子类不一定需要，或不一定满足

• 快捷键：Alt+Insert：Override

//父类
//重写都是方法的重写，和属性无关
public class B {
    //删去static
    public void test(){
        System.out.println("B->test()");
    }
}

//子类
public class A extends B{
    //Override 重写，Alt+Insert：Override
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("A->test()");
    }
}

//Application
public class Application {
    //静态和非静态方法有很大区别
        //静态方法：方法的调用只与左边的数据类型有关
        //非静态方法：重写
    public static void main(String[] args) {
        //方法的调用只和定义的数据类型有关
        A a = new A();
        a.test();//A

        B b = new A();//子类重写了父类的方法
        b.test();//A
    }
}