O Composite é um padrão estrutural que compartilha objetos em estruturas de árvore para representar hierarquias parte-todo, permitindo que clientes tratem objetos individuais e composições de objetos uniformemente. Ele é utilizado para aplicações que desejam ignorar a diferença entre composição de objetos e objetos individuais.

Um exemplo de problema solucionado pelo Composite é o seguinte: um congresso inscreve participantes que podem ser um indivíduo ou uma instituição, e cada indivíduo tem um assento no congresso.

Segue abaixo o diagrama de classes e o código fonte que demonstram a implementação do padrão como solução.

Diagrama de Classes utilizando o padrão Composite como solução

Classe abstrata para componente Participante:

public abstract class Participante {

	public String getNome() {
		throw new UnsupportedOperationException();
	}

	public int getAssento() {
		throw new UnsupportedOperationException();
	}

	public void adicionar(Participante participante) {
		throw new UnsupportedOperationException();
	}

	public void remover(Participante participante) {
		throw new UnsupportedOperationException();
	}

	public Participante getFilho(int index) {
		throw new UnsupportedOperationException();
	}
}

Classe folha para tipo primitivo Individuo:

public class Individuo extends Participante {

	private String nome;

	private int assento;

	public Individuo(String nome, int assento) {
		this.nome = nome;
		this.assento = assento;
	}

	@Override
	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	@Override
	public int getAssento() {
		return assento;
	}

	public void setAssento(int assento) {
		this.assento = assento;
	}

	@Override
	public String toString() {
		return "Nome: " + this.nome + " - Assento: " + this.assento;
	}
}

Classe composite para tipo composto Instituição:

import java.util.ArrayList;
import java.util.List;

public class Instituicao extends Participante {

	private String nome;

	private List<Participante> membros;

	public Instituicao(String nome) {
		this.nome = nome;
		membros = new ArrayList<Participante>();
	}

	@Override
	public void adicionar(Participante participante) {
		membros.add(participante);
	}

	@Override
	public void remover(Participante participante) {
		membros.remove(participante);
	}

	@Override
	public Participante getFilho(int index) {
		return membros.get(index);
	}

	@Override
	public String getNome() {
		return nome;
	}

	public List<Participante> getMembros() {
		return membros;
	}

	@Override
	public String toString() {
		return "Instituição: " + this.nome;
	}

	public void imprimeMembros() {
	   for (Participante membro : membros) {
	      System.out.println(membro + " - Instituição: " + this.nome);
	   }
	}
}

Classe cliente Congresso que utiliza interface de Participante para realizar operações:

import java.util.ArrayList;
import java.util.List;

public class Congresso {

	private String nome;

	private int totalAssentos;

	private List<Participante> participantes;

	public Congresso(String nome, int totalAssentos) {
	    this.nome = nome;
	    this.totalAssentos = totalAssentos;
	    participantes = new ArrayList<Participante>();
	}

	public String getNome() {
	    return nome;
	}

	public int getTotalAssentos() {
	    return totalAssentos;
	}

	public int getTotalParticipantes() {
	    int totalParticipantes = 0;

	    for (Participante participante : participantes) {
		if (participante instanceof Individuo) {
		  totalParticipantes++;
		} else if (participante instanceof Instituicao) {
		  Instituicao instituicao = (Instituicao) participante;
		  totalParticipantes += instituicao.getMembros().size();
		}
	    }

	    return totalParticipantes;
	}

	public void adicionarParticipante(Participante participante) {

	   if (participante instanceof Individuo) {

		if (totalAssentos > participantes.size()) {
		  participantes.add(participante);
		} else {
		  throw new UnsupportedOperationException("Congresso não possui 				assentos livres!");
		}

         } else if (participante instanceof Instituicao) {

	    Instituicao t = (Instituicao) participante;

           if (totalAssentos > participantes.size() + t.getMembros().size()) {
				participantes.add(participante);
	    } else {
		throw new UnsupportedOperationException("Congresso não possui"                      		 + " quantidade de assentos livres que Instituição necessita!");	   	    }
	  }
	} 

	public void imprimeParticipantes() {
	  System.out.println("----- Listagem de Participantes -----");
	  for (Participante participante : participantes) {
	    if (participante instanceof Individuo) {
	     System.out.println(participante + " - Instituição: Sem Filiação");
	    } else if (participante instanceof Instituicao) {
	     Instituicao instituicao = (Instituicao) participante;
	     instituicao.imprimeMembros();
	    }
	  }
	}

	@Override
	public String toString() {
	   return this.nome + " - Assentos: " + this.totalAssentos
		+ " - Participantes: " + getTotalParticipantes();
	}

	public static void main(String[] args) {
	Congresso congresso = new Congresso("Congresso Nacional", 5);
	  Participante bruno = new Individuo("Bruno Garcia", 1);
	  Participante sarney = new Individuo("José Sarney", 2);

	  congresso.adicionarParticipante(bruno);
	  congresso.adicionarParticipante(sarney);

	  Participante eduardo = new Individuo("Eduardo Suplicy", 3);
	  Participante mercadante = new Individuo("Aloisio Mercadante", 4);

	  Participante partidoTrabalhadores = new Instituicao("PT");
	  partidoTrabalhadores.adicionar(eduardo);
	  partidoTrabalhadores.adicionar(mercadante);

	  congresso.adicionarParticipante(partidoTrabalhadores);

	  System.out.println(congresso);
	  congresso.imprimeParticipantes();
	}
}

O Desenvolvimento Guiado Por Funcionalidades (FDD) é uma metodologia ágil para o processo de engenharia de software, elaborado com foco na entrega freqüente de “software funcionando” para os clientes e na utilização de boas práticas durante o ciclo de seu desenvolvimento.

Criado em 1997 num grande projeto de sistema de empréstimos em Java para o banco United Overseas Bank, em Singapura. União entre a experiência de análise e modelagem orientadas por objetos de Peter Coad, e o gerencimento de projetos de Jeff De Luca.

Depois de terminar a faculdade com brilhantismo, Chris McCandless, jovem americano saudável e de família rica, doa todo o dinheiro que tem, abandona o carro e a maioria de seus pertences, adota outro nome e some na estrada, sem nunca mais dar notícias aos pais. Dois anos depois, aparece morto num lugar ermo e gelado no Alasca.