Attributi/variabili membro nelle interfacce?

Question

Vorrei sapere se esiste un modo in cui posso rendere obbligatorio per la classe implementatore dichiarare gli handle handle/primitives come fanno con i metodi. per es .:

public interface Rectangle {  
    int height = 0; 
    int width = 0; 

    public int getHeight(); 
    public int getWidth(); 
    public void setHeight(int height); 
    public void setWidth(int width);     
} 


public class Tile implements Rectangle{ 
    @Override 
    public int getHeight() { 
     return 0; 
    } 

    @Override 
    public int getWidth() { 
     return 0; 
    } 

    @Override 
    public void setHeight(int height) { 
    } 

    @Override 
    public void setWidth(int width) { 
    } 

} 

Nel metodo di cui sopra come possiamo costringere classe Tile per dichiarare attributi altezza e larghezza mediante l'interfaccia? Per qualche ragione, desidero farlo solo con l'interfaccia!

Inizialmente ho pensato di usarlo con l'ereditarietà. Ma la cosa è che devo affrontare con 3 classi.!

1. rettangolo
2. Tile
3. JLabel.!

 

class Tile extends JLabel implements Rectangle {} 

avrebbe funzionato.!

ma

class Tile extends JLabel extends Rectangle {} 

non woud.!

Answer 1

Il punto di un'interfaccia è specificare l'API pubblica. Un'interfaccia non ha stato. Qualsiasi variabile che crei è davvero una costante (quindi fai attenzione a creare oggetti mutabili nelle interfacce).

Fondamentalmente un'interfaccia dice qui sono tutti i metodi che una classe che lo implementa deve supportare. Probabilmente sarebbe stato meglio se i creatori di Java non avessero permesso le costanti nelle interfacce, ma troppo tardi per sbarazzarsene ora (e ci sono alcuni casi in cui le costanti sono sensibili nelle interfacce).

Poiché si specifica solo quali metodi devono essere implementati, non vi è alcuna idea di stato (nessuna variabile di istanza). Se vuoi richiedere che ogni classe abbia una certa variabile, devi usare una classe astratta.

Infine, in generale, non si dovrebbero utilizzare variabili pubbliche, quindi l'idea di inserire le variabili in un'interfaccia è una cattiva idea.

Risposta breve: non è possibile fare ciò che si desidera perché è "sbagliato" in Java.

Edit:

class Tile 
    implements Rectangle 
{ 
    private int height; 
    private int width; 

    @Override 
    public int getHeight() { 
     return height; 
    } 

    @Override 
    public int getWidth() { 
     return width; 
    } 

    @Override 
    public void setHeight(int h) { 
     height = h; 
    } 

    @Override 
    public void setWidth(int w) { 
     width = w; 
    } 
} 

una versione alternativa sarebbe:

abstract class AbstractRectangle 
    implements Rectangle 
{ 
    private int height; 
    private int width; 

    @Override 
    public int getHeight() { 
     return height; 
    } 

    @Override 
    public int getWidth() { 
     return width; 
    } 

    @Override 
    public void setHeight(int h) { 
     height = h; 
    } 

    @Override 
    public void setWidth(int w) { 
     width = w; 
    } 
} 

class Tile 
    extends AbstractRectangle 
{ 
} 

Answer 2

Le interfacce non possono richiedono le variabili di istanza da definire: solo metodi.

(Variables can be defined in interfaces, ma non si comportano come ci si poteva aspettare:. Sono trattati come final static)

Felice di codifica.

Answer 3

È possibile farlo solo con una classe astratta, non con un'interfaccia.

dichiarare Rectangle come abstract class invece di un interface e dichiarare i metodi che devono essere implementati dalla sottoclasse come public abstract. Quindi la classe Tile estende la classe Rectangle e deve implementare i metodi astratti da Rectangle.

Answer 4

In Java non è possibile. L'interfaccia ha a che fare con i metodi e la firma, non ha a che fare con lo stato interno di un oggetto - questa è una domanda di implementazione. E anche questo ha senso - voglio dire, semplicemente perché alcuni attributi esistono, non significa che debbano essere usati dalla classe di implementazione. getHeight potrebbe effettivamente puntare alla variabile width (assumendo che l'implementatore sia un sadico).

(Come nota - questo non è vero per tutti i linguaggi, ActionScript consente di dichiarazione di attributi pseudo, e credo che C# non troppo)

Answer 5

campi nelle interfacce sono implicitamente public static final. (Anche i metodi sono implicitamente pubblici, quindi è possibile eliminare la parola chiave public.) Anche se si utilizza una classe astratta anziché un'interfaccia, suggerisco fortemente di rendere tutto non costante (public static final di un riferimento oggetto primitivo o immutabile) private. Più in generale "preferisci la composizione all'ereditarietà" - uno Tile non-uno-Rectangle (ovviamente, puoi giocare ai giochi di parole con "è-a" e "ha-a").

Answer 6

Qualcosa di importante è stato detto da Tom:

se si utilizza l'ha-un concetto, è evitare il problema

Infatti, se invece di usare estende e attrezzi si definiscono due attributi, uno di tipo rettangolare, uno di tipo JLabel nella classe Tile, allora si può definire una Rectangle ad essere sia un interfaccia o una classe.

Inoltre, normalmente incoraggerei l'uso di interfacce in connessione con l'has-a, ma suppongo che sarebbe un eccesso nella tua situazione. Tuttavia, sei l'unico in grado di decidere su questo punto (flessibilità del tradeoff/over-engineering).

Answer 7

Java 8 ha introdotto default methods per le interfacce mediante le quali è possibile eseguire il body sui metodi. Secondo le OOP, le interfacce dovrebbero fungere da contratto tra due sistemi/parti.

Ma ancora ho trovato un modo per ottenere la memorizzazione delle proprietà nell'interfaccia. Ammetto che è una brutta implementazione.

import java.util.Map; 
    import java.util.WeakHashMap; 

interface Rectangle 
{ 

class Storage 
{ 
    private static final Map<Rectangle, Integer> heightMap = new WeakHashMap<>(); 
    private static final Map<Rectangle, Integer> widthMap = new WeakHashMap<>(); 
} 

default public int getHeight() 
{ 
    return Storage.heightMap.get(this); 
} 

default public int getWidth() 
{ 
    return Storage.widthMap.get(this); 
} 

default public void setHeight(int height) 
{ 
    Storage.heightMap.put(this, height); 
} 

default public void setWidth(int width) 
{ 
    Storage.widthMap.put(this, width); 
} 
} 

Questa interfaccia è brutta. Per l'archiviazione di una proprietà semplice, erano necessari due hashmap e ogni hashmap crea automaticamente 16 voci per impostazione predefinita. Inoltre, quando l'oggetto reale è dereferenziato, JVM deve anche rimuovere questo riferimento debole.