Motivi per cui le parole chiave abstract e strictfp non possono essere utilizzate insieme in una dichiarazione di metodo?

Question

Sto leggendo SCJP di katherine sierra.
Capisco che le parole chiave astratte e finali non possono essere utilizzate insieme perché si contraddicono a vicenda come spiegato nel libro.

Tuttavia, non capisco perché le parole chiave strictfp e abstract non possano essere utilizzate insieme.
Non so come la parola chiave strictfp funzioni esattamente ancora in Java.

Nei miei pensieri, si potrebbe dichiarare un metodo abstract strictfp, avere una sottoclasse e implementare tale metodo nel "modo strictfp".

Qual è il motivo per cui queste parole chiave non vanno d'accordo?
EDIT
ho ricontrollato il libro e si dice certo

Perché metodi di interfaccia sono astratti, non possono essere contrassegnati finale, strictf, o nativo.

da SCJP di Katherine Sierra. pagina 21.

Anche il mio IDE (Eclipse Juno) dice che non posso usare insieme parole chiave astratte e strictfp.
Hmmm, perché no?

Answer 1

Katherine Sierra stava probabilmente parlando di metodi astratti. Non avrebbe senso creare un metodo astratto strictfp perché un metodo astratto fornisce solo una firma di metodo (e la clausola di throw, se presente), per usarlo abbiamo bisogno di sovrascriverlo in una sottoclasse con un metodo concreto e questo metodo avrà il suo modificatori che sovrascriveranno i modificatori del metodo principale. Cioè, i metodi non ereditano i modificatori.

Si noti che non è solo sctriptfp, ma non sono consentiti modificatori su metodi astratti tranne public e protected. Se ci provi, riceverai un errore in fase di compilazione.

Answer 2

Spero che tu abbia già la tua risposta, se non è così, potrebbe essere utile per te.

Ho riscontrato una domanda simile posta in un forum.

Il motivo per cui abstract e strictfp non può stare insieme nella dichiarazione del metodo è perché abstract dice il metodo non deve essere implementato dalla classe corrente e deve essere attuato dal sottoclasse concreta e strictfp dice che il metodo deve essere implementato (dovrebbe avere un corpo) dalla classe in cui viene utilizzato strictfp. Quindi in questo caso entrambe le parole chiave sono in contraddizione tra loro, quindi entrambe non sono ammesse insieme nelle dichiarazioni del metodo.

Ma è assolutamente legale utilizzare abstract e strictfp prima della lezione. Qualcosa di simile

public abstract strictfp class MyAbstractClass{}  //is ok 

Se dichiari strictf in una classe astratta poi tutto il suo metodo sta per essere strictf per impostazione predefinita. Ricorda tutti i metodi concreti a fianco della classe, non i metodi astratti.

Eseguire l'esempio indicato di seguito per vedere il PO:

import java.lang.reflect.*; 
public abstract strictfp class AbstractStrictfp 
{ 
    public abstract void abstractMethod(); 
    public void concreteMethod(){}; 

    public static void main(String args[]){ 
      Method methods[] = AbstractStrictfp.class.getMethods(); 
      for(Method method : methods){ 
       System.out.println("Method Name::"+method.getName()); 
        System.out.println("Modifiers::"+Modifier.toString(method.getModifiers())); 
       System.out.println(); 

      } 
    } 
}