Java Classes Super e uso dos Construtores e Settters

[Bruno Coviello 6]

Olá a todos!

Bom, gostaria de pedir ajuda em um dúvida que estou tento em relação a conceitos em relação com super classes.

Em geral o que eu entendi foi que: Super classe contém os atributos comuns as demais.

Até aí tudo bem, mas a minha dúvida é que o professor frisou sempre que isso reaproveitaria muitos códigos e não é isso que vejo acontecendo (minha humilde opiniãode *****). Já que, por exemplo este exercício:

  

 

Temos que será reaproveitado marca, modelo, volume, preço e a porta entrará como um objeto em cada um deles.

Então eu fiz o seguinte:

 

♦Pergunta, qual é o sentido de eu ter que colocar nas classes com EXTENDS todos os construtores que estava na SUPER? Não é pra escrever menos ou só reaproveitamento de código mesmo? 

♦Pergunta, na classe super tem: marca, modelo, volume, preço. Eu faço os Getters e Setters, Construtores, uso public void cadastrar(){}, etc. Na SUB Classe deve ter tudo que se passou na SUPER, e como fica essa sintaxe? 

public class Commom {
    String marca,modelo;
    int volume;
    double preco;
/*
    Setters & Getters;
    */
    public String getMarca() {
        return marca;
    }

    public void setMarca(String marca) {
        this.marca = marca;
    }

    public String getModelo() {
        return modelo;
    }

    public void setModelo(String modelo) {
        this.modelo = modelo;
    }

    public int getVolume() {
        return volume;
    }

    public void setVolume(int volume) {
        this.volume = volume;
    }

    public double getPreco() {
        return preco;
    }

    public void setPreco(double preco) {
        this.preco = preco;
    }
    /*
    Construtores;
    */
    public Commom(){
        
    }
    public Commom(String m){
        marca=m;
    }
    public Commom(int v){
        volume =v;
    }
    public Commom(double p){
        preco=p;
    }
    public Commom(String m,int v){
        marca=m;
        volume=v;
    }
    public Commom(int v,String m){
        marca=m;
        volume=v;
    }
    public Commom(double p,String m){
        preco=p;
        marca=m;
    }
    public Commom(String m, double p){
        preco=p;
        marca=m;
    }
    public Commom(int v,double p){
        preco=p;
        volume=v;
    }
    public Commom(double p, int v){
        preco=p;
        volume=v;
    }
    public Commom(String marca, String modelo, int volume, double preco) {
        this.marca = marca;
        this.modelo = modelo;
        this.volume = volume;
        this.preco = preco;
    }
   /*
    Cadastrar;
    */   
    public void cadastrar(String marca, String modelo, int volume,
    double preco)
    {
        setMarca(marca);
        setModelo(modelo);
        setVolume(volume);
        setPreco(preco);
    }
    public void imprimir(){
        System.out.println("Marca: "+marca
                + "Modelo: "+modelo
                + "Volume: "+volume
                + "Preço: "+preco);

Se alguém puder dar a dica ou redirecionar pra algum material eu agradeço! 

Obrigado a TODOS!!

[giu_d 583]

@Bruno Coviello Olá. Vou te passar um código de um projeto bem didático para ver se você entende melhor o conceito de Herança:

 

Classe Veiculo:

public class Veiculo {

    protected String marca;
    protected String modelo;
    protected int ano;

    public void buzinar() {
        System.out.println("BI BI");
    }

    public void imprimirDados() {
        System.out.println("Marca: " + marca);
        System.out.println("Modelo: " + modelo);
        System.out.println("Ano: " + ano);
    }

    public void empinar() {
        System.out.println("UHU!");
    }

    public String getMarca() {
        return marca;
    }

    public void setMarca(String marca) {
        this.marca = marca;
    }

    public String getModelo() {
        return modelo;
    }

    public void setModelo(String modelo) {
        this.modelo = modelo;
    }

    public int getAno() {
        return ano;
    }

    public void setAno(int ano) {
        this.ano = ano;
    }
}

Classe Carro:

public class Carro extends Veiculo {

    private boolean quatroPortas;

    public boolean isQuatroPortas() {
        return quatroPortas;
    }

    public void setQuatroPortas(boolean quatroPortas) {
        this.quatroPortas = quatroPortas;
    }

    @Override
    public void imprimirDados() {
        super.imprimirDados();
        System.out.println("Quatro portas: " + quatroPortas);
    }
}

Classe Caminhao:

public class Caminhao extends Veiculo {

    @Override
    public void buzinar() {
        System.out.println("FOM FOM");
    }
}

Classe Motocicleta:

public class Motocicleta extends Veiculo {

    public void empinar() {
        System.out.println("UHU!");
    }
}

Classe principal com o método main:

public class Aplicacao {

    public static void main(String[] args) {

        System.out.println("Carro");
        Carro c = new Carro();
        c.setMarca("XYZ");
        c.setModelo("ABC");
        c.setAno(2000);
        c.setQuatroPortas(true);
        c.imprimirDados();
        c.buzinar();

        System.out.println("Motocicleta");
        Motocicleta m = new Motocicleta();
        m.setMarca("QQQ");
        m.setModelo("ZZZ");
        m.setAno(2010);
        m.imprimirDados();
        m.empinar();
        m.buzinar();

        Caminhao cam = new Caminhao();
        cam.buzinar();
    }
}

Perceba q os métodos getters e setters só são criados na super classe (ou classe mãe ) Veiculo, porém, podem ser acessados por todas as classes "filhas", Carro, Caminhao e Motocicleta

O termo extends se refere a uma classe ser uma classe "filha" de outra classe, logo, ela herda todos os atributos e métodos da "classe-mãe" (ou super classe)

 

Herança é um dos pilares de orientação a objetos, juntamente com Polimorfismo, Encapsulamento e Abstração

E outra: Umas das principais vantagens de orientação a objetos se comparada com programação procedural (estruturada) é o reaproveitamento d código 

[Bruno Coviello Autor do tópico 6]

E quanto aos construtores?

Não estou no pc, mas lembro que era o seguinte: 

/*Na super classe*/
String nome;
int idade;
public Humano(String n,int i){
nome=n;
idade=i;
}
/*Na sub classe*/
String sobrenome;
public Humano(String sb){
super(n,i);
sobrenome=sb;
}

Enfim, em relação aos construtores há algum tipo de sintaxe especial?

[giu_d 583]

@Bruno Coviello Olá. Com relação aos construtores seria do modo como você está fazendo mesmo, onde, na classe-filha, você chama o construtor da classe-mãe

Só tem um ponto q gostaria de frisar: Já vi programadores com um vasta experiência em orientação em objetos seguir o q me pareceu uma boa prática de programação

Seguindo essa prática, o construtor da super classe ficaria assim:

public Humano(String nome,int idade) {
    this.nome = nome;  // aqui o " this.nome " se refere ao atributo da classe, enquanto que " nome " se refere ao parâmetro 
    this.idade = idade;
}

Percebeu q é usado o mesmo nome do atributo da classe para o nome do parâmetro, e depois diferenciá-los com o operador this 

 

[Bruno Coviello Autor do tópico 6]

Entendi! Valeu! Abraços e valeu pela ajuda mais uma vez XD

[giu_d 583]

@Bruno Coviello Olá. Apenas p deixar mais completa a resposta, vou pegar o código q passei acima e criar um construtor na super classe Veiculo:

public Veiculo(String marca, String modelo, int ano) {
    this.marca = marca;
    this.modelo = modelo;
    this.ano = ano;
}

E aí um construtor na classe Carro:

public Carro(String marca, String modelo, int ano, boolean quatroPortas) {
    super(marca, modelo, ano);
    this.quatroPortas = quatroPortas;
}

E Motocicleta:

public Motocicleta(String marca, String modelo, int ano) {
    super(marca, modelo, ano);
}

E aí na classe principal, com o método main poderia fazer isso:

public class Aplicacao {

    public static void main(String[] args) {

        System.out.println("Carro");
        Carro c = new Carro("XYZ", "ABC", 4545);
        c.setQuatroPortas(true);
        c.imprimirDados();
        c.buzinar();

        System.out.println("Motocicleta");
        Veiculo m = new Motocicleta("QQQ", "ZZZ", 2017); // Perceba aqui o Polimorfismo ao criar um novo objeto
        m.imprimirDados();
        m.empinar();

        System.out.println("Caminhão");
        Caminhao cam = new Caminhao("Ford", "GHJ", 2011);
        cam.buzinar();
        cam.imprimirDados();
    }
}

Ou seja, apenas para comprovar q a maneira como você está fazendo está correta.

Perceba que para criar um novo objeto do tipo Motocicleta, estou fazendo uso do Polimorfismo:

Veiculo m = new Motocicleta("QQQ", "ZZZ", 2017);

Fiz d propósito isso para mostrar a relação é-um entre uma sub-classe e a classe mãe. Ou seja, um Carro é-um Veiculo, uma Motocicleta é-um Veiculo, etc...

Saber disso vai ajudar você a planejar melhor seus projetos, que é um passo fundamental p se fazer antes de começar a criar códigos.

Também é preciso pensar q mais tarde seu projeto pode crescer. Ex: Suponha q mais tarde você quer incluir um ônibus em seu projeto por algum motivo. Um ônibus é-um Veiculo, logo, basta criar a classe Onibus e fazer ela herdar de Veiculo por meio da palavra reservada extends. Dessa forma, você poderia incluir um ônibus em seu projeto sem nem mesmo ter q mudar uma linha de código se quer no que já foi criado, por isso é importante planejar bem como implementar seu projeto.

Claro q isso vem com a prática, não é d uma hora p outra

Mas a ideia aqui é apenas procurar mostrar as vantagens de um código orientado a objetos 

 

obs: acabei me empolgando com o assunto rs...