Java基础学习——Java面向对象（五）继承、重写

一.继承

1.定义

是类与类之间的关系：子类和父类。继承的本质是对某一批类的抽象。

在子类中使用extends关键字，意为扩展，子类是父类的扩展，子类可以继承父类的所有属性和方法（如果属性定义为private，要写成封装（get、set）方法来给子类调用）

Java中只有单继承，因为一个儿子只能有一个父，而父可以有多个儿子。

final定义的类是没有子类的，无法被继承。

2.继承的程序写法

1）先创建一个Person类

//父类
public class Person {

}

再创建一个Student子类，因为Student属于Person

//Student是Person，也就是Student是Person的子类，或者叫派生类
public class Student extends Person{

}

这样就完成了Student子类对Person父类的继承

2）子类可以继承父类的所有方法，Student类里什么都不写，在Person类中写了如下属性和方法

//父类
public class Person {
    public int money=10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
}

在Application中调用这些属性和方法，可以正常调用

import com.rzd.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.money);
        student.say();
    }
}

但是由于属性一般写成私有的，于是就在Person内写成封装

//父类
public class Person {
    private int money=10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }
}

import com.rzd.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getMoney());
        student.say();
    }
}

3）Super()

super关键字用来调用父类的属性或方法。

创建一个父类Person类，子类Student类，编写程序如下

package com.rzd.oop.demo07;
//父类
public class Person {
    protected String name="父name";

    public void print(){
        System.out.println("Person");
    }
}

在子类中定义与父类相同的属性名和方法名

package com.rzd.oop.demo07;
//super()
public class Student extends Person{
    String name="子name";
    public void print(){
        System.out.println("Student");
    }



    //子类调用父类的属性
    public void test(String name){
        //这个name是当前方法的形参，值是调用这个方法传进来的参数
        System.out.println(name);
        //this.name表示当前这个类的属性name
        System.out.println(this.name);
        //super.name表示父类的属性name
        System.out.println(super.name);
    }

    //子类调用父类的方法
    public void test1(){
        print();    //一般不用这个写法，会分不清。指当前类的print方法，可以按住Ctrl点击它来看跳转到具体哪一个方法
        this.print();   //当前类的print方法
        super.print();  //父类的print方法
    }
}

在main方法中调用，可以看到，this指代当前类，super指代父类

package com.rzd.oop;

import com.rzd.oop.demo07.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("实参name");

        student.test1();
    }
}

在子类的构造器中，第一行有一行super();是隐藏代码，就像没有定义构造器时，程序有一个隐藏的无参构造器一样，是默认存在的。

可以通过debug看到，程序走到子类的构造器之后，下一步是走到父类的构造器，说明子类里有颐一句调用父类构造器的语句，也就是super()。

public class Person {
    protected String name="父name";

    public Person() {
        System.out.println("父类的无参构造执行了");
    }
}

public class Student extends Person {
   //Student的无参构造器
    public Student() {
        //这里有一句隐藏代码，就像没有定义构造器时，程序有一个隐藏的无参构造器一样。
        //super();  //调用父类的无参构造器
        System.out.println("子类的无参构造执行了");
    }

}

这时在main方法中new一个Student时，执行结果如下

 由此可见，在子类的无参构造的第一行是有一句super();的。

super也可以用来调用构造器

package com.rzd.no02oop.demo06;

public class Person {
    int age;
    String name;
    //定义了有参，无参必须写上
    public Person(){

    }

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

package com.rzd.no02oop.demo06;

public class Student extends Person{
    int score;

    public Student(){

    }
    //定义一个3个参数的有参构造器，其中两个参数是从父类继承的
    public Student(int age,String name,int score){
       /* //age和name是直接从父类继承的属性，可以直接用
        this.age=age;
        this.name=name;*/
        /*//也可以直接调用父类的age和name
        super.age=age;
        super.name=name;*/
        //最常用的写法是，在父类定义两个属性的有参构造，子类直接调用父类的有参构造
        super(age,name);
        this.score=score;
    }

}

一些报错的解释：

1.Call to 'super()' must be first statement in constructor body 

在子类中调用构造器时，无论是调用本身的构造器，还是调用父类的构造器，都必须写在构造器的第一行。

原因是：this()和super()都是构造方法，作用是在JVM堆中构建出一个对象。如果不写在第一行，例如第一行System.out.println(name);用来输出父类的name属性值，但是此时name对象还没有进行初始化

　　　　所以为了避免操作对象时对象还未构建成功，需要this()和super()的调用在第一行实现【以此来创建对象】，防止异常

2.Call to 'this()' must be first statement in constructor body

在子类中调用构造器时，super()和this()不能同时出现。

 原因是：this()和super()都是构造方法，作用是在JVM堆中构建出一个对象。super()会调用父类的无参构造器，初始化父类；而this()默认会先调用父类的无参构造器，这样就会对父类进行两次初始化，重复创建两次对象

　　　　所以为了避免多次创建对象，同一个方法内只能调用一次this()或super()。

那么同理，也不能既调用父类的无参构造，又调用父类的有参构造了，也会造成重复创建对象。

3.There is no default constructor available in 'com.rzd.oop.demo08.Person'：在Person中没有默认的构造器

如果在父类Person中只提供了有参构造，没有写无参构造，那么此时无参构造自动失效。此时如果在子类Student中调用

在类中，如果只定义了有参构造，那么无参构造自动失效。而在上面这个程序中，子类写了一个无参构造，第一行默认是super();没有写出来，意思为调用父类的无参构造，但是现在父类里并没有无参构造，所以会报错。

所以有两种解决办法

解决方法1：在父类中添加无参构造

 解决方法2：在子类中指明要调用的是父类的有参构造

 小结：

super()：

1）super()只能用在子类的构造方法中，且必须在第一行

2）所有构造器中，如果没有显式使用super()调用父类的构造器（无论是有参还是无参），则系统就会自动分配super();

2）在子类的普通方法中可以调用super.属性，super.方法等

3）super()和this()不能同时调用，会导致重复创建对象

 

this()：表示本身类的构造方法

二、方法重写

1.概念

1）只有方法可以重写，和属性无关

2）子类重写父类的方法：方法名、参数列表必须相同，只有方法体可以不同（否则会变成重载）

3）子类的修饰符可以扩大，但不能缩小：public>protected>default<private

4）子类抛出的异常范围可以缩小但不能扩大：ClassNotFoundException<Exception

添加一个Father父类，写一个test方法

//重写都是方法的重写。
public class Father {
    public void test(){

        System.out.println("父类的test()");
    }
}

再添加一个Son方法，写一个和父类只有方法体不同的test方法

public class Son extends Father{
    public void test(){
        System.out.println("子类的test()");
   }
}

在main方法中初始化

public class Application {
    public static void main(String[] args) {
        Son son = new Son();
        Father father = new Son();//子类重写了父类的方法
        son.test();
        father.test();
    }
}

运行结果为

这里就是方法的重写，会去调用子类test方法。

重写的意义：父类的功能对子类来说太多或不够用。

重写的快捷键：Alt+Insert   override（重写）、Ctrl+o

快捷添加重写会自动添加代码：

public class Son extends Father{
    @Override   //注释
    public void test() {
        super.test();
    }
}

然后可以修改方法体。

三、权限修饰符

1.default

在同一包内可见，缺省即为default属性。使用对象：类、接口、变量、方法。

public class Demo01 {
    public static void main(String[] args) {
    String str1="default";  //默认的就是声明为public static final
    }
    boolean add() { //add（）方法默认为public
        return true;
    }
}

2.private

在同一类内可见。使用对象：变量、方法（类和接口不能用）。 注意：不能修饰类（外部类）

package com.rzd.no02oop.demo05;

public class A {
    private int age;
    private void eat() {
        System.out.println(age);
        age = 10;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

package com.rzd.no02oop.demo05;

public class Test {
    public static void main(String[] args) {
        A a = new A();
        //a.age=100;  //私有属性，在另一个类中无法使用
        //a.eat();      //私有方法同理
        a.setAge(100);  //在A中写了get、set方法后可以使用
    }
}

3.protected

对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

package com.rzd.no02oop.demo05;

public class B {
    protected int age;
    int num;
    public void eat() {
        System.out.println(age);
        age = 10;
    }
}

package com.rzd.no02oop.demo04;
import com.rzd.no02oop.demo05.B;

public class Test1 extends B {
    public void test1(){
        System.out.println(age);    //protected不同包，子类也可以直接访问
        //System.out.println(num); //default修饰，则不同包的子类不能访问，但是同一个包下的子类可以访问
    }
}

4.public

对所有类可见。使用对象：类、接口、变量、方法

一般，我们属性使用private修饰，方法使用public修饰