JAVA-JDK里的设计模式

Structural（结构模式）

Adapter:
把一个接口或是类变成另外一种。
   •
java.util.Arrays#asList()
   •
javax.swing.JTable(TableModel)
   •
java.io.InputStreamReader(InputStream)
   •
java.io.OutputStreamWriter(OutputStream)
   •
javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
   •
javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()
Bridge:
把抽象和实现解藕，于是接口和实现可在完全独立开来。

• AWT
(提供了抽象层映射于实际的操作系统)
• JDBC
Composite:
让使用者把单独的对象和组合对象混用。

   •
javax.swing.JComponent#add(Component)
   •
java.awt.Container#add(Component)
   •
java.util.Map#putAll(Map)
   •
java.util.List#addAll(Collection)
   •
java.util.Set#addAll(Collection)

Decorator:
为一个对象动态的加上一系列的动作，而不需要因为这些动作的不同而产生大量的继承类。这个模式在JDK中几乎无处不在，所以，下面的列表只是一些典型的。

   •
java.io.BufferedInputStream(InputStream)
   •
java.io.DataInputStream(InputStream)
   •
java.io.BufferedOutputStream(OutputStream)
   •
java.util.zip.ZipOutputStream(OutputStream)
   •
java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
Facade:
用一个简单的接口包状一组组件，接口，抽象或是子系统。

•
java.lang.Class
•
javax.faces.webapp.FacesServlet
Flyweight:
有效率地存储大量的小的对象。

   •
java.lang.Integer#valueOf(int)
   •
java.lang.Boolean#valueOf(boolean)
   •
java.lang.Byte#valueOf(byte)
   •
java.lang.Character#valueOf(char)
Proxy:
用一个简单的对象来代替一个复杂的对象。

•
java.lang.reflect.Proxy
•
RMI

Creational（创建模式）

Abstract factory:
创建一组有关联的对象实例。这个模式在JDK中也是相当的常见，还有很多的framework例如Spring。我们很容易找到这样的实例。

   •
java.util.Calendar#getInstance()
   •
java.util.Arrays#asList()
   •
java.util.ResourceBundle#getBundle()
   •
java.sql.DriverManager#getConnection()
   •
java.sql.Connection#createStatement()
   •
java.sql.Statement#executeQuery()
   •
java.text.NumberFormat#getInstance()
   •
javax.xml.transform.TransformerFactory#newInstance()
Builder:
主要用来简化一个复杂的对象的创建。这个模式也可以用来实现一个 Fluent Interface。

   •
java.lang.StringBuilder#append()
   •
java.lang.StringBuffer#append()
   •
java.sql.PreparedStatement
   •
javax.swing.GroupLayout.Group#addComponent()
Factory:
简单来说，按照需求返回一个类型的实例。

   •
java.lang.Proxy#newProxyInstance()
   •
java.lang.Object#toString()
   •
java.lang.Class#newInstance()
   •
java.lang.reflect.Array#newInstance()
   •
java.lang.reflect.Constructor#newInstance()
   •
java.lang.Boolean#valueOf(String)
   •
java.lang.Class#forName()
Prototype:
使用自己的实例创建另一个实例。有时候，创建一个实例然后再把已有实例的值拷贝过去，是一个很复杂的动作。所以，使用这个模式可以避免这样的复杂性。

•
java.lang.Object#clone()
•
java.lang.Cloneable
Singleton:
只允许一个实例。在 Effective Java中建议使用Emun.

   •
java.lang.Runtime#getRuntime()
   •
java.awt.Toolkit#getDefaultToolkit()
   •
java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
   •
java.awt.Desktop#getDesktop()

Behavioral(行为模式)

Chain of responsibility:
把一个对象在一个链接传递直到被处理。在这个链上的所有的对象有相同的接口（抽象类）但却有不同的实现。

•
java.util.logging.Logger#log()
•
javax.servlet.Filter#doFilter()
Command:
把一个或一些命令封装到一个对象中。

•
java.lang.Runnable
•
javax.swing.Action
Interpreter:
一个语法解释器的模式。

   •
java.util.Pattern
   •
java.text.Normalizer
   •
java.text.Format
Iterator:
提供一种一致的方法来顺序遍历一个容器中的所有元素。

•
java.util.Iterator
•
java.util.Enumeration
Mediator:
用来减少对象单的直接通讯的依赖关系。使用一个中间类来管理消息的方向。

   •
java.util.Timer
   •
java.util.concurrent.Executor#execute()
   •
java.util.concurrent.ExecutorService#submit()
   •
java.lang.reflect.Method#invoke()
Memento:
给一个对象的状态做一个快照。Date类在内部使用了一个long型来做这个快照。

•
java.util.Date
•
java.io.Serializable
Null Object:
这个模式用来解决如果一个Collection中没有元素的情况。

   •
java.util.Collections#emptyList()
   •
java.util.Collections#emptyMap()
   •
java.util.Collections#emptySet()
Observer:
允许一个对象向所有的侦听的对象广播自己的消息或事件。

   •
java.util.EventListener
   •
javax.servlet.http.HttpSessionBindingListener
   •
javax.servlet.http.HttpSessionAttributeListener
   •
javax.faces.event.PhaseListener
State:
这个模式允许你可以在运行时很容易地根据自身内部的状态改变对象的行为。

•
java.util.Iterator
•
javax.faces.lifecycle.LifeCycle#execute()
Strategy:
定义一组算法，并把其封装到一个对象中。然后在运行时，可以灵活的使用其中的一个算法。

   •
java.util.Comparator#compare()
   •
javax.servlet.http.HttpServlet
   •
javax.servlet.Filter#doFilter()
Template method:
允许子类重载部分父类而不需要完全重写。

   •
java.util.Collections#sort()
   •
java.io.InputStream#skip()
   •
java.io.InputStream#read()
   •
java.util.AbstractList#indexOf()
Visitor:

作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作.

•
javax.lang.model.element.Element
和javax.lang.model.element.ElementVisitor
•
javax.lang.model.type.TypeMirror
和javax.lang.model.type.TypeVisitor
（全文完）

转自：http://coolshell.cn/articles/3320.html
参考：http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns

在eclipse上用lwuit的过程

下面是国外一个人发的在eclipse上用lwuit的过程。（是有很多注意的地方，感觉这个东西还是用sun的netbean方便）

Hello all

if you are an Eclipse developer like me, than you are probably
missing the possibility to build LWUIT with Eclipse. This small
How-To describes what I did to get this done:

What you need
a. Love to work with Eclipse 🙂
b. A subversion client (I use TortoiseSVN) and some subversion
know-how
c. A good internet connection

Setup Eclipse and create a new Midlet project
1. Install the Eclipse MJT plugin (http://www.eclipse.org/dsdp/mtj/) and set it up
correctly (http://www.eclipse.org/dsdp/mtj/ …
/gettingstarted.php)
2. Create a new “Midlet Project”
3. Open the “Application Descriptor” file and change the
“Microedition Profile” from version 2.1 to 2.0

Checkout LWUIT
4. Open a file explorer and navigate to the new project in your
Eclipse workspace (You can see where this is in the project
properties (Alt-Enter) on the “Resource”-tab)
5. Checkout the LWUIT directory with the URL
“https://lwuit.dev.java.net/svn/lwuit/trunk/MIDP/LWUIT”
(guest/guest) directly into your project directory with your svn
client

Fix compilation errors
6. Go back to Eclipse and refresh (F5) your project: now there
“src” folder should show some “com.sun.lwuit” folders and also
(unfortunately) some compiling errors
7. To fix the compiling errors (maybe if someone of the developer
team reads this, he can fix this directly in the repository), open
the erroneous classes and put a “this.” in front of every
expression marked as error (“setLayout…” ->
“this.setLayout…”)

Download necessary build files
8. Now comes the circumstantially part. You have to download
Netbeans! Yes, I’m afraid so. All you need is a JAR file with about
200K, that’s inside the Netbeans distribution. But I don’t want to
post it here, because I am not sure if this offend against any SUN
licenses.
9. After you downloaded and installed Netbeans, create a “lib”
directory inside your project. Then copy the
“org-netbeans-modules-mobility-antext.jar” from the
“NETBEANS_INSTALLATION\mobility8\modules” directory into your new
“lib” directory.

Fix the build for Eclipse
10. Open “nbproject/build-impl.xml” and delete “${netbeans.user}/”
in line 7. The line should now appear as:
<property name=”user.properties.file”
location=”build.properties”/>
(I know, that this file should not be edited (see line 2), maybe
someone has a better idea here)
10. Create a new “build.properties” file right under the project
(next to “build.xml”) with your settings for the build. You need at
least this three entries here:
* “project.LWUIT” = the path to the LWUIT project (in our case this
is “.”)
* “libs.j2me_ant_ext.classpath” = the path to the netbeans lib (in
our case this is now
“lib/org-netbeans-modules-mobility-antext.jar”)
* “platform.home” = the path to your WTK (this depends on your WTK
installation)

My “build.properties” looks like this:

project.LWUIT=.
libs.j2me_ant_ext.classpath=lib/org-netbeans-modules-mobility-antext.jar

platform.home=C:\\WTK2.5.2

These are the minimum entries for the “build.properties” file. If
someone finds more useful settings, please post it here.

Run the build
Now everything should be ready to run the build. Right-Click on
“build.xml” and say “Run as/Ant Build”. The build should finish
successfully and you should find the resulting “LWUIT.jar” in the
“dist” directory of the project.

I hope I can make some Eclipse developers happy with this How-To.
Any comments are welcome.

[Java]读取文件方法大全

1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容

public class ReadFromFile {

public static void readFileByBytes(String fileName) {

File file = new File(fileName);

InputStream in = null;

try {

System.out.println(“以字节为单位读取文件内容，一次读一个字节：“);

// 一次读一个字节
in = new FileInputStream(file);

int tempbyte;

while ((tempbyte = in.read()) != –1) {

System.out.write(tempbyte);

}

in.close();

} catch (IOException e) {

e.printStackTrace();

return;

}

try {

System.out.println(“以字节为单位读取文件内容，一次读多个字节：“);

// 一次读多个字节
byte[] tempbytes = new byte[100];

int byteread = 0;

in = new FileInputStream(fileName);

ReadFromFile.showAvailableBytes(in);

// 读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != –1) {

System.out.write(tempbytes, 0, byteread);

}

} catch (Exception e1) {

e1.printStackTrace();

} finally {

if (in != null) {

try {

in.close();

} catch (IOException e1) {

}

public static void readFileByChars(String fileName) {

File file = new File(fileName);

Reader reader = null;

try {

System.out.println(“以字符为单位读取文件内容，一次读一个字节：“);

// 一次读一个字符
reader = new InputStreamReader(new FileInputStream(file));

int tempchar;

while ((tempchar = reader.read()) != –1) {

// 对于windows下，\r\n这两个字符在一起时，表示一个换行。

// 但如果这两个字符分开显示时，会换两次行。

// 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
if (((char) tempchar) != ‘\r‘) {

System.out.print((char) tempchar);

}

reader.close();

} catch (Exception e) {

e.printStackTrace();

}

try {

System.out.println(“以字符为单位读取文件内容，一次读多个字节：“);

// 一次读多个字符
char[] tempchars = new char[30];

int charread = 0;

reader = new InputStreamReader(new FileInputStream(fileName));

// 读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars)) != –1) {

// 同样屏蔽掉\r不显示
if ((charread == tempchars.length)

&& (tempchars[tempchars.length – 1] != ‘\r‘)) {

System.out.print(tempchars);

} else {

for (int i = 0; i < charread; i++) {

if (tempchars[i] == ‘\r‘) {

continue;

} else {

System.out.print(tempchars[i]);

}

} catch (Exception e1) {

e1.printStackTrace();

} finally {

if (reader != null) {

try {

reader.close();

} catch (IOException e1) {

}

public static void readFileByLines(String fileName) {

File file = new File(fileName);

BufferedReader reader = null;

try {

System.out.println(“以行为单位读取文件内容，一次读一整行：“);

reader = new BufferedReader(new FileReader(file));

String tempString = null;

int line = 1;

// 一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null) {

// 显示行号
System.out.println(“line “ + line + “: “ + tempString);

line++;

}

reader.close();

} catch (IOException e) {

e.printStackTrace();

} finally {

if (reader != null) {

try {

reader.close();

} catch (IOException e1) {

}

public static void readFileByRandomAccess(String fileName) {

RandomAccessFile randomFile = null;

try {

System.out.println(“随机读取一段文件内容：“);

// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, “r“);

// 文件长度，字节数
long fileLength = randomFile.length();

// 读文件的起始位置
int beginIndex = (fileLength > 4) ? 4 : 0;

// 将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);

byte[] bytes = new byte[10];

int byteread = 0;

// 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。

// 将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != –1) {

System.out.write(bytes, 0, byteread);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

if (randomFile != null) {

try {

randomFile.close();

} catch (IOException e1) {

}

private static void showAvailableBytes(InputStream in) {

try {

System.out.println(“当前字节输入流中的字节数为:“ + in.available());

} catch (IOException e) {

e.printStackTrace();

}

public static void main(String[] args) {

String fileName = “C:/temp/newTemp.txt“;

ReadFromFile.readFileByBytes(fileName);

ReadFromFile.readFileByChars(fileName);

ReadFromFile.readFileByLines(fileName);

ReadFromFile.readFileByRandomAccess(fileName);

}

5、将内容追加到文件尾部

public class AppendToFile {

public static void appendMethodA(String fileName, String content) {

try {

// 打开一个随机访问文件流，按读写方式
RandomAccessFile randomFile = new RandomAccessFile(fileName, “rw“);

// 文件长度，字节数
long fileLength = randomFile.length();

//将写文件指针移到文件尾。
randomFile.seek(fileLength);

randomFile.writeBytes(content);

randomFile.close();

} catch (IOException e) {

e.printStackTrace();

}

public static void appendMethodB(String fileName, String content) {

try {

//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer = new FileWriter(fileName, true);

writer.write(content);

writer.close();

} catch (IOException e) {

e.printStackTrace();

}

public static void main(String[] args) {

String fileName = “C:/temp/newTemp.txt“;

String content = “new append!“;

//按方法A追加文件
AppendToFile.appendMethodA(fileName, content);

AppendToFile.appendMethodA(fileName, “append end. \n“);

//显示文件内容
ReadFromFile.readFileByLines(fileName);

//按方法B追加文件
AppendToFile.appendMethodB(fileName, content);

AppendToFile.appendMethodB(fileName, “append end. \n“);

//显示文件内容
ReadFromFile.readFileByLines(fileName);

}