面向对象编程：继承、重写与构造方法的奥秘

叁歲伎倆 2023-10-14 01:21 80阅读 0赞

### 文章目录 ###

*   *   *  1. 代码如何创建类？
         *  2. 使用类创建对象
         *  3. 继承
         *  4. 方法的重写
         *  5. 构造方法

![在这里插入图片描述][4cf4354303f54ef7bcce85b91759a20b.gif_pic_center]

当编写面向对象的Java程序时，我们常常会涉及到继承、重写和构造方法等概念。让我们通过具体的代码片段来更好地理解这些概念。

### 1. 代码如何创建类？ ###

在Java中，我们可以使用以下语法来创建一个类：

// 定义一个学生类
    public class Student {
        
        // 成员变量
        String name;
        int age;
        String gender;
    
        // 成员方法
        public void eat() {
        
            System.out.println("eat()......");
        }
    
        public void sleep() {
        
            System.out.println("sleep()......");
        }
    }

在上面的代码中，我们创建了一个名为`Student`的类，包含了成员变量`name`、`age`和`gender`，以及成员方法`eat()`和`sleep()`。这样我们就定义了一个学生类，可以用来表示学生对象。

### 2. 使用类创建对象 ###

创建类后，我们可以使用该类来创建对象，如下所示：

// 使用Student类创建对象
    Student student1 = new Student();

上面的代码创建了一个名为`student1`的`Student`对象。通过这个对象，我们可以访问该类中的成员变量和成员方法，例如：

// 访问成员变量
    student1.name = "Alice";
    student1.age = 20;
    student1.gender = "female";
    
    // 调用成员方法
    student1.eat();
    student1.sleep();

### 3. 继承 ###

继承是面向对象编程的重要特性之一，类似于现实生活中的传承和继承。通过继承，一个类可以继承另一个类的属性和方法，从而实现代码的复用，简化程序的开发过程。在生活中，我们可以将继承类比为王健林继承财产的过程，不需要从零开始，可以直接享受前人积累的成果。

1.  访问子类，查看具有的成员  
    子类可以继承父类中的方法和非私有的成员变量，如果父类成员变量是私有的，可以通过提供公有的get和set方法进行访问。这样，在创建子类对象时，可以直接使用继承来的属性和方法，减少了代码的冗余。
2.  继承的特点  
    一个父类可以有多个子类，但一个子类只能有一个父类。  
    继承具有传递性，即如果A类继承自B类，而B类又继承自C类，那么A类自然也继承了C类的属性和方法。
3.  继承中特殊情况  
    在继承中，有一些特殊情况需要注意：

子类中直接使用父类的成员：继承具有传递性，子类可以直接使用父类继承来的成员。  
成员变量命名与父类相同：按照就近原则，子类的成员变量会隐藏父类的同名成员变量，需要使用super关键字来调用父类的成员变量。  
使用super关键字：子类可以通过super关键字调用父类的非私有成员变量和方法。

现在我们来看看继承的示例。假设我们有一个`Teacher`类，它也具有姓名、年龄和性别的成员变量，但同时还有一个职位信息的成员变量和`teach()`方法：

// 定义一个教师类
    public class Teacher {
        
        // 成员变量
        String name;
        int age;
        String gender;
        String position;
    
        // 成员方法
        public void eat() {
        
            System.out.println("eat()......");
        }
    
        public void sleep() {
        
            System.out.println("sleep()......");
        }
    
        public void teach() {
        
            System.out.println("teach()......");
        }
    }

现在我们想要创建一个`MathTeacher`类，它是`Teacher`类的子类，我们可以通过`extends`关键字实现继承：

// 定义数学教师类，继承自Teacher类
    public class MathTeacher extends Teacher {
        
        // MathTeacher类拥有Teacher类的所有成员变量和成员方法
        // ...
    }

通过继承，`MathTeacher`类自动拥有了`Teacher`类中的所有成员变量和成员方法。我们可以像之前一样创建`MathTeacher`对象，并访问其成员变量和成员方法：

// 使用MathTeacher类创建对象
    MathTeacher mathTeacher = new MathTeacher();
    
    // 访问继承自Teacher类的成员变量和成员方法
    mathTeacher.name = "Bob";
    mathTeacher.age = 30;
    mathTeacher.gender = "male";
    mathTeacher.position = "Math Teacher";
    
    mathTeacher.eat();
    mathTeacher.sleep();
    mathTeacher.teach();

### 4. 方法的重写 ###

方法的重写是指子类对父类中的方法进行重新实现。重写的条件是：方法名称、返回值类型和参数列表相同，但实现不同。重写的标志是在子类方法上加上@Override注解。

在继承中，我们还可以重写父类的方法，即在子类中重新实现父类中的方法。假设我们想在`MathTeacher`类中重写`teach()`方法：

// 在MathTeacher类中重写teach()方法
    public class MathTeacher extends Teacher {
        
        // ...
    
        @Override
        public void teach() {
        
            System.out.println("Math teacher teaches math...");
        }
    }

在上述代码中，我们使用`@Override`注解标记了`teach()`方法的重写。现在，当我们调用`mathTeacher.teach()`时，输出将是`Math teacher teaches math...`，而不是父类中的`teach()`方法的实现。

### 5. 构造方法 ###

构造方法是创建对象时自动调用的特殊方法，用于对对象进行初始化。在前面的示例中，我们并未显式定义构造方法，但Java会默认提供一个无参的构造方法。如果我们需要自定义构造方法，可以这样做：

// 在Teacher类中添加有参构造方法
    public class Teacher {
        
        // 成员变量
        String name;
        int age;
        String gender;
        String position;
    
        // 无参构造方法（默认提供）
        public Teacher() {
        }
    
        // 有参构造方法
        public Teacher(String name, int age, String gender, String position) {
        
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.position = position;
        }
    
        // 成员方法
        // ...
    }

通过添加有参构造方法，我们可以在创建对象时传入参数进行初始化：

// 使用有参构造方法创建Teacher对象
    Teacher teacher = new Teacher("John", 40, "male", "English Teacher");

在上述代码中，我们创建了一个名为`teacher`的`Teacher`对象，并传入参数来初始化对象的成员变量。

通过以上的代码片段，相信大家对继承、重写和构造方法等面向对象的概念有了更

清晰的理解。这些特性使得Java编程更加灵活、高效，让我们在编写代码时能够更好地实现代码的复用和扩展。希望这篇文章对你的学习和实践有所帮助！

[4cf4354303f54ef7bcce85b91759a20b.gif_pic_center]: https://img-blog.csdnimg.cn/4cf4354303f54ef7bcce85b91759a20b.gif#pic_center