Refactoring di due classi da una libreria di terze parti che potrebbe aver esteso una classe base

Question

Refactoring di due classi da una libreria di terze parti che potrebbe aver esteso una classe base

#1 da (3 voti)
#2 da (2 voti)

2

Ho due Classi, con comportamenti molto simili, entrambi da una libreria di terze parti. Entrambi devono essere compilati con qualche oggetto valore e inviati a code specifiche per la registrazione. Si prega di notare che entrambi non hanno un genitore comune.

Mi sto grattando la testa per scoprire i modi per refactoring questo. Ecco lo sceanrio.

Classe 1: Apple Classe 2: arancione

Sfortunatamente, Apple e Orange non sono classi figlio di Fruit E non posso cambiarli per estendere una classe base. I costruttori di Apple e Orange hanno diverse firme.

Codice corrente:

if(isApple){
    Apple apple = new Apple(....);
    apple.setColor(Color.RED);
    apple.setPrice(10);
    apple.setCount(1000);

    AppleMQObject applMQObject = new AppleMQObject(apple);
    Producer appleProducer = Factory.create("apple-producer");
    appleProducer.send(applMQObject);
}else{
    Orange orange = new Orange(...);
    orange.setColor(Color.ORANGE);
    orange.setPrice(30);
    orange.setCount(100);
    OrangeMQObject oMQObject = new oMQObject(orange);
    Producer orangeProducer = Factory.create("orange-producer");
    orangeProducer.send(orangeMQObject);
}

Posso spostare il codice MQ in un metodo comune. Ma come gestire la situazione mela / arancia.

refactoring java third-party-libraries

posta ring bearer 02.10.2013 - 18:03

fonte

2 risposte

Leggi altre domande sui tag refactoring java third-party-libraries

Nomi funzione brevi per funzione o concetto generale usati spesso [duplicato] Qual è il modo più semplice / semplice per visualizzare una riga di testo solo quando si stampa una pagina Web utilizzando PHP?

score 3 · Answer 1

Questo è un perfezionamento della risposta @ user2670177:

Se le firme delle funzioni di entrambi sono quasi le stesse, potrebbe essere più semplice utilizzare l'ereditarietà invece della composizione.

Dato che hai le arance e le mandorle che vuoi elaborare

class Orange {
    public void setColor(Color color){}
    public void setPrice(int euroCents){}
    public void setCount(int numberOfItems){}
}

class Apple {
    public void setColor(Color color){}
    public void setPrice(int euroCents){}
    public void setCount(int numberOfItems){}
}

È possibile definire un'interfaccia comune per entrambi

interface MyFruitInterface{
    void setColor(Color color);
    void setPrice(int euroCents);
    void setCount(int numberOfItems);
}

e allega l'interfaccia alla classe ereditata

class MyOrangeImpl extends Orange implements MyFruitInterface {
} 

class MyAppleImpl extends Apple implements MyFruitInterface {
}

Ora il tuo codice comune MQObject può gestire entrambi:

class MQObject {
    private MyFruitInterface fruit;
    MQObject(MyFruitInterface fruit) {
        this.fruit = fruit;
    }

    void setPriceColorCount(int euroCents, Color color, int numberOfItems) {
        fruit.setPrice(euroCents);
        fruit.setColor(color);
        fruit.setCount(numberOfItems);
    }
}

void testMQ() {
    MQObject applMQObject = new MQObject(new MyAppleImpl());
    MQObject orangeMQObject = new MQObject(new MyOrangeImpl());
}

score 2 · Answer 2

MyFruitInterface{
setColor();
setPrice;
..
}

MyOrangeImpl{
Orange o;

MyOrangeImpl(Orange o)
{
this.o = o;
}
setColor(Color C){
o.setColor(c);
}
setPrice(int price){
o.setPrice(price);
}
..
} 
MyAppleImpl{

Apple a;

MyAppleImpl(Apple a)
{
this.a = a;
}
setColor(Color C){
a.setColor(c);
}
setPrice(int price){
a.setPrice(price);
}
..
}

Ora hai un'interfaccia comune;