Primeiramente olá a todos, meu nome é Victor e esse é o meu primeiro post.
Minha dúvida é a seguinte: eu quero que uma classe “pai” passe variáveis obrigatórias diretamente para a classe “filho”.
Como assim?
Exemplo:
public class Funcionario {
//Variáveis que serão passadas para a classe "filho"
private float salario;
private int cargaHoraria;
}
Eu gostaria que essas variáveis fossem passadas para essa outra classe como forma obrigatória e visivel:
[code]public class Professor extends Funcionario{
}[/code]
No caso assim:
public class Professor extends Funcionario{
//Variáveis que foram passadas obrigatoriamente para essa classe
private float salario;
private int cargaHoraria;
}
Algo parecido com os métodos obrigatórios que algumas classes passam só que em forma de variáveis.
Espero que tenham entendido, muito obrigado.
Obs.: o “extends” foi só um exemplo.
Olha amigo com variáveis eu não sei se dá pra fazer isso.
Mas se você usar os métodos getters e setters ou encapsulamento com o modificador abstract.
Estará obrigando a classe filho usar esses métodos.
[code]public abstract class Funcionario {
protected float salario;
protected int cargaHoraria;
public abstract void setSalario(float salario);
public abstract void setCargaHoraria(int cargaHoraria);
public abstract float getSalario();
public abstract int getCargaHoraria();
} [/code]
[code]public class Professor extends Funcionario{
// Agora será necessário implementar todos os métodos da classe Funcionario e assim tem que usar todas as variáveis.
public void setSalario(float salario) {
this.salario = salario;
}
public void setCargaHoraria(int cargaHoraria) {
this.cargaHoraria= cargaHoraria;
}
public float getSalario() {
return salario;
}
public int getCargaHoraria() {
return cargaHoraria;
}
Obrigado, javahunter!
Eu fiz de outra forma:
Criei uma interface -> Para obrigar a classe a ter os métodos.
Criei uma classe -> Para aplicação dos métodos, para que depois eu possa gerar a herança.
Criei a classe “professor” -> Para teste de polimorfismo.
Interface
public interface Trabalhador {
public float getSalario();
public void setSalario(float salario);
public int getCargaHoraria(); //Horas
public void setCargaHoraria(int cargaHoraria);
}
Class com a interface
[code]public class Funcionario implements Trabalhador {
protected float salario;
protected int cargaHoraria;
@Override
public int getCargaHoraria() {
return cargaHoraria;
}
@Override
public void setCargaHoraria(int cargaHoraria) {
this.cargaHoraria = cargaHoraria;
}
@Override
public float getSalario() {
return salario;
}
@Override
public void setSalario(float salario) {
this.salario = salario;
}
}[/code]
Class test
public class Professor extends Funcionario{
int valorHoraAula;
//Poliformismo
public float getSalario() {
salario = valorHoraAula * cargaHoraria;
return salario;
}
}
Sua solução foi bem interessante, mas só pra informação, é possível uma subclasse herdar atributos também, só que não atributos privados.
Quando você diz que um atributo é privado, somente aquela classe terá acesso a ela, então qualquer um que estenda a essa classe sequer saberá que ele existe, agora com modificadores de visibilidade diferentes isso é possível, veja:public abstract class Funcionario {
//Variáveis que serão passadas para a classe "filho"
protected float salario;
protected int cargaHoraria;
} [code]public class Professor extends Funcionario{
public int getCargaHoraria(){
return cargaHoraria;
}
}[/code][code]public class Teste{
public static void main(String[] args){
Professor professor = new Professor();
System.out.println(professor.getCargaHoraria());
}
...
public abstract void setSalario(float salario);
...
E ainda segundo as boas práticas, para cada classe abstrata devemos declarar ao menos um método abstrato, já que o papel da classe abstrata é não ser instanciável (usar new) e promover um mesmo comportamento para seus filhos (parêmetros e tipo de retorno) mas com implementações diferentes por parte deles. Como exemplo segue algumas classes usando abstract:
public abstract Conta {
protected double saldo; // filhos de conta terão disponível o atributo saldo
public abstract double getSaldo(); // delega para seus filhos implementarem o corpo do método
}
public class ContaCorrente extends Conta {
private double limite;
public double getSaldo() {
return saldo + limite;
}
}
public class ContaPoupanca extends Conta {
public double getSaldo() {
return saldo;
}
}
Por favor não se prendam aos cálculos que mostrei aqui, (sou péssimo em matmática financeira, rsrsrs), mas vejam a versatilidade que ganhamos ao usar uma classe abstrata delegando regras aos seus filhos, afinal não precisamos instanciar a classe Conta, ela será utilizada única e exclusivamente em função das classes ContaCorrente e ContaPoupanca.
...
public abstract void setSalario(float salario);
...
E ainda segundo as boas práticas, para cada classe abstrata devemos declarar ao menos um método abstrato, já que o papel da classe abstrata é não ser instanciável (usar new) e promover um mesmo comportamento para seus filhos (parêmetros e tipo de retorno) mas com implementações diferentes por parte deles. Como exemplo segue algumas classes usando abstract:
public abstract Conta {
protected double saldo; // filhos de conta terão disponível o atributo saldo
public abstract double getSaldo(); // delega para seus filhos implementarem o corpo do método
}
public class ContaCorrente extends Conta {
private double limite;
public double getSaldo() {
return saldo + limite;
}
}
public class ContaPoupanca extends Conta {
public double getSaldo() {
return saldo;
}
}
Por favor não se prendam aos cálculos que mostrei aqui, (sou péssimo em matmática financeira, rsrsrs), mas vejam a versatilidade que ganhamos ao usar uma classe abstrata delegando regras aos seus filhos, afinal não precisamos instanciar a classe Conta, ela será utilizada única e exclusivamente em função das classes ContaCorrente e ContaPoupanca.[/quote]
Hehehehehe rrsrsrsrsrs
public abstract String getNome();
public abstract void setNome(String nome);
public abstract String getCPF();
public abstract void setCPF(String CPF);
}[/code]
Funcionario.java
[code]public abstract class Funcionario extends PessoaFisica{
protected float salario;
protected int cargaHoraria;
public abstract float getSalario();
public abstract void setSalario(float salario);
public abstract int getCargaHoraria();
public abstract void setCargaHoraria(int cargaHoraria);
}[/code]
Professor.java
[code]public class Professor extends Funcionario{
private float valorHoraAula;
@Override
public float getSalario() {
this.salario = cargaHoraria * valorHoraAula;
return salario;
}
@Override
public void setSalario(float salario) {
this.salario = salario;
}
@Override
public int getCargaHoraria() {
return cargaHoraria;
}
@Override
public void setCargaHoraria(int cargaHoraria) {
this.cargaHoraria = cargaHoraria;
}
@Override
public String getNome() {
return nome;
}
@Override
public void setNome(String nome) {
this.nome = nome;
}
@Override
public String getCPF() {
return CPF;
}
@Override
public void setCPF(String CPF) {
this.CPF = CPF;
}
public float getValorHoraAula() {
return valorHoraAula;
}
public void setValorHoraAula(float valorHoraAula) {
this.valorHoraAula = valorHoraAula;
}
}[/code]
Acho que está tudo certo, estou no trabalho usando o notebook daqui. Depois dou uma revisada! Valeu galera!