广州网站建设价格bt磁力链好用的引擎

          hello！这里是敲代码的小董，很荣幸您阅读此文，本文只是自己在学习JAVA过程中的笔记，如有不足，期待您的评论指点和关注，欢迎欢迎~~

✨✨个人主页：敲代码的小董

💗💗系列专栏：JAVA

​

​

目录

1. 为什么需要继承

2. 继承概念

3. 继承的语法

4. 父类成员访问

4.1 子类中访问父类的成员变量

4.2 子类中访问父类的成员方法 

5. super 关键字 

6. 子类构造方法

7. super 和 this 

8. 再谈初始化

9. protected 关键字

10. 继承方式 

11. final 关键字 

11.1 final 类

11.2 final 方法

11.3 final 变量

12. 继承与组合

13. 继承的最佳实践

14. 常见问题与陷阱

---

上一节：七. JAVA类和对象（四）-CSDN博客

1. 为什么需要继承

        在软件开发的世界里，代码的复用性和可维护性至关重要。想象一个场景，你正在开发一个学校管理系统，其中涉及学生、教师和管理人员。这些角色都有一些共同的属性，比如姓名、年龄，也有一些共同的行为，像登录系统。如果为每个角色都编写重复的代码来实现这些属性和行为，不仅会让代码变得冗长，还会增加维护的难度。一旦需要修改这些共同的属性或行为，就需要在多个地方进行修改，容易出错。

比如：狗和猫，它们都是一个动物。

​

使用Java语言来进行描述，就会设计出：

​

通过观察上述代码会发现，猫和狗的类中存在大量重复，如下所示：

​

        继承的出现就是为了解决这个问题。它允许我们创建一个通用的父类，将这些共同的属性和行为放在父类中，然后让各个子类继承这个父类。这样，子类就可以自动拥有父类的属性和行为，从而实现代码的复用。同时，如果需要修改共同的属性或行为，只需要在父类中进行修改，所有子类都会受到影响，大大提高了代码的可维护性。 

---

 

2. 继承概念

        继承是面向对象编程（OOP）的基本特性之一，它描述了类与类之间的一种关系。在继承关系中，有父类（也称为基类、超类）和子类（也称为派生类）。子类可以继承父类的属性和方法，并且可以在此基础上添加自己的属性和方法，或者重写父类的方法以实现不同的行为。这种关系体现了一种 “is - a” 的逻辑，即子类是父类的一种特殊类型。例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。

​

        上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
        从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态。

---

 

3. 继承的语法

        在 Java 中，使用 extends 关键字来实现继承。其基本语法如下：

class 父类名 {// 父类的成员变量和方法
}class 子类名 extends 父类名 {// 子类的成员变量和方法
}

对 1.为什么需要继承 中场景使用继承方式重新设计：

 Animal.java

public class Animal{String name;int age;public void eat(){System.out.println(name + "正在吃饭");}public void sleep(){System.out.println(name + "正在睡觉");}
}

 Dog.java

public class Dog extends Animal{void bark(){System.out.println(name + "汪汪汪~~~");}
}

 Cat.Java

public class Cat extends Animal{void mew(){System.out.println(name + "喵喵喵~~~");}
}

        在这个示例中，Animal是父类，Dog、Cat是子类。Dog、Cat类继承了Animal类的name、age成员变量和 eat( )、sleep( ) 方法，并且添加了自己的 brak( )、mew( ) 方法。

注意：

• 子类会将父类中的成员变量或者成员方法继承到子类中了.
• 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了.

---

4. 父类成员访问

        在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

4.1 子类中访问父类的成员变量

子类和父类不存在同名成员变量：

        当子类和父类不存在同名成员变量时，子类可以直接访问父类的成员变量。示例代码如下：

class Parent {int parentVar = 10;
}class Child extends Parent {public void printParentVar() {System.out.println(parentVar);}
}

        在这个例子中，Child 类的 printParentVar() 方法可以直接访问类 Parent 的 parentVar 成员变量。

子类和父类成员变量同名：

class Parent {int a;int b;int c;
}
class Child extends Parent{int a;     // 与父类中成员a同名，且类型相同char b;    // 与父类中成员b同名，但类型不同public void method(){a = 100; // 访问父类继承的a，还是子类自己新增的a？b = 101; // 访问父类继承的b，还是子类自己新增的b?c = 102; // 子类没有c，访问的肯定是从父类继承下来的c// d = 103; // 编译失败，因为父类和子类都没有定义成员变量b}
}

在子类方法中 或者 通过子类对象访问成员时：

1. 如果访问的成员变量子类中有，优先访问自己的成员变量。
2. 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
3. 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
4. 成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

4.2 子类中访问父类的成员方法 

成员方法名字不同：

当子类和父类的成员方法名字不同时，子类可以直接调用父类的方法。示例代码如下：

class Parent {public void parentMethod() {System.out.println("父类的方法");}
}class Child extends Parent {public void childMethod() {parentMethod();System.out.println("子类的方法");}
}

在这个例子中，Child 类的 childMethod() 方法可以直接调用父类 Parent 的 parentMethod() 方法。

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

成员方法名字相同：

class Parent {public void methodA(){System.out.println("Base中的methodA()");}public void methodB(){System.out.println("Base中的methodB()");}
}
class Chiled extends Parent{public void methodA(int a) {System.out.println("Derived中的method(int)方法");}public void methodB(){System.out.println("Derived中的methodB()方法");}public void methodC(){methodA();     // 没有传参，访问父类中的methodA()methodA(20);   // 传递int参数，访问子类中的methodA(int)methodB();     // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到}
}

说明：

• 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
• 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

 问题：如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？ 

---

5. super 关键字 

        由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。它有以下几种常见的用法：

• 访问父类的成员变量：super.成员变量名
• 调用父类的成员方法：super.成员方法名()
• 调用父类的构造方法：super() 或 super(参数列表)

class Parent {int var = 10;public Parent() {System.out.println("父类的无参构造方法");}public Parent(int var) {this.var = var;System.out.println("父类的有参构造方法");}public void method() {System.out.println("父类的方法");}
}class Child extends Parent {int var = 20;public Child() {super(); // 调用父类的无参构造方法}public Child(int var) {super(var); // 调用父类的有参构造方法}public void printVars() {System.out.println("子类的 var: " + var);System.out.println("父类的 var: " + super.var);}public void callParentMethod() {super.method();}
}

注意：只能在非静态方法中使用 

---

6. 子类构造方法

        在 Java 中，子类的构造方法在执行时，会默认先调用父类的无参构造方法。如果父类没有无参构造方法，子类必须在构造方法的第一行使用 super(参数列表) 显式调用父类的有参构造方法。示例代码如下：

class Parent {int var;public Parent(int var) {this.var = var;System.out.println("父类的有参构造方法");}
}class Child extends Parent {public Child(int var) {super(var); // 显式调用父类的有参构造方法System.out.println("子类的构造方法");}
}

        在这个例子中，由于父类 Parent 没有无参构造方法，所以子类 Child 的构造方法必须显式调用父类的有参构造方法。

        在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，父类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。 

注意：

• 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法。
• 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
• 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
• super(...)只能在子类构造方法中出现一次，并且不能和this同时出现。

---

7. super 和 this 

super 和 this 都是 Java 中的关键字，他们之间有什么区别呢？

相同点：

• 都是Java中的关键字。
• 只能在类的非静态方法中使用，用来访问非静态成员方法和字段。
• 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。

不同点：

• this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用。
• 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性。
• 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现。
• 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有。 

​

---

 

8. 再谈初始化

        我们还记得之前讲过的代码块吗？我们简单回顾一下几个重要的代码块：实例代码块和静态代码块。

在没有继承关系时的执行顺序：

​

继承关系上的执行顺序： 

class Person {public String name;public int age;public Person(String name, int age) {this.name = name;this.age = age;System.out.println("Person：构造方法执行");}{System.out.println("Person：实例代码块执行");}static {System.out.println("Person：静态代码块执行");}
}
class Student extends Person{public Student(String name,int age) {super(name,age);System.out.println("Student：构造方法执行");}{System.out.println("Student：实例代码块执行");}static {System.out.println("Student：静态代码块执行");}
}
public class TestDemo {public static void main(String[] args) {Student student1 = new Student("stu1", 19);System.out.println("===========================");Student student2 = new Student("syu2", 20);}
}

执行结果：

​

通过分析执行结果，得出以下结论：

• 父类静态代码块优先于子类静态代码块执行，且是最早执行。
• 父类实例代码块和父类构造方法紧接着执行。
• 子类的实例代码块和子类构造方法紧接着再执行。
• 第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行。

---

9. protected 关键字

        protected 是 Java 中的一种访问修饰符，它的访问权限介于 private 和 public 之间。被 protected 修饰的成员可以在同一个包内的任何类中访问，也可以在不同包的子类中访问。示例代码如下：

// 父类
package com.example.parent;public class Parent {protected int protectedVar = 10;protected void protectedMethod() {System.out.println("这是一个受保护的方法");}
}// 子类
package com.example.child;import com.example.parent.Parent;public class Child extends Parent {public void accessParentProtected() {System.out.println("访问父类的受保护成员变量: " + protectedVar);protectedMethod();}
}

​

---

10. 继承方式 

 在现实生活中，事物之间的关系是非常复杂，灵活多样，比如：

​

但在Java中只支持以下几种继承方式： 

​

注意：

• Java中不支持多继承（接口继承实现多继承）。
• Java继承一般我们不希望出现超过三层的继承关系。
• 想要限制继承可以使用 final 关键字。

---

 

11. final 关键字 

final关键可以用来修饰变量、成员方法以及类。

11.1 final 类

final class Immutable {// 表示此类不能被继承
}

11.2 final 方法

class Base {final void fixedMethod() { /* ... */ }
}class Derived extends Base {// 无法重写
}

11.3 final 变量

final int MAX_SIZE = 100;
// MAX_SIZE = 200; // 编译错误 修饰变量或字段，表示常量(即不能修改)

---

 

12. 继承与组合

        和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。

继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物
组合表示对象之间是has-a的关系，比如：汽车

​

class Engine {void start() { /* ... */ }
}class Car {private Engine engine = new Engine();void startCar() {engine.start(); // 组合调用}
}

         组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合。

---

13. 继承的最佳实践

1. 里氏替换原则：子类应能替换父类出现的任何地方。
2. 优先使用组合：除非明确需要继承语义。
3. 合理使用 protected：避免过度暴露父类实现细节。
4. finalize 设计：用 final 修饰不希望被重写的类 / 方法。
5. 构造方法规范：父类应提供无参构造或明确构造调用链。

---

14. 常见问题与陷阱

1. 隐藏字段问题：子类声明与父类同名的字段会导致隐藏，应避免
2. 构造方法调用顺序：必须保证父类构造在子类之前执行
3. 多态方法调用：子类重写方法时，注意参数列表和返回类型
4. 接口继承 vs 类继承：接口用于行为抽象，类继承用于实现复用