GDScript Inheritance: extends, super() and Overriding

A class can extends another class. It gets every variable and method of its parent, and can add or replace them:

extends Node

class Character:
	var title := "someone"
	var hp := 10

	func attack() -> int:
		return 2

	func describe() -> String:
		return "%s with %d hp" % [title, hp]

class Knight extends Character:
	var armor := 3

	func attack() -> int:          # override: replaces the parent's version
		return 7

func _ready():
	var knight := Knight.new()
	knight.title = "a knight"
	print(knight.describe())       # inherited from Character
	print(knight.attack(), " ", knight.armor)

a knight with 10 hp
7 3

Your scripts already use inheritance: extends Node2D makes the script a Node2D, with position, rotation and every other property of that class.

Calling the Parent with super

An override often adds to the parent's behavior instead of replacing it. super.method() calls the parent's version:

extends Node

class Character:
	var title: String
	var hp: int

	func _init(t: String, start_hp: int):
		title = t
		hp = start_hp

	func describe() -> String:
		return "%s (%d hp)" % [title, hp]

class Knight extends Character:
	var armor := 3

	func _init(t: String):
		super(t, 30)               # the parent's _init with these arguments

	func describe() -> String:
		return super.describe() + ", armor " + str(armor)

func _ready():
	print(Knight.new("Ana").describe())
	print(Character.new("Bo", 10).describe())

Ana (30 hp), armor 3
Bo (10 hp)

• super(...) inside _init() runs the parent constructor with arguments. Call it before using the parent's members.
• super.describe() runs the parent's describe().
• Plain super() in any method calls the parent's version of that same method.

Godot calls _ready() on a child script's node and, if the parent script defines _ready() too, only the child's runs. Call super() at the start of the child's _ready() when the parent's setup must still happen.

One Type, Many Classes

A child is also its parent type, so one list can hold them all and each object runs its own version of a method:

extends Node

class Enemy:
	func sound() -> String:
		return "..."

class Bat extends Enemy:
	func sound() -> String:
		return "screech"

class Golem extends Enemy:
	func sound() -> String:
		return "rumble"

func _ready():
	var horde: Array[Enemy] = [Bat.new(), Golem.new(), Enemy.new()]
	for enemy in horde:
		print(enemy.sound())
	print(horde[0] is Bat, " ", horde[0] is Enemy, " ", horde[1] is Bat)

screech
rumble
...
true true false

This is how a game treats every enemy the same in a loop (move, take damage, die) while each type behaves differently.

Extending Another Script

Across files, extend a class by its class_name, or a script by its path:

# boss.gd
class_name Boss
extends Enemy            # enemy.gd has class_name Enemy

func take_damage(amount: int) -> void:
	super.take_damage(amount / 2)   # bosses take half damage

extends "res://enemies/enemy.gd"

A class has exactly one parent. To share behavior across unrelated classes, add a child node that does the job (composition), which Godot's node system is built for.

Abstract Classes

Since Godot 4.5, @abstract marks a class you only extend and never create, and methods children must provide:

@abstract
class_name Weapon
extends Node2D

@abstract func fire() -> void

func reload() -> void:
	print("Reloading")

Weapon.new() is then an error, and a child that does not define fire() cannot be created either.

Inheritance or Composition?

Godot favors composition: a Player scene with a Health child node, a Hitbox child and a Sprite2D child, each with its own small script, instead of a deep chain of classes. Inherit for real "is a" relations (a Boss is an Enemy). Add a node for "has a" relations (an enemy has health).