子类没有从超类继承方法

Question

我从来没有经历过。

我有一堂课Loja。 Loja 有各种子类。

 public abstract class Loja {

/**
 * Corresponde ao valor da area da loja
 */
private double area;

/**
 * Nome da loja
 */
private String nome;

/**
 * Valor da renda fixa atribuida a todas as lojas
 */
private static double rendaFixa = 200;
/**
 * Área por omissão das lojas
 */
private static final double AREA_POR_OMISSAO = 0;

/**
 * Nome por omissão das lojas
 */
private static final String NOME_POR_OMISSAO = "sem nome";
/**
 * clasificação inferior por omissão dda loja
 */
private static final int CLASSIFICACAO_INFERIOR = 20;

/**
 * Classificação superior por omissão da loja
 */
private static final int CLASSIFICACAO_SUPERIOR = 100;

/**
 * dividendo da àrea para calcular a renda a pagar
 */
private static final int DIVIDENDO_DE_AREA = 100;

/**
 * Classificação da loja
 */
enum Classificacao {
    /**
     * classificação pequena
     */
    pequena(),
    /**
     * classificação média
     */
    media(),
    /**
     * classificação grande
     */
    grande();
}

/**
 * Instância uma instância Loja recebendo como parametro um double area e
 * uma String nome
 *
 * @param area Área da loja
 * @param nome Nome da loja
 */
public Loja(double area, String nome) {
    setArea(area);
    setNome(nome);
}

/**
 * construtor copia que leva como parametro ums instâncoa de Loja copiando
 * os atributos dessa instância para uma nova instância de Loja(area, nome)
 *
 * @param loja loja que servirá para clonar os atributos para construir uma
 * nova loja.
 */
public Loja(Loja loja) {
    setArea(loja.getArea());
    setNome(loja.getNome());
}

/**
 * Construtor que não recebe parâmetros logo usa o valor por omissão
 */
public Loja() {
    setArea(AREA_POR_OMISSAO);
    setNome(NOME_POR_OMISSAO);
}

/**
 * Método que retorna o valor da área
 *
 * @return area da loja
 */
public double getArea() {
    return area;
}

/**
 * método qeu retorna o nome da loja
 *
 * @return Nome da loja
 */
public String getNome() {
    return nome;
}

/**
 * Método que retorna o valor da renda fixa da loja
 *
 * @return valor da renda fixa
 */
public double getRendaFixa() {
    return rendaFixa;
}

/**
 * Método que retorna a classificação da loja
 *
 * @return classificação da loja
 */
public Classificacao getClassificacao() {
    if (area < CLASSIFICACAO_INFERIOR) {
        return Classificacao.pequena;
    } else if (area > CLASSIFICACAO_SUPERIOR) {
        return Classificacao.grande;
    }
    return Classificacao.media;

}

/**
 * Método que permite a alteração do valor da área
 *
 * lança uma excessão do tipo IllegalArguemntException caso a area seja
 * invalida ou seja: area menor que a area minima de loja(<5>)
 *
 * @param area Área da loja
 */
public void setArea(double area) {
    this.area = area;
}

/**
 * Método que permite alteração do nome da loja
 *
 * @param nome Nome da loja
 */
public void setNome(String nome) {
    this.nome = nome;
}

/**
 * Método toString que imprime na consola os atributos da loja
 *
 * @return String com valores da loja
 */
@Override
public String toString() {
    return String.format("Nome da loja: %s%nArea da loja: %f  Renda Fixa: %f €%n",
            area, rendaFixa, nome);
}

/**
 * Método que calcula a arenda a pagar pela loja
 *
 * Para ser especificado nas subclasses
 *
 * não usado polimorfismo na classe Quiosque porque classe têm o seu próprio
 * valor de renda a pagar
 *
 * @return valor da renda a pagar pela loja
 */
public double calcularRendaAPagar() {
    return rendaFixa * (1 + area / DIVIDENDO_DE_AREA);
}

}

calcularRendaAPagar是rentToPay()

我使用这种没有抽象修饰符的方法来使用多态性，因为每个子类都至少具有这种结构。但是，当我添加另一种方法时，例如

  public double allExpenses(){
   return calcularRendaAPagar();
  }

或者...

  public double allExpenses(){
     return 0;
  }

没有一个不是抽象的子类，“问”fo

Answer 1

超类可以是抽象的，也可以不是。

抽象超类可以定义抽象方法（无实现）和具体方法（有实现）。

这里的关键点是，如果您使用派生类中的具体方法 - 它们没有义务提供任何实现。可以使用父类的实现，并在需要时按需覆盖它。

所有抽象方法都需要在派生类中实现（或者如果派生类也是抽象的，则需要定义抽象），因为没有实现就无法使用它们。要强制所有类派生类实现某些东西，您需要声明抽象方法。

public abstract class AbstractOne {

    // Obligated to implement in all derived concrete classes
    public abstract void pay();

    // Can be used as is or could be overrided
    public void getTax() {
        System.out.println("Getting general tax");
    }
}

public class Derived1 extends AbstractOne {

    // Obligated to override
    @Override
    public void pay() {
        System.out.println("Pay by cash");
    }
}

public class Derived2 extends AbstractOne {

    // Obligated to override
    @Override
    public void pay() {
        System.out.println("Pay by card");
    }

    // Optional override
    @Override
    public void getTax() {
        System.out.println("Some new tax");
    }
}