Il problema delle proprietà private nell'ereditarietà in OOP in JavaScript

Il fatto che le proprietà private non vengano ereditate può portare a un problema inaspettato. Diamo un'occhiata a un esempio. Supponiamo di avere la seguente classe genitore con una proprietà privata:

class User {
	#age;
	
	setAge(age) {
		this.#age = age;
	}
	getAge() {
		return this.#age;
	}
}

Supponiamo che nella classe figlia abbiamo deciso di creare un metodo che aumenterà l'età di uno. Tuttavia, il tentativo di modificare la proprietà privata del genitore risulterà in un errore:

class Student extends User {
	incAge() {
		this.#age++; // errore
	}
}

L'errore scomparirà se nella classe figlia dichiari la proprietà privata #age:

class Student extends User {
	#age;
	
	incAge() {
		this.#age++;
	}
}

Ed è qui che ci aspetta la trappola! In realtà abbiamo creato due proprietà private: una nel genitore e una nel figlio. E funzionano completamente in modo indipendente. Ciò significa che i metodi del genitore modificheranno la propria proprietà, mentre i metodi del figlio - le proprie.

Questo problema in realtà ha una soluzione. Basta manipolare le proprietà private del genitore attraverso i metodi di quel genitore. Riscriviamo il nostro codice in accordo con questo:

class Student extends User {
	incAge() {
		let age = this.getAge();
		age++;
		this.setAge(age);
	}
}

Può essere semplificato:

class Student extends User {
	incAge() {
		this.setAge(++this.getAge());
	}
}

Nel codice seguente, nella classe figlia, il metodo del genitore viene sovrascritto. Correggi i problemi in questo codice:

class User {
	#name;
	
	setName(name) {
		this.#name = name;
	}
	getName() {
		return this.#name;
	}
}

class Employee extends User {
	setName(name) {
		if (name.length > 0) {
			this.#name = name;
		}
	}
}