Newsgroup: it.comp.java
Titolo: Come fare?

Devo scrivere una libreria ma ho il seguente problema:
Ho due classi A e B che esetendono altre classi e che sono differenti in 
tutto per tutto tranne per due metodi:M1 e M2 che devono essere di tipo 
package-accessed. Ora ho un'altra classe C che contiene il metodo M3 a 
cui come argomento deve essere passato un oggetto con i metodi M1 e M2 
quindi vanno bene sia oggetti del tipo A che B. Come faccio? Non posso 
fare una interfaccia con M1 e M2 in quanto non possono essere pubblici 
quindi l'unica cosa che posso fare e' effettuare l'overloading dei metodi?

Roberto wrote:

Una soluzione potrebbero dartela le innerclasses:
1) Realizzi un'interfaccia che contiene i metodi M1 e M2;
2) Implementi l'interfaccia (occhio a questo punto) con una innerclass 
dentro A e B, che tieni con visibilità di package.
3) Fai in modo che il metodo M3 della classe C accetti oggetti del tipo 
interfaccia definito sopra.
Secondo i tuoi scopi l'interfaccia stessa potrebbe essere una innerinterface 
oppure potrebbe essere definita dentro un file con nome diverso in modo da 
non essere essa stessa pubblica.
Ecco un po' di codice esplicativo:
interface YourInterface
{
        public yourType M1();
        public yourType M2();
}
public class A
{
        class YourInner implements YourInterface
        {
                ...
        }
}
public class B
{
        class YourInner implements YourInterface
        {
                ...
        }
}
public class C
{
        public yourType M3( YourInterface yi )
        {
                ...
                yi.M1();
                yi.M2();
                ...
        }
}
Dall'interno del package potresti chiamare il metodo M3 di C in un modo 
simile:
C c = new C();
c.M3( new A().new YourInner() );
...
ciao :)
pole
-- 
Note: Some input words use a deprecated author.
Note: Read with -deprecation to understand.
http://web.tiscali.it/meridies

Roberto ha scritto:


Questo potrebbe fare al caso tuo ...
abstract class MethodDefiner{
    public abstract void metodoUno();
    public abstract void metodoDue();
}
class A extends MethodDefiner{
    public void metodoUno(){System.out.println("Metodo 1 - classeA");}
    public void metodoDue(){System.out.println("Metodo 2 - classeA");}
    public void metodoClasseA(){System.out.println("Metodo classeA");}
}
class B extends MethodDefiner{
    public void metodoUno(){System.out.println("Metodo 1 - classeB");}
    public void metodoDue(){System.out.println("Metodo 2 - classeB");}
    public void metodoClasseB(){System.out.println("Metodo classeB");}
}
class MethodExecuter{
    public void eseguiMetodi(MethodDefiner m){
        m.metodoUno();
        m.metodoDue();
    }
}
public class TestMethod{
    public static void main(String[] args){
        MethodExecuter exe = new MethodExecuter();
        MethodDefiner m = new A();
        exe.eseguiMetodi(m);
        m = new B();
        exe.eseguiMetodi(m);
    }
}
Hope this help
mauro
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 > package-accessed. 
[ CUT ]
Mi correggo da solo, nella definizione dei metodi cambia la visibilità da
public a protected ...
abstract class MethodDefiner{
protected abstract void metodoUno();
protected abstract void metodoDue();
}
class A extends MethodDefiner{
protected void metodoUno(){System.out.println("Metodo 1 - classeA");}
protected void metodoDue(){System.out.println("Metodo 2 - classeA");}
protected void metodoClasseA(){System.out.println("Metodo classeA");}
}
class B extends MethodDefiner{
protected void metodoUno(){System.out.println("Metodo 1 - classeB");}
protected void metodoDue(){System.out.println("Metodo 2 - classeB");}
protected void metodoClasseB(){System.out.println("Metodo classeB");}
}
ciao
