Accesso ai metodi dall'implementazione di due interfacce in una classe

Question

Accesso ai metodi dall'implementazione di due interfacce in una classe

#1 da (12 voti)

4

Sto cercando di implementare il seguente pattern in un livello Cache.

Sto suddividendo l'implementazione di possibili metodi Cache come getUsers() nella classe UserCache , getLikes() nella classe PostsCache .

Ma mi piacerebbe che tutti questi metodi fossero accessibili da un oggetto di classe singola come Cache.getUsers() , Cache.getLikes()

La ragione di questo è che mi piacerebbe che gli sviluppatori che utilizzano questo livello non fossero consapevoli della divisione che è stata eseguita dietro questo livello.

Ho fatto quanto segue

2 interfacce - UserCache, PostsCache e 2 Classi che implementano le interfacce - UserCacheImpl, PostsCacheImpl .

Ho provato a introdurre una classe astratta AbstractCache che implementa queste 2 interfacce e quindi questa classe Cache estenderà quella classe astratta. Ma quello non è riuscito: (

Ora come posso combinare questi due essere accessibili da un singolo oggetto Cache . Per favore guidami

design java inheritance multiple-inheritance

posta Magesh Kumaar 08.07.2017 - 16:47

fonte

1 risposta

Leggi altre domande sui tag design java inheritance multiple-inheritance

Quali insidie sono insite nell'uso di classi parziali? Prevenire la manomissione del record del database?

score 12 · Answer 1

È perfettamente possibile che tu abbia

a[n] abstract class AbstractCache that implements these 2 interfaces and then this Cache class will extend that abstract class

public interface UserCache {
    int getUsers();
}

public interface PostsCache {
    int getLikes();
}

public abstract class AbstractCache implements UserCache, PostsCache {
    @Override public int getUsers() { return 12; }
    @Override public int getLikes() { return 34; }
}

public class Cache extends AbstractCache {
}

e che tutto compila perfettamente. Ciò che ovviamente non è possibile fare in Java è avere un'eredità multipla, dove una classe estende due classi (invece di implementare due interfacce), quindi non è possibile fare

public abstract class AbstractCache extends UserCacheImpl, PostsCacheImpl {
}

e sospetto che questo sia ciò che stai effettivamente cercando di fare. La soluzione qui è per favorire la composizione sull'ereditarietà :

public abstract class AbstractCache implements UserCache, PostsCache {
    private UserCacheImpl userCache;
    private PostsCacheImpl postsCache;

    public AbstractCache() {
        userCache = new UserCacheImpl();
        postsCache = new PostsCacheImpl();
    }

    @Override public int getUsers() { return userCache.getUsers(); }
    @Override public int getLikes() { return postsCache.getLikes(); }
}