Dúvida Construtores que recebem objetos como atributos

Programação Java
#1

Boa noite pessoal, não sei se o título condiz com o conteúdo, mas vamos lá. Estou desenvolvendo um pequeno programa nada convencional. Trata-se de um programa para administração de um cemitério. kkkk é eu sei mó doido né? Bom, o problema é que durante o desenvolvimento me surgiu uma dúvida e gostaria de tirá-la com vocês. O programa em questão tem tres classes: SepulturaComunitaria (que é a superClasse), SepulturaPerpetua (que é a subClasse e herda alguns atributos da superClasse) e a classe Pessoa (que recebe dentre outros atributos um objeto que pode ser SepulturaComunitaria ou SepulturaPerpetua). A minha dúvida é exatamente ai, qual melhor maneira para montar este construtor de forma que ele consiga distinguir qual tipo de Objeto se trata? Me falaram que dá para aplicar conceitos de polimorfismo, mas sinceramente não estou conseguindo enchergar isso, outros me disseram instance of e por ai vai. Eu usei construtores sobrecarregados como vcs podem ver pelo meu código abaixo. E então o que acham? Abaixo estão partes das classes que estou com dúvida para que vcs analisem blz?

public class Pessoa{

	private String nome;
	private char sexo;
	private String filiacao;
	private Date dataNascimento;
	private Calendar dataFalecimento;
	private SepulturaPerpetua sepulturaPerpetua;
	private SepulturaComunitaria sepulturaComunitaria;
		
	public Pessoa(String nome, char sexo, String filiacao, Date dataNascimento,
			Calendar dataFalecimento, SepulturaComunitaria sepultura){
		this.nome = nome;
		this.sexo = sexo;
		this.filiacao = filiacao;
		this.dataNascimento = dataNascimento;
		this.dataFalecimento = dataFalecimento;
		this.sepulturaComunitaria = sepultura;
	}
	
	public Pessoa(String nome, char sexo, String filiacao, Date dataNascimento,
			Calendar dataFalecimento, SepulturaPerpetua sepultura){
		this.nome = nome;
		this.sexo = sexo;
		this.filiacao = filiacao;
		this.dataNascimento = dataNascimento;
		this.dataFalecimento = dataFalecimento;
		this.sepulturaPerpetua = sepultura;
	}
public class SepulturaComunitaria{
	
	private int numero;
	private char ala;
	
	public SepulturaComunitaria(int numero, char ala){
		
		this.numero = numero;
		this.ala = ala;
	}
		
}

[code]
public class SepulturaPerpetua extends SepulturaComunitaria{

private String cpf;
private String cliente;
private boolean aVista = false;
private boolean aPrazo = false;
private Vector<Parcelas> parcelas;

public SepulturaPerpetua(int numero, char ala, String cliente, String cpf){
	super(numero, ala);
	this.cpf = cpf;
	this.cliente = cliente;
}

}[/code]

Desde já obrigado a todos!

#2

Você pode usar um contrutor só na classe pessoa, dentro desse contrutor vc faz um if para verificar qual o tipo da Sepultura.

#3

Você já pensou em criar uma interface Sepultura e as classes Comunitária, Perpétua e Pessoa, onde a classe Pessoa tem um construtor que recebe a interface Sepultura… é um bom uso do polimorfismo na minha opinião, além de evitar a herança…

#4

Tá mas vc diz assim:

    public Pessoa(String nome, char sexo, String filiacao, Date dataNascimento,
       Calendar dataFalecimento, SepulturaComunitaria sepultura){
           this.nome = nome;   
           this.sexo = sexo;   
           this.filiacao = filiacao;   
           this.dataNascimento = dataNascimento;   
           this.dataFalecimento = dataFalecimento;   
           this.sepulturaComunitaria = sepultura;   
           if(sepultura instaceof SepulturaComunitaria){
              this.sepulturaComunitaria = sepultira;
           }
           else{
              this.sepulturaPerpetua = sepultura;
            }         
     }
#5

Opa ivan é bem isso que me disseram, mas a minha dúvida é se eu utilizando essa interface, na hora de passar para o construtor da classe Pessoa, ela consegue destinguir qual dos tipos Sepultura esta sendo passado?

#6

[quote=Danielrricci]Tá mas vc diz assim:

public Pessoa(String nome, char sexo, String filiacao, Date dataNascimento, Calendar dataFalecimento, SepulturaComunitaria sepultura){ this.nome = nome; this.sexo = sexo; this.filiacao = filiacao; this.dataNascimento = dataNascimento; this.dataFalecimento = dataFalecimento; this.sepulturaComunitaria = sepultura; if(sepultura instaceof SepulturaComunitaria){ this.sepulturaComunitaria = sepultira; } else{ this.sepulturaPerpetua = sepultura; } } [/quote]

Sim

#7

[quote=Danielrricci]Tá mas vc diz assim:

public Pessoa(String nome, char sexo, String filiacao, Date dataNascimento, Calendar dataFalecimento, SepulturaComunitaria sepultura){ this.nome = nome; this.sexo = sexo; this.filiacao = filiacao; this.dataNascimento = dataNascimento; this.dataFalecimento = dataFalecimento; this.sepulturaComunitaria = sepultura; if(sepultura instaceof SepulturaComunitaria){ this.sepulturaComunitaria = sepultira; } else{ this.sepulturaPerpetua = sepultura; } } [/quote]

Sim!

#8

Eu já fiz isso, mas acusa erro no construtor, pois ele recebe um tipo SepulturaComunitaria sepultura e na hr de atribuir this.sepulturaPerpetua = sepultura (dentro do if) ele diz que o tipo não é o mesmo. Onde estou errando? Deve ser coisa boba, mas não entendo onde está o erro! Inclusive, já me falaram sobre fazer polimorfismo, mas acho que nao me lembro de alguns conceitos de polimorfirmos por isso estou apanhando para entender como fazer!

#9

É por q SepultutraComunitaria é superclasse de SepulturaPerpetua.

Faz uma classe Sepultura e faz SepulturaComunitária e SepulturaPerpetua herdar de Sepultura (por exemplo)

#10

Como eu disse anteriormente, eu acho melhor ao invés de criar uma super classe, implemente a classe Sepultura com os métodos em comum as classes que a implementaram…

Abraçs!!

#11

Fiz as alterações que vc disse. Criei uma classe Sepultura com dois atributos (tumulo e ala), fiz a classe SepulturaComunitária e Perpetua herdar de Sepultura. E na classe Pessoa eu fiz assim:

public class Pessoa{

	private String nome;
	private char sexo;
	private String filiacao;
	private Date dataNascimento;
	private Calendar dataFalecimento;
	private Sepultura sepulturaPerpetua;
	private Sepultura sepulturaComunitaria;
	
	public Pessoa(String nome, char sexo, String filiacao, Date dataNascimento,
			Calendar dataFalecimento, Sepultura sepultura){
		this.nome = nome;
		this.sexo = sexo;
		this.filiacao = filiacao;
		this.dataNascimento = dataNascimento;
		this.dataFalecimento = dataFalecimento;
		if(sepultura instanceof SepulturaComunitaria){
			this.sepulturaComunitaria = sepultura;
		}
		else{
			this.sepulturaPerpetua = sepultura;
		}
	}
#12

E o que aconteceu?

#13

Sim Ivan, vou testar esta sua ideia! Tipo crio uma interface Sepultura e insiro todas as chamadas dos métodos das classes SepulturaPerpetua e Comunitaria, dai faço a classe Pessoa implementar interface Sepultura né? Mas e o construtor como ficaria? Tipo na hora de passar o objeto SepulturaComunitaria ou Perpetua? Cara me desculpe se a resposta é obvia e eu nao estou entendendo blz?

#14

Pedro do jeito que vc disse compilou normal. Vou fazer alguns testes aqui para ver direito, dai qualquer coisa eu posto o resultado. Inclusive vou testar o polimorfismo do ivan tb para ver qual dos códigos é mais interessante usar para essa aplicação. Obrigado einh, suas dicas me ajudou bem! E vc tb ivan, valeu pela dica. Acho muito interessante antes de começar um projeto, trocar ideia com amigos da área de TI, pois assim conseguimos agregar mais valor aos códigos. Sempre tiro dúvidas no guj, inclusive peço sugestões, são sempre muito bem vindas! Assim que eu tiver uma conclusão aqui eu posto o resulta e fecho o tópico. Se alguem mais tiver sugestões, compartilhem!

#15

Danielrricci, quem implementaria a interface Sepultura seria Comunitária e Perpétua e no construtor da Pessoa você pode colocar assim


public class Pessoa{

private Sepultura sepultura = null;

public Pessoa(Sepultura sepultura){
 this.sepultura = sepultura;
}

}

e desse jeito você ainda pode ter construtores que aceitam um tipo Sepultura dentro dos construtores Perpétua e Comunitária, por exemplo

public class Comunitaria implements Sepultura{

//set de valores
public Comunitaria(Sepultura sepultura){

}

}
public class Perpetua implements Sepultura{

//set de valores
public Comunitaria(Sepultura sepultura){

}

}

Eu sugeri o uso de interfaces para diminuir o acoplamento entre as classes… testa aeh e depois você posta os resultados…

Abraços e boa sorte no seu projeto do mal :lol:

#16

Opa ivan olha eu aqui de volta! Gostei do “PROJETO DO MAL” kkkk! Cara, tua idéia parece muito boa, tentei implementá-la, mas não consegui. Me corrija se eu estiver errado, mas classes do tipo interface só contém as assinaturas dos métodos que a implementam não é? Então como ficaria esta classe interface Sepultura? Eu teria que criar um método para fazer essa diferenciação ou se eu apenas fazer com que as classes Perpetua e Comunitaria a implemente, a classe Pessoa automaticamente consegue entender que tipo esta sendo passada para ela? É que eu quero que o construtor da classe Pessoa consiga entender que eu estou encaminhando para ele um objeto que hora pode ser, SepulturaPerpetua, hora pode ser SepulturaComunitária. Desculpe se estou vacilando em alguns conceitos aqui kkk

#17

Boa tarde amigos! Bom, ainda não terminei o projeto intitulado por vocês como “Projeto do mal” kkkk, mas como prometido postarei qual das estratégias acabei implementando em meu programa. Depois de muita pesquisa e testes, inclusive opiniões de amigos, acabei chegando a usar as duas estratégias, ou seja, polimorfismo e instaceof. Implementei a idéia do Ivan, usando polimorfismo porém sem o uso de interface, apenas uma superclasse Sepultura e outra classe SepulturaPerpetua herdando dela, de modo que no construtor da classe Pessoa eu recebo apenas Sepultura. Em um segundo momento, eu uso o instaceof, mas apenas na hora q eu preciso definir qual objeto irei trabalhar, dai eu faço o que o Pedro disse.

Obrigado aos amigos ai que contribuiram!

#18