The document is a 17 page presentation on the Adapter pattern. It defines the Adapter pattern as changing the interface of an existing class into another interface that is expected by clients. It discusses the intent, structure, applicability, consequences, known uses, and related patterns of the Adapter pattern. It also provides examples of its use and references for further information.

1. Adapter
SENG 609.04 Design Patterns
Winter, 2003
Presented by Ming Zhou, Guy Davis

2. Agenda
Intent & Motivation

Structure

Applicability

Consequences

Known Uses

Related Patterns

References

- Total 17 pages - 1

3. What is Adapter?
Change the interface of a

class into another interface
which is expected by the
client.
A.K.A. Wrapper

- Total 17 pages - 1

4. What is Adapter?
Change the interface of a

class into another interface
which is expected by the
client.
A.K.A. Wrapper

- Total 17 pages - 1

5. What is Adapter?
Change the interface of a

class into another interface
which is expected by the
client.
A.K.A. Wrapper

- Total 17 pages - 1

6. Motivation
- Total 17 pages - 1

7. Motivation
- Total 17 pages - 1

8. Motivation
- Total 17 pages - 1

9. Motivation
1 1
- Total 17 pages - 1

10. Structure (Class)
- Total 17 pages - 1

11. Structure (Object)
- Total 17 pages - 1

12. Applicability
- Total 17 pages - 1

13. Applicability
Use an existing class whose interface

does not match the requirement
- Total 17 pages - 1

14. Applicability
Use an existing class whose interface

does not match the requirement
Create a reusable class though the

interfaces are not necessary
compatible with callers
- Total 17 pages - 1

15. Applicability
Use an existing class whose interface

does not match the requirement
 Create a reusable class though the
interfaces are not necessary
compatible with callers
 Want to use several existing subclasses,
but it is impractical to subclass
everyone. (Object Adapter Only)
- Total 17 pages - 1

16. Class Adapter Pattern
Pros

Only 1 new object, no additional indirection

Less code required than the object Adapter

Can override Adaptee's behaviour as required

Cons

Requires sub-classing (tough for single

inheritance)
Less flexible than object Adapter

- Total 17 pages - 1

17. Object Adapter Pattern
Pros

More flexible than class Adapter

Doesn't require sub-classing to work

Adapter works with Adaptee and all of its

subclasses
Cons

Harder to override Adaptee behavior

Requires more code to implement

properly
- Total 17 pages - 1

18. Pluggable Adapters
implemented with abstract operations

- Total 17 pages - 1

19. Pluggable Adapters
implemented with delegate objects

- Total 17 pages - 1

20. Two-way Adapters
class PegAdapter: public SquarePeg,
class SquarePeg {
RoundPeg {
public:
void virtual squarePegOperation() public:
{ blah }
void virtual roundPegOperation() {
}
add some corners;
squarePegOperation();
class RoundPeg {
}
public:
void virtual squarePegOperation() {
void virtual roundPegOperation()
add some corners;
{ blah }
roundPegOperation();
}
}
}
- Total 17 pages - 1

21. Adapting Local Classes to RMI
Comparison:
 Increases reusability
of local class
 Improves performance
of local class
 Doesn't use Java
single parent by
subclassing (uses
composition)
- Total 17 pages - 1

22. Related Patterns
Adapter can be similar to the remote

form of Proxy. However, Proxy doesn't
change interfaces.
Decorator enhances another object

without changing its interface.
Bridge similar structure to Adapter,

but different intent. Separates
interface from implementation.
- Total 17 pages - 1

23. Conclusions
Allows collaboration between classes

with incompatible interfaces
Implemented in either class-based

(inheritance) or object-based
(composition & delegation) manner
Useful pattern which promotes reuse

and allows integration of diverse
software components
- Total 17 pages - 1

24. References
Becker, Dan. Design networked applications in RMI using the Adapter design

pattern. JavaWorld Magazine, May 1999. http://www.javaworld.com/javaworld/
jw-05-1999/jw-05-networked.html
Buschmann et al. A System of Patterns: Pattern-Oriented Software Architecture.

John Wiley and Sons. Chichester. 1996
Gamma et al. Design Patterns: Elements of Reusable Object-Oriented Software.

Addison-Wesley. Boston. 1995
Nguyen, D.X. Tutorial 10: Stacks and Queues: The Adapter Pattern. Rice

University. 1999. http://www.owlnet.rice.edu/~comp212/99-fall/tutorials/10/
tutorial10.html
Whitney, Roger. CS 635 Advanced Object-Oriented Design & Programming. San

Diego State University. 2001. http://www.eli.sdsu.edu/courses/spring01/cs635/
notes/proxy/proxy.html#Heading10
Shalloway, Alan., and Trott, James R., Design Patterns Explained: A New

Perspective on Object-Oriented Design, Addison-Wesley, 2002.
Rising, Linda., The Patterns Handbook: Techniques, Strategies, and Applications,

Cambridge university Press, 1998.
- Total 17 pages - 1

25. Questions?
- Total 17 pages - 1

26. Questions?
- Total 17 pages - 1

27. Java Native Interface (JNI)
SENG 609.04 Design Patterns
Winter, 2003
Presented by Guy Davis, Ming Zhou

28. Agenda
Overview

Justification

Hello World!

Summary

References

Q&A

- Total 17 pages - 1

29. JNI Overview
- Total 17 pages - 1

30. Interactions with Native Code
Access to Java world from native code
Access to- native code from Java
Total 17 pages - 1

31. Justification
Pros:
 Reuse: allows access to useful native code
 Efficiency: use best language for the task
Cons:
 Applets: doesn't work as they're mobile
 Portability: native methods aren't portable
 Extra work: javah, create shared native libs
- Total 17 pages - 1

32. HelloWorld.java
class HelloWorld {
public native void displayHelloWorld();
static {
System.loadLibrary(quot;helloquot;);
}
public static void main(String[] args) {
new
HelloWorld().displayHelloWorld();
}
}
- Total 17 pages - 1

33. HelloWorld.java
class HelloWorld {
public native void displayHelloWorld();
static {
System.loadLibrary(quot;helloquot;);
}
public static void main(String[] args) {
new
HelloWorld().displayHelloWorld();
}
}
- Total 17 pages - 1

34. HelloWorld.java
class HelloWorld {
public native void displayHelloWorld();
static {
System.loadLibrary(quot;helloquot;);
}
public static void main(String[] args) {
new
HelloWorld().displayHelloWorld();
}
}
- Total 17 pages - 1

35. HelloWorld.java
class HelloWorld {
public native void displayHelloWorld();
static {
System.loadLibrary(quot;helloquot;);
}
public static void main(String[] args) {
new
HelloWorld().displayHelloWorld();
}
}
- Total 17 pages - 1

36. HelloWorld.h
#include “jni.h”
/* Header for class HelloWorld */
#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern “C” {
#endif
/*
* Class: HelloWorld
* Method: displayHelloWorld
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_HelloWorld_displayHelloWorld(JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif
- Total 17 pages - 1

37. HelloWorld.h
#include “jni.h”
/* Header for class HelloWorld */
#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern “C” {
#endif
/*
* Class: HelloWorld
* Method: displayHelloWorld
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_HelloWorld_displayHelloWorld(JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif
- Total 17 pages - 1

38. HelloWorld.h
#include “jni.h”
/* Header for class HelloWorld */
#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern “C” {
#endif
/*
* Class: HelloWorld
* Method: displayHelloWorld
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_HelloWorld_displayHelloWorld(JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif
- Total 17 pages - 1

39. HelloWorldImp.c
#include <jni.h>
#include quot;HelloWorld.hquot;
#include <stdio.h>
JNIEXPORT void JNICALL
Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)
{
printf(quot;Hello world!nquot;);
return;
}
- Total 17 pages - 1

40. HelloWorldImp.c
#include <jni.h>
#include quot;HelloWorld.hquot;
#include <stdio.h>
JNIEXPORT void JNICALL
Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)
{
printf(quot;Hello world!nquot;);
return;
}
- Total 17 pages - 1

41. HelloWorldImp.c
#include <jni.h>
#include quot;HelloWorld.hquot;
#include <stdio.h>
JNIEXPORT void JNICALL
Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)
{
printf(quot;Hello world!nquot;);
return;
}
- Total 17 pages - 1

42. HelloWorldImp.c
#include <jni.h>
#include quot;HelloWorld.hquot;
#include <stdio.h>
JNIEXPORT void JNICALL
Java_HelloWorld_displayHelloWorld(JNIEnv *env, jobject obj)
{
printf(quot;Hello world!nquot;);
return;
}
- Total 17 pages - 1

43. Create a Shared Library
class HelloWorld {
...
System.loadLibrary(quot;helloquot;);
...
}
Compile the native code into a shared library:
(example for MS Windows Visual C++ 4.0)
cl -Ic:javainclude -Ic:javaincludewin32
-LD HelloWorldImp.c -Fehello.dll
- Total 17 pages - 1

44. Run the Program
Command:
java HelloWorld
Result:
Hello World!
Possible exceptions:
java.lang.UnsatisfiedLinkError: no hello in
shared library path at
java.lang.Runtime.loadLibrary(Runtime.java)
at java.lang.System.loadLibrary(System.java)
at java.lang.Thread.init(Thread.java)
- Total 17 pages - 1

45. Summary
Connect Java with native languages
Code reuse
Powerful
Compromise of Java safety features,

cross-platform and dynamic ability
JNI call is slow and costful

Not work well for applets

- Total 17 pages - 1

46. References
 Glenn L. Vanderburg. et al., Tricks of the Java
Programming Gurus, 1996, http://docs.rinet.ru:8080/
JaTricks/
 Beth Stearns, Trail: Java Native Interface, Sun
Microsystems, Inc., 2003, http://java.sun.com/docs/
books/tutorial/native1.1/
 Roedy Green, JNI, The Java Native Interface, Canadian
Mind Products, 2002, http://mindprod.com/jni.html
 Kong Wenyu, A Brief Introduction to Java Native
Interface, http://www.geocities.com/kongwenyu/jni.html
- Total 17 pages - 1

47. Questions?
- Total 17 pages - 1

48. Questions?
- Total 17 pages - 1