[saga-rg] Is there Factory in Java Binding?

[Pascal Kleijer]

Hi all,

In Java, a design pattern is defined by an Interface, like:

public interface Foo {
   ...
   public void foo ();
   ...
}

public interface Bar {
   ...
   public void bar ();
   ...
}

All methods in the interface are abstract (virtual in C++) and all 
attributes are static and global.

You can then implement this interface on any object. 1 object can 
implement more then one interface but cannot inherit of more then 1 
class, as opposed to C++. Default inheritance is the Object class. That 
means you have to use the aggregation paradigm with interface to 
archives multi-inheritance.

public class MyFoo implements Foo, Bar {
   public void foo () {
     System.out.println ("Hello SAGA foo[l] ;p");
   }
   public void bar () {
     System.out.println ("A bar of black chocolate!");
   }
}

public class AndreFoo implements Foo {
   public void foo () {
     System.out.println ("Hello Andre!");
   }
}

// Code
Foo foo= new MyFoo();
foo.foo();
foo= new AndreFoo();
foo.foo();


If your program have different implementations of the same Foo interface 
that are supposed to do the same (API contract), that is possible, see 
Hidemoto's example. Like the XML parsers you can implement a SPI 
(Service Provider Interface) to access the different implementations 
without having to care about the full class names and locations 
(packages). Some default SPI are directly endorsed by the Java runtime, 
like the XML stuff.

I did not check the implementation yet, but it should be implicit that 
the implementation uses design patterns otherwise it will be a hard job 
to switch between implementations.

Best regards,
Pascal Kleijer



Andre Merzky wrote:
> Hi Hidemote, Graeme, 
> 
> please excuse my ignorance - as said before, I am Java
> agnostic, and my question might be off target...
> 
> Hidemote mentioned the use of the factory pattern at GGF
> already, and other people I know which do Java issued
> similar statements.
> 
> How does that actually compare to other languages?  E.g. in
> C/C++, you can usually link your code against a specific
> _API_ in a shared library - as long as a library implements
> the same API, there is no need to recompile (just exchange
> library).
> 
> Also, in C/C++ it is possible to implement an API with
> plugins: so you create a thin API layer, which forwards to
> dunamically loaded plugins, which can then provide different
> implementations of the API calls.
> 
> The latter way is what we actually do in our C++
> implementation (plugins are called adaptors though).
> 
> The difference I see is actually that in both cases, the
> fact that the API is implemented by different vendors is
> completely hidden on API level, w/o the need for any
> additional patterns like factories.
> 
> So, is there a difference between these approaches?  And if
> not: what is the advantage of the factory approach?
> 
> Thanks, 
> 
>   Andre.
> 
> 
> Quoting [Hidemoto Nakada] (May 17 2006):
>> All,
>>
>> I have a question on the Java Binding.
>> Does the current Java binding include explicit factory notion?
>>
>> Factory mechanism is important to
>> - reuse a source code with several implementation of the API
>>    without modification of the code.
>> - leverage several implementation simultaneously from one
>>   client code.
>>
>> One good example of factory design can be found in the Dom parser
>> definition; org.w3c.dom.DomImplementation.
>> When you create a Dom document
>>
>> - get a DomImplementation from org.w3c.dom.bootstrap.DomImplementationRegistory
>> - then create a Document object using DomImplementation.
>>
>> This mechanism might be too complicated for SAGA, but
>> I think some flavor of this is required.
>>
>> -hidemoto
>>
>>
>>
>>
> 
> 
> 

-------------- next part --------------
A non-text attachment was scrubbed...
Name: smime.p7s
Type: application/x-pkcs7-signature
Size: 4385 bytes
Desc: S/MIME Cryptographic Signature
Url : http://www.ogf.org/pipermail/saga-rg/attachments/20060518/d7f6a7f7/attachment-0003.bin