Gente gostaria de saber se é correto fazer o que eu fiz no código abaixo, ou se é melhor a aplicação de herança, obrigado!
[code]public class Pessoa {
private float altura;
private float peso;
public void setAltura(float vlrAltura){
this.altura = vlrAltura;
}
public float getAltura(){
return altura;
}
public void setPeso(float vlrPeso){
this.peso = vlrPeso;
}
public float getPeso(){
return peso;
}
}[/code]
[code]
public class Joao{
Pessoa joao = new Pessoa();
public void atributos(){
float altura = 1.73f;
float peso = 67.5f;
joao.setAltura(altura);
joao.setPeso(peso);
}
public void exibirMensagem(){
System.out.println("A altura do joão é "+joao.getAltura()+" e o seu peso é "+joao.getPeso()+".");
}
}[/code]
[code]
public class Maria{
Pessoa maria = new Pessoa();
public void atributos(){
float altura = 1.68f;
float peso = 56.2f;
maria.setAltura(altura);
maria.setPeso(peso);
}
public void exibirMensagem(){
System.out.println("A altura da maria é "+maria.getAltura()+" e o seu peso é "+maria.getPeso()+".");
}
}[/code]
[code]
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println(“Pessoas cadastradas:\n João: [1] \n Maria: [2]”);
int pessoa = input.nextInt();
switch(pessoa){
case 1:
Joao pessoa1 = new Joao();
pessoa1.atributos();
pessoa1.exibirMensagem();
break;
case 2:
Maria pessoa2 = new Maria();
pessoa2.atributos();
pessoa2.exibirMensagem();
break;
}
}
eu faria diferente, eu usaria apenas duas classes, uma pessoa e outra a principal. dentro dessa classe principal eu usaria para criar os objetos João e Maria, os objetos joao e maria possuem os mesmos metodos e atributos, logo não seria necessario criar uma classe para cada um deles. abraços
public class Pessoa {
private float altura;
private float peso;
public void setAltura(float vlrAltura){
this.altura = vlrAltura;
}
public float getAltura(){
return altura;
}
public void setPeso(float vlrPeso){
this.peso = vlrPeso;
}
public float getPeso(){
return peso;
}
}
[code]
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println(“Pessoas cadastradas:\n João: [1] \n Maria: [2]”);
int pessoa = input.nextInt();
switch(pessoa){
case 1:
Pessoa joao = new Pessoa();
float joao_Altura = 1.73f;
float joao_Peso = 67.5f;
joao.setAltura(joao_Altura);
joao.setPeso(joao_Peso);
System.out.println("A altura do João é "+joao.getAltura()+" e o seu peso é "+joao.getPeso()+".");
break;
case 2:
Pessoa maria = new Pessoa();
float maria_Altura = 1.68f;
float maria_Peso = 56.2f;
maria.setAltura(maria_Altura);
maria.setPeso(maria_Peso);
System.out.println("A altura do Maria é "+maria.getAltura()+" e o seu peso é "+maria.getPeso()+".");
break;
} // fim do switch
}
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("Pessoas cadastradas:\n João: [1] \n Maria: [2]");
int pessoa = input.nextInt();
Pessoa maria = new Pessoa();
maria.setAltura(1.68f);
maria.setPeso(56.2f);
Pessoa joao = new Pessoa();
joao.setAltura(1.73f);
joao.setPeso(67.5f);
switch(pessoa){
case 1:
System.out.println("A altura do João é "+joao.getAltura()+" e o seu peso é "+joao.getPeso()+".");
break;
case 2:
System.out.println("A altura do Maria é "+maria.getAltura()+" e o seu peso é "+maria.getPeso()+".");
break;
} // fim do switch
}
}
Não deixa de ser correto, entretanto, não é aconselhável fazer isto, sabe porque :?: :?: :?:
Quando fazemos a pergunta Maria e João são Pessoas, mas será que todas as Pessoas são Maria e João :?: :?: :?:
Como assim, o que voce quer dizer :?: :?: :?:
Quero dizer que nem todas as Pessoas podem ter os mesmo atributos, se quer ver um exemplo:
Supomos que Maria seja Advogada e João seja Enhenheiro. Para Maria voce tem que ter o atributo “registro na OAB” e João o registro no “CREA”.
Voce vai sair definindo os diversos atributos de tipos de documentos (CREA numero, OAB numero) na classe Pessoa :?: :?: :?:
Ah, mas eu posso definir um único atributo “Nome da Profissão” e outro “Orgão do Documento”, tudo bem, isto voce pode, porém o exemplo que dei acima, é só um dos exemplos que podem ocorrer dentro do paradigma de Orientação a Objetos. Em uma situação mais complexa, haverá casos em que para uma determinada Pessoa voce tenha que definir um atributo que não pode ser definido para todas as Pessoas, somente e esclusivamente para esta Pessoa, eu no seu caso, a Classe Pessoa engessou todos os atributos para cada Pessoa.
Recomendo fazer a herança, podendo até definir a classe Pessoa como Classe Abstrata, ou Interface, ou uma simples herança mesmo.
Não deixa de ser correto, entretanto, não é aconselhável fazer isto, sabe porque :?: :?: :?:
Quando fazemos a pergunta Maria e João são Pessoas, mas será que todas as Pessoas são Maria e João :?: :?: :?:
Como assim, o que eu quero dizer :?: :?: :?:
Quero dizer que nem todas as Pessoas podem ter os mesmo atributos, quer ver um exemplo:
Supomos que Maria seja Advogada e João seja Enhenheiro. Para Maria voce tem que ter o atributo “registro na OAB” e João o registro no “CREA”.
Voce vai sair definindo os diversos atributos de tipos de documentos (CREA numero, OAB numero) na classe Pessoa :?: :?: :?:
Ah, mas eu posso definir um único atributo “Nome da Profissão” e outro “Orgão do Documento”, tudo bem, isto voce pode, porém o exemplo que dei acima, é só um dos exemplos que podem ocorrer dentro do paradigma de Orientação a Objetos. Em uma situação mais complexa, haverá casos em que para uma determinada Pessoa voce tenha que definir um atributo que não pode ser definido para todas as Pessoas, somente e esclusivamente para esta Pessoa, eu no seu caso, a Classe Pessoa engessou todos os atributos para cada Pessoa.
Recomendo fazer a herança, podendo até definir a classe Pessoa como Classe Abstrata, ou Interface, ou uma simples herança mesmo.
public class Profissao{
String orgao;//CREAS,OAB,etc
String numRegistro
}
public class Pessoa{
Profissao profissao;
}
O que vc acha?[/quote]
Boa noite.
Sim, foi como disse antes, porém eu esqueci do primordial que é o comportamento que são definidos pelos métodos, vamos ao exemplo.
Supomos os seguintes comportamentos: “Dirigir”, “Fazer compras”, “Ler livros”, “Assistir TV”, “Jogar Futebol”, “Limpar a casa”, “Pilotar avião”, “Pilotar trem” e etc.
Repare que nem todas as Pessoas vão ter todos estes comportamentos.
Vamos a um exemplo prático:
// Definindo alguns atributos comuns a todas as Pessoas na classe Pessoa.
public class Pessoa {
private float altura;
private float peso;
private String cor_cabelo;
private String cor_olhos;
private float tamanho_calca;
private float tamanho_camisa;
public void setAltura(float vlrAltura){
this.altura = vlrAltura;
}
public float getAltura(){
return altura;
}
public void setPeso(float vlrPeso){
this.peso = vlrPeso;
}
public float getPeso(){
return peso;
}
public String getCor_cabelo(){
return cor_cabelo;
}
public void setCor_cabelo(String cor_cabelo){
this.cor_cabelo = cor_cabelo;
}
public String getCor_olhos(){
return cor_olhos;
}
public void setCor_olhos(String cor_olhos){
this.cor_olhos = cor_olhos;
}
public float getTamanho_calca(){
return tamanho_calca;
}
public void setTamanho_calca(float tamanho_calca){
this.tamanho_calca = tamanho_calca;
}
public float getTamanho_camisa(){
return tamanho_camisa;
}
public void setTamanho_camisa(float tamanho_camisa){
this.tamanho_camisa;
}
}
// Definindo agora as classes Mulher e Homem herdando de Pessoa
Public classe Homem extends Pessoa {
private float tamanho cueca;
public float getTamanho_cueca(){
return tamanho_cueca;
}
public void setTamanho_cueca(float tamanho_cueca){
this.tamanho_cueca = tamanho_cueca;
}
}
Public classe Mulher extends Pessoa {
private float tamanho_calcinha;
private float tamanho_soutien;
public float getTamanho_calcinha(){
return tamanho_calcinha;
}
public void setTamanho_calcinha(float tamanho_calcinha){
this.tamanho_calcinha = tamanho_calcinha;
}
public float getTamanho_soutien(){
return tamanho_soutien;
}
public void setTamanho_soutien(float tamanho_soutien){
this.tamanho_soutien = tamanho_soutien;
}
}
Agora vamos definir os comportamentos de João e Maria
public class Joao extends Homem {
public void setDirigir(String horas) {
System.out.println("Vou dirigir às " + horas);
}
public void setJogarFutebol(String horas) {
System.out.println("Vou jogar futebol às" + horas);
}
}
public class Maria extends Mulher {
public void setFazerCompras(String horas) {
System.out.println("Vou fazer compras às " + horas);
}
public void setIrShopping(String horas) {
System.out.println("Vou ao shopping às " + horas);
}
public void setArrumarCasa(String horas) {
System.out.println("Vou arrumar a casa às " + horas);
}
}
É claro que o exemplo acima foi bem simples, mas repare que há mudança de atributos de Homem pra Mulher e mudanças de comportamento de Pessoa para Pessoa. Isto em uma situação mais complexa ocorre com frequencia em Orientação a Objetos e este conceito é conhecido como “Polimorfismo”.
Fazer do jeito que voce estava fazendo antes, estava quebrando a regra deste conceito.
Eu usei o comportamento de Pessoas apenas para ilustrar como ocorre com os objetos virtuais na Orientação a Objetos.
É claro, como disse antes, o procedimento que o nosso colega adotou anteriormente, não está errado, em se tratando no caso de Pessoas, até porque nós não costumamos criar classes para cadastrar Pessoas, Funcionários e etc. pois eles são feitos atraves do banco de dados, as classes são apenas criadas, no caso de pessoas, como entidade de dados que vão trafegar esses dados referentes a identificação da Pessoa, e dentro desses dados não se inclui o comportamento delas.
O comportamento a que me referia, era o comportamento do Objeto e se voce pensar em criar uma classe Pessoa, então voce está olhando nesta Pessoa como um Objeto Virtual no seu computador e isso envolve a Orientação a Objetos. E era exatamente o que estava querendo explicar são os conceitos da Orientação a Objetos: Classes, herança, Polimorfismo e etc. pois da maneira que estava sendo feito, quebra as regras do Polimorfismo, onde um objeto possui estado que são seus atributos e possui comportamento que são seus métodos, e estes jamais poderão ficar engessados em apenas uma classe.