Generics solve the problem of returning different external instances in class inheritance

[zrwusa]

class BinaryTreeNode {
}

class BinaryTree {
	getNode() {
  		return new BinaryTreeNode()
	}
}

class BSTNode extends BinaryTreeNode {
}

class BST extends BinaryTree {
	someMethod () {
		console.log(this.getNode())
	}
}

In the someMethod, when calling the this.getNode() method, it returns a BinaryTreeNode type, but I want it to return a BSTNode type. How can I achieve this? Is this design pattern not quite reasonable?

In the TypeScript code you provided, the BST class inherits from the BinaryTree class, and the getNode method of the BinaryTree class returns an instance of BinaryTreeNode. When you call this.getNode() within the BST class, it indeed returns an object of type BinaryTreeNode, not BSTNode. This is because the getNode method is defined in the BinaryTree class to return objects of type BinaryTreeNode.

To address this issue, you can use generics in TypeScript to define the BinaryTree class so that it can return different types of nodes. Here is an example of how to refactor your code using generics

class BinaryTreeNode {
}

class BinaryTree<T extends BinaryTreeNode> {
    getNode(): T {
        return new BinaryTreeNode() as T;
    }
}

class BSTNode extends BinaryTreeNode {
}

class BST extends BinaryTree<BSTNode> {
    someMethod() {
        console.log(this.getNode()); // This will return a BSTNode type here
    }
}

In this modified code, the BinaryTree class is defined as a generic class BinaryTree, where T can be any type that extends BinaryTreeNode. The getNode method returns an object of type T.

Then, in the BST class, we specify the generic parameter of BinaryTree as BSTNode. This means that in the context of the BST class, the getNode method will return objects of type BSTNode.

As for the design pattern question, using generics is a common approach in object-oriented programming to handle such issues. It allows for code to maintain type safety while providing better reusability and flexibility.