Quels modèles de conception sont courants en JavaScript et TypeScript mais pas en Java?

• Singleton (en JS/TS est plus facilement réalisé grâce aux modules et aux closures).
• Module (patron implicite du langage).
• Prototype (par héritage prototype).
• Mixin (via Object.assign, classes ou fonctions de fabrique).
• Pattern de module révélant (avec utilisation de closures).
• Fonction de fabrique (alternative aux constructeurs de classes).
• Injection de dépendances (souvent via des usines ou des conteneurs, pas autant basé sur des annotations qu’en Java).

Exemples de différences :

• Singleton :

// singleton.js
const instance = {
  data: 'some data'
};

export default instance; // Exportation simple d’une seule instance

En Java, il faut une méthode statique getInstance() et un constructeur privé.

• Module :

// module.js
const privateVar = 'private';

export function publicMethod() {
  console.log(privateVar);
}

En Java, il faut déclarer explicitement des classes et des modificateurs d’accès.

• Prototype :

const animal = {
  speak() {
    console.log('...');
  }
};

const dog = Object.create(animal);
dog.speak = function() {
  console.log('woof');
};

dog.speak(); // woof

En Java, l’héritage est basé sur des classes.

• Mixin :

const searchable = {
  search() {
    console.log('Searching...');
  }
};

class Article {
  constructor(title) {
    this.title = title;
  }
}

Object.assign(Article.prototype, searchable);

const myArticle = new Article('Hello');
myArticle.search(); // Searching...

En Java, il n’y a pas de support natif pour les mixins (on utilise des interfaces ou la composition).