Agregação ou composição?

Vamos aos exemplos clássicos.

Agregacão: Simplesmente é um relacionamento do tipo "Parte-Todo" e isso não vai mudar praticamente nada no seu código. Agregação simplesmente é uma informação do projeto [ Rumbaught]. Na dúvida, não use. É isso mesmo que estou falando. Se for gerar confusão no seu projeto não use, pois Agregação não tem semântica na UML.

Exemplo Clássico:

Explicação: Simplesmente uma Equipe é o Todo e as Pessoas são as Partes. Nada muda se você simplesmente tirar aquele diamante dali.

Composição: é o relacionamento mais forte da UML. A idéia da Composição é que o conjunto todo de classes é como se fosse uma única coisa. Uma instância das partes não pode ser compartilhada e quando a classe forte (da do diamante) morre todos os compostos morrem junto.

Exemplo Clássico:

Um item pedido não pode estar associado a dois pedidos simultaneamente. Quanto o pedido morre os itens também morrem.

http://martinfowler.com/bliki/AggregationAndComposition.html

Deixei um exemplo em outro tópico http://www.guj.com.br/posts/list/85835.java#1010350, e gostaria de trazer aqui pra botar lenha na fogueira :slight_smile:

Antes, uma das coisas que causam confusão é onde se toma a referência, seja a PARTE ou o TODO.

Tudo bem que a PARTE que não faz sentido sem o TODO seja uma composição, mas e o contrário?
Quando um TODO perde sentido sem a PARTE, que tipo associação temos?


O caso que postei se trata de ERRATAS de LIVROS.
A ERRATA pode ou não existir no LIVRO, se pensarmos no TODO (LIVRO) este não depende/não é necessariamente composto pela PARTE (ERRATA).
Mas uma vez que esta ERRATA (PARTE) exista, ela passa a compor o TODO (LIVRO).

Sob a perspectiva do TODO, a errata é agregada, onde necessáriamente não faz parte do LIVRO (que pode existir sem ERRATA).
Sob a perspectiva da PARTE, a ERRATA tem uma relação de composição com o LIVRO, já que ela sozinha não tem sentido.

Tomamos a consideração o TODO ou a PARTE na associação?
Como vocês modelariam este caso?

Valeu!
Abs

Então de acordo com mo que foi dito;
homem --> pernas
é uma agregação de fato um homem pode viver sem pernas?è isso mesmo?

[quote]Vamos aos exemplos clássicos.

Agregacão: Simplesmente é um relacionamento do tipo “Parte-Todo” e isso não vai mudar praticamente nada no seu código. Agregação simplesmente é uma informação do projeto [ Rumbaught]. Na dúvida, não use. É isso mesmo que estou falando. Se for gerar confusão no seu projeto não use, pois Agregação não tem semântica na UML.

Exemplo Clássico:

Explicação: Simplesmente uma Equipe é o Todo e as Pessoas são as Partes. Nada muda se você simplesmente tirar aquele diamante dali.

Composição: é o relacionamento mais forte da UML. A idéia da Composição é que o conjunto todo de classes é como se fosse uma única coisa. Uma instância das partes não pode ser compartilhada e quando a classe forte (da do diamante) morre todos os compostos morrem junto.

Exemplo Clássico:

Um item pedido não pode estar associado a dois pedidos simultaneamente. Quanto o pedido morre os itens também morrem.

http://martinfowler.com/bliki/AggregationAndComposition.html[/quote]

Excelente explicação, simples e direta

Entao fabioEM, o problema é que:

Do ponto de vista do TODO (Homem) está certo dizer que é uma agregação, já que ele pode existir sem a PARTE (perna).
Mas do ponto de vista da PARTE (perna) é uma composição, já que uma perna sozinha não tem sentido de ser e nem ser aplicada a outro homem.

Por isso volto a perguntar qual a referência ideal que devemos ter na modelagem, a PARTE ou o TODO?

? Agregação e Composição
? Fonte freqüente de confusão!
? Agregação: indica que a relação entre duas classes é do
tipo é-parte (ex.: o motor é parte do carro. As rodas são
parte do carro)
? Composição: indica que a relação entre dois objetos é do
tipo é-todo (ex.: um ponto pertence a um círculo. Não existe
o círculo sem aquele ponto)
? Se o círculo for excluído, o ponto é excluído junto!
?Recomenda-se sempre usar composição…

Ok Diego, e no caso que postei sobre LIVRO e ERRATA?

Um livro pode existir sem errata mas, se houver errata e o livro for excluído, as erratas vão junto.

Se o livro pode existir sem errata = agregação (essa é a perspectiva do TODO)
Se a errata é excluída junto com o livro = composição (essa é a perspectiva da PARTE)

Erratas de livros caem em qual caso?

Cara neste caso, vai depender da regra de negócio aplicado a sua necessidade.

O exemplo que dei é um exemplo genérico e ponderável.

De maneira geral (pensando de maneira macro), um livro pode sim, existir sem errata. Agora uma errata não pode existir sem um livro(Agregação), entende.

Agora dependendo da regra de negócio aplicado ao “seu negócio”, vai depender. Tem que ter o “feeling” para perceber isso. Mas vc está indo bem, apenas pense nesta forma e adque a sua solução.

A UML não visa complicar e sim deixar o mais simples possível, como linguagem universal de “expressão” em soluções para expressar uma solução de software, objeto e seu desenho mental.

Qualquer dúvida sugiro ler o livro mais famoso, escrito pelos “pais” da UML. Com o nome de:

Guia do Usuário - Grady Booch; Ivar Jacobson; James Rumbaugh.

[]'s.

Valeu Diego.
Se a referência é relativa, eu modelaria a relação errata - livro como dependência por conta dos registros de erratas serem apagadas junto com o livro, apesar disso não ser verdade sob a perspectiva do todo.
Acho que é um caso mais para a Filosofia do que pra TI rs
abs

[quote=pgnt]Ok Diego, e no caso que postei sobre LIVRO e ERRATA?

Um livro pode existir sem errata mas, se houver errata e o livro for excluído, as erratas vão junto.

Se o livro pode existir sem errata = agregação (essa é a perspectiva do TODO)
Se a errata é excluída junto com o livro = composição (essa é a perspectiva da PARTE)

Erratas de livros caem em qual caso?
[/quote]

Existem 3 principais tipos de relação em OO. E nenhum deles têm relação com integridade referencial. OO não é banco de dados.
Quando vc pergunta “se houver errata e o livro for excluído, as erratas vão junto” isso não faz sentido em OO.

A relações possiveis : Associação , Agregação e Composição.
Associação é o simples Tem-Um. Em UML é a linha sem losangulos.
Agregação é uma associação em que não ha referencia recursiva. Ou seja, Se A contém B, B não contém A, nem mesmo através de C.
Composição é uma agregação em que o ciclo de vida dos filhos é controlada pelo pai.

Uma errata não pode viver sem o livro, e o livro tem erratas. Erratas são de livros, ou seja, duas erratas relativas ao mesmo texto podem acontecer em livros diferentes. Portanto Um livro tem várias erratas associadas e um errata tem um livro associado. Porque a errata tem referencia ao livro, não é uma agregação nem uma composição.

quando o livro é removido, a sua associação à erratas desaparece. Porque o livro foi removido, a errata não se relaciona a ninguem, logo ela é inconsistente e é removida tb. A integridade referencial não depende apenas do tipo de associação.

Em linguagem moderna , Livro é um Agregado. Neste sentido, Errata está contida dentro de livro. Remover o livro remove todo o que está “dentro” dele, é como ao remover o livro, o nome dele é removido.

[b]Aproveitando este Fórum, eu sou novata no mundo Java :slight_smile: E gostaria da ajuda de vocês. Tenho um sistema que possui a classe professor, aluno e curso. Sendo que na hora de cadastrar o curso, eu preciso mostrar a lista de professores existes e dá uma opção ao adm de escolher o professor que vai lecionar esse curso, a mesma coisa terei que fazer para o aluno, depois preciso imprimir o curso com seu respectivo professor e alunos. :? :? :?
Me disseram pra trabalhar com composição, como fazer isso ??? :? :? :? :?: :?: :?:

Obrigada. :smiley: [/b]

Segue meu código

Classe Curso

[code]import java.util.List;

public class Curso {
protected int codCurso;
protected String nCurso;
protected Professor professor;
protected List alunos;

// Get e Set codCurso========================
public int getCodCurso() {
return codCurso;
}
public void setCodCurso(int codCurso) {
this.codCurso = codCurso;
}
// Get e Set codCurso========================
public String getNCurso() {
return nCurso;
}
public void setNCurso(String nomeCurso) {
nCurso = nomeCurso;
}
// Get e Set Professor
public Curso getProfessor() {
return this.getProfessor();
}
public void setProfessor(Professor professor) {
this.professor = professor;
}
// Get e set List Aluno
public List getAlunos() {
return alunos;
}
public void setAlunos(List alunos) {
this.alunos = alunos;
}
}[/code]

Classe Aluno

[code]import java.util.*;

public class Aluno {
Scanner scanner = new Scanner(System.in);
protected int matAluno;
protected String nAluno;
protected String login;
protected String senha;

// Get e Set mtAluno ====================================
public int getMatAluno() {
	return matAluno;
}
public void setMatAluno(int mtAluno) {
	this.matAluno = mtAluno;
}

// Get e Set nAluno =====================================
public String getNAluno() {
return nAluno;
}
public void setNAluno(String aluno) {
nAluno = aluno;
}
// Get e Set login ======================================
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
// Get e Set senha ======================================
public String getSenha() {
return senha;
}
public void setSenha(String senha) {
this.senha = senha;
}
// Cadastro do Aluno ===================================
public void cadastraAluno(){

	System.out.println("Matricula: ");
	this.setMatAluno(scanner.nextInt());
	
	System.out.println("Nome: ");
	this.setNAluno(scanner.next());
		
	System.out.println("Login: ");
	this.setLogin(scanner.next());

	System.out.println("Senha: ");
	this.setSenha(scanner.next());

}

//Mostra os cadastros dos alunos ===========================
public void exibeAluno(){
System.out.println("Matricula: " + getMatAluno());
System.out.println("Nome: " + getNAluno());
System.out.println("Login: " + getLogin());
System.out.println("Senha: " + getSenha());
}
}[/code]

Classe Professor

[code]import java.util.Scanner;

public class Professor {
Scanner scanner = new Scanner(System.in);
protected int matProf;
protected String nProf;
protected String login;
protected String senha;

// Get e Set mtProf ====================================
public int getMatProf() {
	return matProf;
}
public void setMatProf(int mtProf) {
	this.matProf = mtProf;
}

// Get e Set nProf ====================================
public String getNProf() {
return nProf;
}
public void setNProf(String prof) {
this.nProf = prof;
}
// Get e Set login ====================================
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
// Get e Set senha ====================================
public String getSenha() {
return senha;
}
public void setSenha(String senha) {
this.senha = senha;
}
}[/code]

Classe Administrador

[code]public class Administrador {
protected String login;
protected String senha;

// Get e SetLogin ===========================
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
// Get e SetSenha ============================
public String getSenha() {
return senha;
}
public void setSenha(String senha) {
this.senha = senha;
}
}[/code]

[code]import java.util.*;

public class Principal {

Administrador administrador = new Administrador();
List<Aluno> alunos = new ArrayList<Aluno>();
List<Professor> professores = new ArrayList<Professor>();
List<Curso> cursos = new ArrayList<Curso>();
int i = 0;

public void logar(int opcao) {
	Scanner scanner = new Scanner(System.in);
	String login;
	String senha;
	System.out.println("Digite seu login e senha!*\n");
	System.out.println("Login: ");
	login = scanner.next();
	System.out.println("Senha: ");
	senha = scanner.next();
	switch (opcao) {
	// == Caso 01 - Se o usuário se identificar como Administrador ==
	// ********************
	case 1:
		int opAdm = 0;
		if (administrador.getLogin().equals(login)
				&& administrador.getSenha().equals(senha)) {
			System.out.println("Autenticação com Sucesso!");
			// logar como administrador

			do {
				System.out.println("Sistema Acadêmico\n");
				System.out.println("* Usuário Administrador *\n");
				System.out.println("1- Cadastrar Curso");
				System.out.println("2- Cadastrar Professor(a)");
				System.out.println("3- Cadastrar Aluno");
				System.out.println("4- Relatório Professores");
				System.out.println("5- Relatório Alunos");
				System.out.println("6- Relatório Curso");
				System.out.println("7- Sair");
				opAdm = scanner.nextInt();

				switch (opAdm) {
				case 1:
					// ============= Cadastro do Curso ================
					Curso curso = new Curso();
					System.out.println("*** Cadastro Curso ***\n\n");
					System.out.println("Digite o Código: ");
					curso.setCodCurso(scanner.nextInt());
					System.out.println("Digite o nome: ");
					curso.setNCurso(scanner.next());
			// ******AQUI TÁ O PROBLEMA
					System.out.println("Escolha o Professor do Curso: ");
					for(Professor prof: professores){
						System.out.println(i +"" +cursos.get(i).getProfessor());
					}
					int opCurso = scanner.nextInt();
					  for(Professor prof: professores){
						if (i == opCurso){
							Curso guardaOp = cursos.get(i).getProfessor();
						}
					  }
					
					cursos.add(curso);
					break;
				case 2:
					// =========== Cadastro do Professor ==============
					Professor prof = new Professor();
					System.out.println("*** Cadastro Professor ***\n\n");
					System.out.println("Digite a Matricula: ");
					prof.setMatProf(scanner.nextInt());
					System.out.println("Digite o nome: ");
					prof.setNProf(scanner.next());
					System.out.println("Digite o Login: ");
					prof.setLogin(scanner.next());
					System.out.println("Digite a Senha: ");
					prof.setSenha(scanner.next());
					professores.add(prof);
					break;
				case 3:
					// ============== Cadastro do Aluno ==================
					Aluno aluno = new Aluno();
					System.out.println("*** Cadastro Aluno ***\n\n");
					System.out.println("Digite a Matricula: ");
					aluno.setMatAluno(scanner.nextInt());
					System.out.println("Digite o nome: ");
					aluno.setNAluno(scanner.next());
					System.out.println("Digite o Login: ");
					aluno.setLogin(scanner.next());
					System.out.println("Digite a Senha: ");
					aluno.setSenha(scanner.next());
					alunos.add(aluno);
					break;
				case 4:
					// ====== Relatórios Professores ==========
					System.out.println("Sistema Acadêmico\n");
					System.out.println("* Lista Professores *\n");
					for (i = 0; i < professores.size(); i++) {
						System.out.println("Matricula: "
								+ professores.get(i).getMatProf());
						System.out.println("Professor(a): "
								+ professores.get(i).getNProf());
						System.out.println("Login: "
								+ professores.get(i).getLogin());
						System.out.println("Senha: "
								+ professores.get(i).getSenha() + "\n");
					}
					break;
				case 5:
					// ============= Relatórios Alunos ================
					System.out.println("Sistema Acadêmico\n");
					System.out.println("* Listas Alunos *\n");
					for (i = 0; i < alunos.size(); i++) {
						System.out.println("Matricula: "
								+ alunos.get(i).getMatAluno());
						System.out.println("Aluno: "
								+ alunos.get(i).getNAluno());
						System.out.println("Login: "
								+ alunos.get(i).getLogin());
						System.out.println("Senha: "
								+ alunos.get(i).getSenha() + "\n");
					}
					break;
				case 6:
					// ============ Relatórios Cursos ================
					System.out.println("Sistema Acadêmico\n * Listas Cursos *\n");
					System.out.println("Digite o Código do Curso de sua preferência: ");
					for (Curso c: cursos) {
						System.out.println(cursos.get(i).getCodCurso());
						System.out.println(cursos.get(i).getNCurso());
					    //System.out.println(cursos.get(i).getAlunos());
					 }
		// ******AQUI TÁ O PROBLEMA
					int opCodCurso = scanner.nextInt();
					for(Curso c: cursos){
					  if(opCodCurso == i){
						  System.out.println(cursos.get(i).getCodCurso());s
						  
					  }
					}
					
					
					//}
				   //}
					break;
				default:
					System.out.println("Opção Inválida!");
					break;
				}
			} while (opAdm != 7);
		} else {
			System.out.println("Erro de Autenticação!");
		}
		break;
	// ========= Caso 02 - Se o usuário se identificar como Professor ================
	// ********************
	case 2:
		for (Professor prof : professores) {
			if (prof.getLogin().equals(login)
					&& (prof.getSenha().equals(senha))) {
				// if (((Professor) professores).getLogin().equals(login) &&
				// ((Professor) professores).getSenha().equals(senha)) {
				System.out.println("Autenticação com Sucesso!");
				System.out.println("Sistema Acadêmico\n");
				System.out.println("* Usuário Professor *\n");
				System.out.println("1- Exibe\n 2-Sair");
				int opProf = scanner.nextInt();
				do {
					switch (opProf) {
					case 1:
						// ====== Apenas exibe uma mensagem =========
						System.out.println("Não tem !!! xD\n");
						break;
					default:
						System.out.println("Opção Inválida!");
						break;
					}
					System.out.println("Sistema Acadêmico\n");
					System.out.println("* Usuário Professor *\n");
					System.out.println("1- Exibe\n 2-Sair");
					opProf = scanner.nextInt();
				} while (opProf != 2);

			} else {
				System.out.println("Erro de Autenticação!");
			}

		}
		break;
	// ====== Caso 03 - Se o usuário se identificar como Aluno ========
	// ********************
	case 3:
		for (Aluno aluno : alunos) {
			if (aluno.getLogin().equals(login)
					&& (aluno.getSenha().equals(senha))) {
				System.out.println("Autenticação com Sucesso!");
				System.out.println("Sistema Acadêmico\n");
				System.out.println("* Usuário Aluno *\n");
				System.out.println("1- Exibe\n 2-Sair");
				int opAluno = scanner.nextInt();
				do {
					switch (opAluno) {
					case 1:
						// ====== Apenas exibe uma mensagem ======
						System.out.println("Não tem !!! xD\n");
						break;
					default:
						System.out.println("Opção Inválida!");
						break;
					}
					System.out.println("Sistema Acadêmico\n");
					System.out.println("* Usuário Aluno *\n");
					System.out.println("1- Exibe\n 2-Sair");
					opAluno = scanner.nextInt();
				} while (opAluno != 2);
			} else {
				System.out.println("Erro de Autenticação!");
			}
		}
		break;
	// =================== Opção Inválida =================
	// ********************
	    default:
		  System.out.println("Opção Inválida!");
		break;
	}
}

// ========== PROGRAMA PRINCIPAL (INICIO) ============
public static void main(String[] args) {
	Principal principal = new Principal();
	principal.administrador.setLogin("administrador");
	principal.administrador.setSenha("senha");
	Scanner scanner = new Scanner(System.in);
	int opcao = 0;

	System.out.println("Sistema Acadêmico\n\nSelecione a opção:");
	System.out
			.println("1-Administrador \n2-Professor(a) \n3-Aluno \n4-Sair");
	opcao = scanner.nextInt();
	while (opcao != 4) {
		principal.logar(opcao);
		System.out.println("Sistema Acadêmico\n\nSelecione a opção:");
		System.out
				.println("1-Administrador \n2-Professor(a) \n3-Aluno \n4-Sair");
		opcao = scanner.nextInt();
	}
}

}
// =========== PROGRAMA PRINCIPAL (FIM) =============[/code]

[quote=denisemviana]
Me disseram pra trabalhar com composição, como fazer isso ??? :? :? :? :?: :?: :?:
[/quote]

Para trabalhar com [google]composição[/google] precisa entender o conceito.

Uma busca no Google trouxe esse link.

Tem a wikipedia também: http://en.wikipedia.org/wiki/Object_composition

Olá Denise,
Eu sou um pouco fraco com conceitos de OO, porque ainda estou estudando eles, mas composição pelo que eu sei é mais ou menos o seguinte. Você tem a Arvores e Passaros e os dos, e se somente os dois existirem você tera uma floresta por exemplo.
Melhorando o que eu falei acima. Se você uma classe aluno e uma classe professor você pode montar a classe turma se e se somente se as duas classes existirem, tipo:

Aluno aluno1 = new Aluno(“nome”, “serie”, nota1, nota2, turmaA);
Professor professor1 = new Professor (“nome”, “materiaLeciona”, turmaA)

Turma turmaA = new Turma(aluno1, professor1);

Esses objetos iriam compor a classe Turma… Entendeu? Se você não tiver um professor, como vai ter uma turma? Compreende?
Essa é a idéia de composição que eu sei e entendi =)

Espero ter ajudado ou pelo menos estimulado alguém me corrigir =) Qualquer coisa é só postar ai =) vlw t+

Obrigada Augusto Cesar

Mas o que realmente estou precisando é ajuda no código !!! Quem pode me ajudar ??? :wink: :wink: :wink: :wink:

Você pode fazer um for dentro do case(*) que você quer listar esse professor, Vamos supor que você queira listar os professores na hora de gerar a turma e quer escolher o professo para essa turma, você pode fazer um FOR ou um WHILE que vai varrer a lista de professores mostrando eles na tela tipo

while(professor != “”){
System.out.println(obj_professor);
}

e segue a mesma idéia que você uso nos cases para listar ele no final das contas

Sei que é pedir demais, mas Augusto Cesar vc poderia ver meu código e me dizer onde preciso modificar ???
Sério, sou novataaaaaa, e preciso de ajuda.
:?: :?: :? :? :? :?: :?: :?: :?: :? :? :? :? :?: :?: :?: :?: :? :? :? :? : :?: :?: :?: :?: :?:

Eu tb sou novato no java e to tentando aprender mais sobre ele, mas vamos lá.

Dentro do local onde você printa os valores que serão cadastrados você vai colocar esse negocio do professor que eu tinha te falado, eu to enrolado com um codigo de jasper aqui to resolvendo uns pepinos aqui e to sem tempo de testar o codigo, mas tenta colocar no local onde você cadastra o curso o objeto que monta a lista de professores e varre ele usando um while e retornando os valores que estão dentro do objeto. se não conseguir vai postando as tentativas de mudança somente com a parte que você alterou que a comunidade vai ajudando =) vlw