[Java基本语法] 继承与多态

Mr.Demo.2024-06-15 8:46

🌸个人主页:https://blog.csdn.net/2301_80050796?spm=1000.2115.3001.5343

🏵️热门专栏:🍕 Collection与数据结构 (92平均质量分)https://blog.csdn.net/2301_80050796/category_12621348.html?spm=1001.2014.3001.5482

🧀线程与网络(96平均质量分) https://blog.csdn.net/2301_80050796/category_12643370.html?spm=1001.2014.3001.5482

🍭MySql数据库(93平均质量分)https://blog.csdn.net/2301_80050796/category_12629890.html?spm=1001.2014.3001.5482

🍬算法(97平均质量分)https://blog.csdn.net/2301_80050796/category_12676091.html?spm=1001.2014.3001.5482

感谢点赞与关注~~~

目录

  • [1. 继承与多态](#1. 继承与多态)
    • [1.1 继承](#1.1 继承)
      • [1.1.1 为什么需要继承](#1.1.1 为什么需要继承)
      • [1.1.2 继承的概念](#1.1.2 继承的概念)
      • [1.1.3 继承的语法格式](#1.1.3 继承的语法格式)
      • [1.1.4 父类成员访问](#1.1.4 父类成员访问)
      • [1.1.5 super关键字](#1.1.5 super关键字)
      • [1.1.6 子类构造方法](#1.1.6 子类构造方法)
      • [1.1.7 super和this](#1.1.7 super和this)
      • [1.1.8 继承体系下的代码块](#1.1.8 继承体系下的代码块)
      • [1.1.9 再谈访问限定符](#1.1.9 再谈访问限定符)
      • [1.1.10 继承方式](#1.1.10 继承方式)
      • [1.1.11 final关键字](#1.1.11 final关键字)
      • [1.1.12 继承与组合](#1.1.12 继承与组合)
    • [1.2 多态](#1.2 多态)
      • [1.2.1 多态的概念](#1.2.1 多态的概念)
      • [1.2.2 多态实现的条件](#1.2.2 多态实现的条件)
      • [1.2.3 重写](#1.2.3 重写)
      • [1.2.4 向上转型和向下转型](#1.2.4 向上转型和向下转型)
      • [1.2.5 避免在构造方法中使用重写的方法](#1.2.5 避免在构造方法中使用重写的方法)

1. 继承与多态

1.1 继承

1.1.1 为什么需要继承

Java中使用类对现实中的事物进行描述的时候，由于世间事物错综复杂，事物之间难免会存在一些特定的关联 ，这就是程序设计时候所需要考虑的问题。

比如：猫和狗都是动物

我们使用Java语言就会有如下描述

java 复制代码 
public class Dog{
	string name;
	int age;
	float weight;
	public void eat(){
		System.out.println(name + "正在吃饭");
	}
public void sleep(){
		System.out.println(name + "正在睡觉");
	}
void Bark(){
		System.out.println(name + "汪汪汪~~~");
	}
}
public class Cat{
	string name;
	int age;
	float weight;
	public void eat(){
		System.out.println(name + "正在吃饭");
	}
	public void sleep()
	{
		System.out.println(name + "正在睡觉");
	}
	void mew(){
		System.out.println(name + "喵喵喵~~~");
	}
}

通过上述代码发现，猫类和狗类中有大量重复的成员，它们都有自己的名字，年龄，体重，它们都会吃，会睡觉，只有叫声是不一样的。那么我们能否对这写共性进行抽取呢？面向对象的程序设计思想中提出了继承的概念，专门用来进行共性抽取，以实现代码的复用。

1.1.2 继承的概念

继承的机制：这是面向对象程序设计中使代码可以复用的最重要的手段，他允许程序员在保持一个类原有特征的同时进行扩展 ，增加功能 ，这样产生的类，称为派生类 。很好地体现了面向对象程序设计的清晰的层次结构。总之，继承所解决的问题就是：共性的抽取，实现代码的复用。

如上图所示，Dog和Cat类都继承了Animal类，其中Animal类称为父类，基类，或者超类，Dog和Cat类称为子类或者派生类，继承之后，子类就可以复用父类中的成员，子类在实现时只关心自己的成员即可。

1.1.3 继承的语法格式

在Java中入如果要表示继承关系，需要使用extends关键字，具体格式如下：

java 复制代码 
修饰符 class 子类 extends 父类{
//
}

现在，我们使用继承语法对猫类和狗类进行重新设计：

java 复制代码 
public class Animal{
	String name;
	int age;
	public void eat(){
		System.out.println(name + "正在吃饭");
	}
	public void sleep(){
		System.out.println(name + "正在睡觉");
	}
}
public class Dog extends Animal{
	void bark(){
		System.out.println(name + "汪汪汪~~~");
	}
}
public class Cat extends Animal{
	void mew(){
		System.out.println(name + "喵喵喵~~~");
	}
}

注意事项：

  • 子类会将父类的成员变量 和成员方法继承到子类中
  • 子类继承父类之后，必须要新添加自己特有的成员，否则就没必要继承了
  • static修饰的成员不可以继承，因为他们不属于对象，他们属于类（这时候可以返回上一篇文章看看删掉的那一行了）

1.1.4 父类成员访问

在继承体系中，既然子类把父类的方法和字段都继承下来了，那子类怎样去访问父类中的成员呢？

1.1.4.1子类中访问父类的成员变量
  1. 子类和父类不存在同名的情况
java 复制代码 
public class Base {
	int a;
	int b;
}
public class Derived extends Base{
	int c;
	public void method(){
		a = 10; // 访问从父类中继承下来的a
		b = 20; // 访问从父类中继承下来的b
		c = 30; // 访问子类自己的c
	}
}

不同名的情况下，可直接访问父类成员

  1. 子类和父类同名的情况
java 复制代码 
public class Base {
	int a;
	int b;
	int c;
}
public class Derived extends Base{
	int a; // 与父类中成员a同名，且类型相同
	char b; // 与父类中成员b同名，但类型不同
	public void method(){
		a = 100; // 访问父类继承的a，还是子类自己新增的a？自己的
		b = 101; // 访问父类继承的b，还是子类自己新增的b? 自己的
		c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
	}
}

子类中的成员访问遵循以下原则：

  • 如果访问的成员变量中，子类里有，优先访问自己的成员变量
  • 如果访问的成员变量中，子类中没有，但父类中有，则访问父类继承下来的
  • 如果访问的成员变量子类和父类重名，优先访问自己的

成员变量的访问遵循就近访问原则，自己有优先用自己的，如果没有再从父类中去找

1.1.4.2 子类中访问父类的成员方法
  1. 成员方法不同名
java 复制代码 
public class Base {
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
}
public class Derived extends Base{
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		methodB(); // 访问子类自己的methodB()
		methodA(); // 访问父类继承的methodA()
	}
}
  1. 成员方法同名
java 复制代码 
public class Base {
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
		System.out.println("Base中的methodB()");
	}
}
public class Derived extends Base{
	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()，基类的无法访问到
	}
}

总结

  • 通过子类对象访问父类与子类不同名的方法时，优先在子类中找，否则在父类中找
  • 通过子类对象访问父类与子类同名的方法时，若两种方法构成重载，根据调用参数的不同调用相应的方法，至于参数列表相同的情况，我们在后面解释到方法的重写的时候再详细解释

那么问题来了，如果在子类中，我偏要访问父类的成员呢？这时我们就需要引入下一个关键字。

1.1.5 super关键字

既然想要在子类中访问父类的成员，直接访问是无法做到的，这时，Java就为我们提供了super关键字 ，这个关键字的作用是：在子类方法中访问父类成员。

java 复制代码 
public class Base {
	int a;
	int b;
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
		System.out.println("Base中的methodB()");
	}
}
public class Derived extends Base{
	int a; // 与父类中成员变量同名且类型相同
	char b; // 与父类中成员变量同名但类型不同
	// 与父类中methodA()构成重载
	public void methodA(int a) {
		System.out.println("Derived中的method()方法");
	}
	// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		// 对于同名的成员变量，直接访问时，访问的都是子类的
		a = 100; // 等价于： this.a = 100;
		b = 101; // 等价于： this.b = 101;
		// 注意：this是当前对象的引用
		// 访问父类的成员变量时，需要借助super关键字
		// super是获取到子类对象中从基类继承下来的部分
		super.a = 200;
		super.b = 201;
		// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
		methodA(); // 没有传参，访问父类中的methodA()
		methodA(20); // 传递int参数，访问子类中的methodA(int)
		// 如果在子类中要访问重写的基类方法，则需要借助super关键字
		methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
		super.methodB(); // 访问基类的methodB()
		}
	}

注意事项

  • 只能在非静态方法中使用
  • 在子类方法中，访问父类的成员变量和方法会用到
  • super还有其他用法，后续介绍

1.1.6 子类构造方法

父子父子，先有父再有子，即：子类对象构造时，需要先调用父类的构造方法，然后再执行子类的构造方法

java 复制代码 
public class Base {
	public Base(){
		System.out.println("Base()");
	}
}
public class Derived extends Base{
	public Derived(){
		// super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
		// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
		// 并且只能出现一次
		System.out.println("Derived()");
	}
}
public class Test {
	public static void main(String[] args) {
		Derived d = new Derived();
	}
}

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

  • 如果父类，显式定义无参或者默认构造方法时，在子类构造方法的第一行有默认的super（）调用，即调用父类的构造方法
  • 如果父类的构造方法是带有参数的，此时需要在子类构造方法中主动调用父类构造方法
  • 在子类构造方法中，super调用父类构造方法的语句必须放在子类构造方法的第一行
  • super只能在子类构造方法中出现一次，且不可以与this同时出现

1.1.7 super和this

【相同点】

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

【不同点】

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

1.1.8 继承体系下的代码块

还记得我们之前讲的代码块吗，我们简单回顾，主要有两种代码块 ：实例代码块和静态代码块 ，在没有继承关系下的执行顺序是：静态代码块>实例代码块

java 复制代码 
class Person {
	public String name;
	public int age;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("构造方法执行");
	}
	{
		System.out.println("实例代码块执行");
	}
	static {
		System.out.println("静态代码块执行");
	}
}
public class TestDemo {
	public static void main(String[] args) {
		Person person1 = new Person("zhangsan",10);
		System.out.println("============================");
		Person person2 = new Person("lisi",20);
	}
}
  • 静态代码块先执行，并且只执行一次，在类加载阶段执行
  • 有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后执行构造方法
    （详细内容请参考前面的文章）

要是加入了继承关系呢？

java 复制代码 
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 TestDemo4 {
	public static void main(String[] args) {
		Student student1 = new Student("zhangsan",19);
		System.out.println("===========================");
		Student student2 = new Student("lisi",20);
		}
}

执行结果：

Person：静态代码块执行

Student：静态代码块执行

Person：实例代码块执行

Person：构造方法执行

Student：实例代码块执行

Student：构造方法执行

===========================

Person：实例代码块执行

Person：构造方法执行

Student：实例代码块执行

Student：构造方法执行

经过上述分析，我们可以得出以下结论：

  • 父类静态>子类静态>父类实例>父类构造>子类实例>子类构造，原理就是，在java文件被写好之后，类就已经存在了，所以不管是父类还是子类，静态代码块都会被优先执行，且父类优先于子类，在之后实例化子类对象的时候，由于子类继承于父类，所以父类的实例代码块和构造方法优先被加载，创建一个对象的时候，先为对象分配内存空间，于是实例代码块被执行，之后调用构造方法，构造方法被执行，之后就是子类的实例代码块和构造方法
  • 第二次实例化的时候，父类和子类的静态代码块都不会再被执行，他们只执行一次，这是因为类只加载一次.

1.1.9 再谈访问限定符

再封装的章节，我们引入了访问限定符，主要限定：类或者类中成员能否再类外或者其他包中被访问

NO 范围 private default protected public
1 同一包中的同一类 √ √ √ √
2 同一包中的不同类 × √ √ √
3 不同包中的子类 × × √ √
4 不同包中的非子类 × × × √

这里记忆的时候，分为同一包和不同包，同一类和不同类，子类和非子类.

那么父类中不同访问权限的成员，在子类中的可见性怎么样呢？

java 复制代码 
// extend01包中
public class B {
	private int a;
	protected int b;
	public int c;
	int d;
}
// extend01包中
// 同一个包中的子类
public class D extends B{
	public void method(){
		// super.a = 10; // 编译报错，父类private成员在相同包子类中不可见
		super.b = 20; // 父类中protected成员在相同包子类中可以直接访问
		super.c = 30; // 父类中public成员在相同包子类中可以直接访问
		super.d = 40; // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问
	}
}
// extend02包中
// 不同包中的子类
public class C extends B {
	public void method(){
		// super.a = 10; // 编译报错，父类中private成员在不同包子类中不可见
		super.b = 20; // 父类中protected修饰的成员在不同包子类中可以直接访问
		super.c = 30; // 父类中public修饰的成员在不同包子类中可以直接访问
		//super.d = 40; // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
	}
}
// extend02包中
// 不同包中的类
public class TestC {
	public static void main(String[] args) {
		C c = new C();
		c.method();
		// System.out.println(c.a); // 编译报错，父类中private成员在不同包其他类中不可见
		// System.out.println(c.b); // 父类中protected成员在不同包其他类中不能直接访问
		System.out.println(c.c); // 父类中public成员在不同包其他类中可以直接访问
		// System.out.println(c.d); // 父类中默认访问权限修饰的成员在不同包其他类中不能直接访问
	}
}
  • 如上面的代码所示，想要在子类中访问到父类中的成员，在允许访问到的前提下，我们可以通过super访问到
  • 父类中的private成员虽然在子类中不可以访问到，但是也继承到了子类中
  • 注意在使用访问限定符时，要认证思考，不可以滥用访问限定符，考虑好类中的字段和方法提供给"谁"用，从而加上合适的访问限定符

1.1.10 继承方式

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

注意 ：Java中不支持多继承
就像一个孩子不可以有多个父亲一样，但是一个父亲可以有多个孩子，就像上面的第三种

1.1.11 final关键字

我们有时不希望一个类被继承，我们希望在继承上进行限制，这时我们就需要用到final关键字

，而且final不仅可以修饰类，还可以用来修饰变量，成员方法

  1. 修饰变量或者字段，表示常量（即不可以被修改）
java 复制代码 
final int a=10;
//a=20 error
  1. 修饰类，表示一个类不可以被继承，称为密封类
java 复制代码 
final public class Animal{
//
}
//public class Cat extends Animal{
//
//} error
  1. 修饰方法：表示该方法不可以被重写

1.1.12 继承与组合

和继承类似，组合也是一种表达类之间关系的方式，也可以实现代码的复用。组合并没有用到什么关键字，也没有固定的语法格式，仅仅是将一个类的实例作为另外一个类的字段

继承表示的是一种is a 的关系，比如猫是动物

而组合表示的是一种has a 的关系，比如人有心脏

java 复制代码 
class Heart{
//
}
class Brain{
//
}
class Lungs{
//
}
class Person{
   private Heart heart;
   private Brain brain;
   private Lungs lungs;
}

组合和继承都可以实现代码的复用，该继承还是组合，一般看实际的应用场景

1.2 多态

1.2.1 多态的概念

通俗来说就是：多种形态，具体一点就是去完成某个行为，当不同的对象去完成的时候会产生出不同的效果

总的来说：同一件事情发生在不同对象的身上，就会产生不同的结果

1.2.2 多态实现的条件

Java中想要实现多态，必须要满足以下几个条件，缺一不可：

  • 必须在继承体系下
  • 子类必须要对父类中的方法进行重写
  • 通过父类引用调用重写的方法
    多态实现：在代码运行时，当传递不同类对象时，会调用对应类中的方法
java 复制代码 
public class Animal {
	String name;
	int age;
	public Animal(String name, int age){
		this.name = name;
		this.age = age;
	}
	public void eat(){
		System.out.println(name + "吃饭");
	}
}
public class Cat extends Animal{
	public Cat(String name, int age){
		super(name, age);
	}
@Override
	public void eat(){
		System.out.println(name+"吃鱼~~~");
	}
}
public class Dog extends Animal {
	public Dog(String name, int age){
		super(name, age);
	}
	@Override
	public void eat(){
		System.out.println(name+"吃骨头~~~");
	}
}
public class TestAnimal {
	// 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
	// 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
	// 注意：此处的形参类型必须时父类类型才可以
	public static void eat(Animal a){
		a.eat();
	}
	public static void main(String[] args) {
		Cat cat = new Cat("元宝",2);
		Dog dog = new Dog("小七", 1);
		eat(cat);
		eat(dog);
	}
}

当类的调用者在编写eat这个方法的时候，参数类型为Animal，此时在方法内部并不关注当前的a指向的是那个类型的实例，此时a这个引用调用eat方法可能会有多种不同的表现，这种行为称为多态

1.2.3 重写

  1. 概念
    重写：也称为覆盖。重写就是对非静态方法，非private修饰的方法，非final修饰的方法，非构造方法的实现过程进行重新编写 ，返回值和形参都不能改变，即外壳不变，实现核心重写，好处就是子类可以在父类的基础上实现自己的方法，定义特定于自己的行为。
  2. 规则
  • 子类在重写父类的方法时，一般情况下返回值和形参都不能改变
  • 被重写的方法返回值类型有时可以不同，但是他们必须具有父子关系
  • 访问权限不可以比父类中被重写的方法更低，例如：父类方法被public修饰，则子类方法中重写该方法就不能声明为private
  • 父类方法不可以被static，final，private修饰，也不可以是构造方法，否者不可以被重写
  • 重写的方法，编译器会用"@override"来注解，可以检查合法性
  1. 重写和重载的区别
区别点 重写 重载
参数列表 一定不可以修改 必须修改
返回类型 一定不可以修改（除非有父子关系） 可以修改
访问限定符 一定不可以降低权限 可以修改
  1. 静态绑定与动态绑定
  • 静态绑定：也称为前期绑定，在编译时根据用户传递的参数类型就可以知道调用哪个方法，典型代表为方法的重载
  • 动态绑定：也称为后期绑定，在编译时，不可以确定方法的行为，无法知道调用哪个方法，需要等程序运行时才可以确定。

1.2.4 向上转型和向下转型

  1. 向上转型
    1. 概念：创建一个子类对象，把他当做父类对象来使用，就是范围从小到大的转换
    2. 语法格式：==父类类型 对象名=new 子类类型（）
java 复制代码 
Animal animal=new Cat("miaomiao",2);

我们就拿上面的代码来说明：

  1. 使用场景

  • 直接赋值

  • 方法传参

  • 方法返回

java 复制代码 
public class TestAnimal {
// 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
	public static void eatFood(Animal a){
		a.eat();
	}
// 3. 作返回值：返回任意子类对象
	public static Animal buyAnimal(String var){
		if("狗".equals(var) ){
			return new Dog("狗狗",1);
		}else if("猫" .equals(var)){
			return new Cat("猫猫", 1);
		}else{
			return null;
	}
}
public static void main(String[] args) {
	Animal cat = new Cat("元宝",2); // 1. 直接赋值：子类对象赋值给父类对象
	Dog dog = new Dog("小七", 1);
	eatFood(cat);
	eatFood(dog);
	Animal animal = buyAnimal("狗");
	animal.eat();
	animal = buyAnimal("猫");
	animal.eat();
	}
}

通过上述的代码，我们不难发现向上转型的有限，他可以使得代码更加简单灵活 ，但是缺点也很明显，不可以调用子类特有的方法，怎么办呢，我们这里便引出了向下转型

  1. 向下转型

    将一个子类对象经过向上转型之后当做了父类的对象使用，无法再调用到子类的方法，但是我们有时候会想要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转型

    1. 语法格式：子类类型 对象名=（子类类名）经过向上转型的父类对象
      从上述语法格式来看，其实就是强制类型转换
    2. 安全性问题
      向下转型存在不安全的问题，不同于向上转型，是安全的，比如原来一个对象是狗类，向上转为了动物类，再向下转型的时候必须转回狗类，不可以转为猫类
    java 复制代码 
    public class TestAnimal {
	public static void main(String[] args) {
		Cat cat = new Cat("元宝",2);
		Dog dog = new Dog("小七", 1);
		// 向上转型
		Animal animal = cat;
		animal.eat();
		animal = dog;
		animal.eat();
		// 编译失败，编译时编译器将animal当成Animal对象处理
		// 而Animal类中没有bark方法，因此编译失败
		// animal.bark();
		// 向上转型
		// 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
		// 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
		cat = (Cat)animal;
		cat.mew();
		// animal本来指向的就是狗，因此将animal还原为狗也是安全的
		dog = (Dog)animal;
		dog.bark();
	}
}
    1. 解决方案
      使用instanceof判断一个对象所属于的类是否属于一个类的父类
    java 复制代码 
    public class TestAnimal {
	public static void main(String[] args) {
	Cat cat = new Cat("元宝",2);
	Dog dog = new Dog("小七", 1);
	// 向上转型
	Animal animal = cat;
	animal.eat();
	animal = dog;
	animal.eat();
	if(animal instanceof Cat){
		cat = (Cat)animal;
		cat.mew();
	}
	if(animal instanceof Dog){
		dog = (Dog)animal;
		dog.bark();
	}
}
}

1.2.5 避免在构造方法中使用重写的方法

下面展示一段有坑的代码

java 复制代码 
class B {
	public B() {
		func();
	}
	public void func() {
		System.out.println("B.func()");
	}
}
class D extends B {
	private int num = 1;
	@Override
	public void func() {
		System.out.println("D.func() " + num);
	}
}
public class Test {
	public static void main(String[] args) {
		D d = new D();
	}
}

运行结果：D.func() 0

难道结果不应该是1吗，我们下面解释为什么不是1

在构造D对象的同时，会调用B的构造方法，在子类构造的时候，先构造父类。B的构造方法调用了func方法，此时会触发动态绑定 ，会调用D中的func，此时D还没有触发构造方法，D自身还没有构造，此时num处于未初始化状态 ，值为0，所以输出为0.

所以我们在构造方法中调用重写方法时一定要注意，在自己编程是尽量避免这种行为

相关推荐
Gu Gu Study几秒前
枚举与lambda表达式，枚举实现单例模式为什么是安全的，lambda表达式与函数式接口的小九九~
java·开发语言
Chris _data3 分钟前
二叉树oj题解析
java·数据结构
牙牙7059 分钟前
Centos7安装Jenkins脚本一键部署
java·servlet·jenkins
时光の尘15 分钟前
C语言菜鸟入门·关键字·float以及double的用法
运维·服务器·c语言·开发语言·stm32·单片机·c
paopaokaka_luck16 分钟前
[371]基于springboot的高校实习管理系统
java·spring boot·后端
以后不吃煲仔饭29 分钟前
Java基础夯实——2.7 线程上下文切换
java·开发语言
进阶的架构师30 分钟前
2024年Java面试题及答案整理（1000+面试题附答案解析）
java·开发语言
前端拾光者34 分钟前
利用D3.js实现数据可视化的简单示例
开发语言·javascript·信息可视化
The_Ticker35 分钟前
CFD平台如何接入实时行情源
java·大数据·数据库·人工智能·算法·区块链·软件工程
程序猿阿伟35 分钟前
《C++ 实现区块链：区块时间戳的存储与验证机制解析》
开发语言·c++·区块链
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作