Re: Workaround to overcome the generics limitation causes by Erasure

From:

Daniel Pitts <googlegroupie@coloraura.com>

Newsgroups:

comp.lang.java.programmer

Date:

2 May 2007 07:50:29 -0700

Message-ID:

<1178117429.671045.6440@o5g2000hsb.googlegroups.com>

On May 2, 6:23 am, yancheng.ch...@gmail.com wrote:

Initially, I thought the introduce of generics in Java would solve me
some problem in pattern design. Here, I make use of generic to design
Observer/Subject pattern.

public interface Observer<S, A> {
    public void update(S subject, A arg);

}

public class Subject<S, A> {

    public void attach(Observer<S, A> observer) {
        observers.add(observer);
    }

    void notify(S subject, A arg) {
        for (Observer<S, A> obs : observers) {
            obs.update(subject, arg);
        }
    }

    private List<Observer<S, A>> observers = new
CopyOnWriteArrayList<Observer<S, A>>();

}

However, due to the limitation of generics causes by erasure, I am
unable to have two different instantiations with same generics
interface

http://angelikalanger.com/GenericsFAQ/FAQSections/ProgrammingIdioms.h...

Compiler will complain if I tend to make an Object act as more than
one type of Observer.

public class MainFrame extends javax.swing.JFrame implements
org.yccheok.jstock.engine.Observer<RealTimeStockMonitor,
java.util.List<org.yccheok.jstock.engine.Stock>>,
org.yccheok.jstock.engine.Observer<StockHistoryMonitor,
StockHistoryServer>

Currently, my workaround for this is using

public class MainFrame extends javax.swing.JFrame implements
org.yccheok.jstock.engine.Observer<Object, Object>

and performing instanceof checking (to check whether it is
RealTimeStockMonitor or StockHistoryMonitor) during runtime.

I had gone through severals articles :

http://www-128.ibm.com/developerworks/java/library/j-jtp01255.htmlhttp://gafter.blogspot.com/2004/09/puzzling-through-erasure-answer.htmlhttp://gafter.blogspot.com/2006/11/reified-generics-for-java.html

Till now, I still do not have any better workaround, in order to have
a typed-safe Observer/ Subject pattern. Can anyone of you share your
experience, how do you overcome this situation?

Thank you very much!

public interface Observer<S, A> {
     void update(S subject, A arg);
}

Where does the compiler complain about here:

class MyObserver {
   public void update(Foo subject, Integer arg) {
   }

   public void update(Bar subject, String arg) {
   }

   public Observer<Foo, Integer> getFooObserver() {
      return new Observer<Foo, Integer>() {
        public void update(Foo subject, Integer arg) {
          MyObserver.this.update(subject, arg);
        }
   }
   public Observer<Bar, Integer> getBarObserver() {
      return new Observer<Bar, Integer>() {
        public void update(Bar subject, Integer arg) {
          MyObserver.this.update(subject, arg);
        }
   }
}

Hope this helps,
Daniel.