Quais padrões de projeto são comuns em JavaScript e TypeScript que não existem em Java?

• Singleton (em JS/TS é mais facilmente implementado através de módulos e closures).
• Module (padrão implícito da linguagem).
• Prototype (através de herança prototípica).
• Mixin (via Object.assign, classes ou funções de fábrica).
• Padrão de módulo revelador (usando closures).
• Função de fábrica (alternativa aos construtores de classes).
• Injeção de dependências (mais frequentemente via fábricas ou contêineres, não tão dependente de anotações como em Java).

Exemplos de diferenças:

• Singleton:

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

export default instance; // Exportação simples de uma única instância

Em Java, é necessário um método estático getInstance() e um construtor privado.

• Module:

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

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

Em Java, é necessário declarar explicitamente classes e modificadores de acesso.

• Prototype:

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

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

dog.speak(); // woof

Em Java, herança é baseada em 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...

Em Java, não há suporte nativo para mixins (usam-se interfaces ou composição).