Java面向对象之继承、构造方法、重写、重载

Java是一门面向对象的编程语言，这意味着它支持面向对象的编程风格及相关的特性，如封装、继承和多态性。本文将讲解Java面向对象中的继承、构造方法、重写和重载的具体原理和应用。

1. 继承

1.1 继承概述

继承是面向对象编程中的一种重要机制，它允许我们基于已有的类创建一个新类，这个新类继承了原有类的属性和行为，并且可以在此基础上添加新的属性和行为。被继承的类称为父类（或超类、基类），新创建的类称为子类（或派生类）。

继承的作用之一是提高代码复用性，通过将重复的代码封装到父类中，减少了代码的编写量。此外，继承也能实现代码的层次化，让代码更加清晰易懂。

1.2 继承的实现方式

要实现继承，我们可以使用Java中的关键字extends。在子类的定义中使用extends关键字，后面紧跟着父类的名字。对于非Object类，一个子类只能有一个直接的父类。

class ParentClass {
    // 父类成员变量和方法
}

class ChildClass extends ParentClass {
    // 子类成员变量和方法
}

1.3 示例

// 定义父类
class Person {
    protected String name; // 姓名
    protected int age; // 年龄

    // 处理人的信息
    public void showInfo() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
    }
}

// 定义子类
class Student extends Person {
    protected String school; // 学校

    // 处理学生的信息
    public void showInfo() {
        super.showInfo();
        System.out.println("学校：" + school);
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "张三";
        stu.age = 18;
        stu.school = "清华大学";
        stu.showInfo();
    }
}

运行结果：

姓名：张三
年龄：18
学校：清华大学

2. 构造方法

2.1 构造方法概述

构造方法是一种特殊的方法，它的主要作用是创建对象时初始化对象的状态。当我们使用new关键字创建Java对象时，Java运行时系统会自动调用该对象的构造方法。构造方法和类同名，并且没有返回值类型。如果我们没有提供构造方法，Java会提供一个默认的无参构造方法。

2.2 构造方法的重载

Java中允许我们定义多个同名的构造方法，只要它们的参数个数或类型或顺序不同，就可以视为不同的方法。这被称为构造方法的重载（Overloading）。当我们创建一个对象时，Java在与构造方法的参数匹配的重载中找到最合适的构造方法来调用。

class MyClass {
    // 无参构造方法
    public MyClass() {
        System.out.println("调用了无参构造方法");
    }

    // 有参构造方法
    public MyClass(String str) {
        System.out.println("调用了有参构造方法：" + str);
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass("Hello, World!");
    }
}

运行结果：

调用了无参构造方法
调用了有参构造方法：Hello, World!

2.3 示例

class Student {
    protected String name; // 姓名
    protected int age; // 年龄

    // 无参构造方法
    public Student() {
        System.out.println("调用了无参构造方法");
    }

    // 有参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("调用了有参构造方法");
    }

    // 处理人的信息
    public void showInfo() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.showInfo();

        Student stu2 = new Student("张三", 18);
        stu2.showInfo();
    }
}

运行结果：

调用了无参构造方法
姓名：null
年龄：0
调用了有参构造方法
姓名：张三
年龄：18

3. 重写和重载

3.1 重写

当子类继承父类的方法时，我们可以通过重写（Override）这些方法来改变它们的行为。重写方法和被重写的方法必须有相同的名称、参数列表和返回类型，访问修饰符也不能比被重写的方法更严格。重写方法可以使用@Override注解标注。

class ParentClass {
    protected String name;

    public void eat() {
        System.out.println("父亲吃饭");
    }
}

class ChildClass extends ParentClass {
    // 重写父类方法
    @Override
    public void eat() {
        System.out.println("孩子吃饭");
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        ParentClass obj1 = new ParentClass();
        obj1.eat();

        ChildClass obj2 = new ChildClass();
        obj2.eat();
    }
}

运行结果：

父亲吃饭
孩子吃饭

3.2 重载

Java中的方法也支持重载（Overload），就是允许我们有多个同名的方法，只要它们的参数列表不同。这样，在创建对象并调用方法时，Java将根据传递的参数类型或数量选择合适的方法。重载方法可以与其他方法重载或重写，但必须有不同的参数列表。

class Calculator {
    // 求和
    public int add(int a, int b) {
        System.out.println("调用了add(int a, int b)");
        return a + b;
    }

    // 求和的重载
    public double add(double a, double b) {
        System.out.println("调用了add(double a, double b)");
        return a + b;
    }

    // 求和的重载
    public double add(int a, double b) {
        System.out.println("调用了add(int a, double b)");
        return a + b;
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        Calculator obj = new Calculator();
        System.out.println(obj.add(1, 2)); // 调用add(int a, int b)
        System.out.println(obj.add(1.1, 2.2)); // 调用add(double a, double b)
        System.out.println(obj.add(1, 2.2)); // 调用add(int a, double b)
    }
}

运行结果：

调用了add(int a, int b)
3
调用了add(double a, double b)
3.3
调用了add(int a, double b)
3.2

总结

本文介绍了Java面向对象编程中的继承、构造方法、重写和重载的原理和应用。继承是提高代码复用性和代码层次化的常用机制。构造方法用于对象创建时的初始化，支持重载。重写可以改变已有方法的行为，而重载可以让方法根据传入参数类型或数量的不同执行不同行为。掌握这些知识，可以帮助我们编写更加清晰和可维护的代码。