java设计模式大全

关于java设计模式的一些个人认识和总结，有不到位的地方希望大家给予指正和批评。

一. 什么是设计模式

我们经常可以看到这些现象：

建筑工地上，工人在盖房子，但是你看不到制造砖的人。

在汽车厂房里，你看到的是组装汽车的人，而不是制造零件的人。

在软件开发中，UI设计师，系统分析师，代码人员也是可以互相不用了解相关的内部知识，就可以完成相应的合作。因此一些专家就把他们在解决某一问题的过程中积累的一些经验进行总结。以帮助后来的人更好地掌握从抽象到具体的方法。这就是设计模式。

二.常用的设计模式
1.工厂模式

当创建对象比较简单的时候，可以直接在mian里面做，但是很多时候创建对象操作会比较复杂，而且如果子类对象变为另外一种类型时，就需要改变mian中的创建方法，这不是一个很好的解决方案。这个时候就可以通过工厂模式来解决。

(1)定义一个接口

//定义一个接口
public interface Fruit {
public void eat();
}

(2)定义接口的具体实现类

//接口的具体实现类
public class Apple implements Fruit {
@Override
public void eat() {
System.out.println("吃苹果");
}
}
public class Orange implements Fruit{
@Override
public void eat() {
System.out.println("吃橘子");
}
}

(3)定义一个工厂类

public class Factory {
public static Fruit getInstance(String className){
Fruit f=null;
if("apple".equals(className)){
f=new Apple();
}
if("orange".equals(className)){
f=new Orange();
}
return f;
}
}

(4)测试程序

public class Test {
public static void main(String[] args) {
Fruit f=null;
//工厂模式的精髓
//可以直接在主函数中通过标记更改参数类型，完成对象的实例化。灵活性更高
f=Factory.getInstance("apple");
f.eat();
}
}

2. 适配器模式

对于java来说一个类要实现一个接口，必须覆盖此接口中的全部方法，如果此时接口中的抽象方法过多，就很麻烦，此时，就需要一个中间的过渡，但是此过渡又不希望被直接使用，所以使用抽象类最为合适，这里我们把这个过渡的抽象类称为适配器类

案例分析：

(1) 定义一个接口，但是我们只要实现其中的open()和close()方法

public interface Window {
public abstract void open();
public abstract void close();
public abstract void activated();
public abstract void iconified();   //最小化
public abstract void deiconified(); //最大化
}

(2) 通过一个抽象类定义一个适配器：

public class WindowAdapter implements Window{
public void open() {}
public void close() {}
public void activated() {}
public void iconified() {}   //最小化
public void deiconified() {} //最大化
}

(3) 具体类实现适配器中所需的方法

public class WindowImpl extends WindowAdapter {
//真正实现的open()方法
public void open(){
System.out.println("打开window方法");
}
//真正实现的close()方法
public void close(){
System.out.println("关闭window方法");
}
}

(4) 测试程序：

public class Test {
public static void main(String[] args) {
Window win=new WindowImpl();
win.open();
win.close();
}
}

(5) 测试结果：

打开window方法
关闭window方法

3. 装饰模式

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

给一个对象增加新的功能有2种方法,第一个面向对象:继承，第二个装饰模式。

举例子：IO流

方案一：通过继承的话，如果后期要求增加的功能太多，继承体系就会越来越大，臃肿。

方案二：装饰模式应运而生。

编写一个装饰者把所有的输入流内的大写字符转化成小写字符：

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

public class LowerCaseInputStream extends FilterInputStream
{
protected LowerCaseInputStream(InputStream in)
{
super(in);
}

@Override
public int read() throws IOException
{
int c = super.read();
return (c == -1 ? c : Character.toLowerCase((char) c));
}

@Override
public int read(byte[] b, int offset, int len) throws IOException
{
int result = super.read(b, offset, len);
for (int i = offset; i < offset + result; i++)
{
b[i] = (byte) Character.toLowerCase((char) b[i]);
}
return result;
}
}

测试我们的装饰者类：

import java.io.*;

public class InputTest
{
public static void main(String[] args) throws IOException
{
int c;

try
{
InputStream in = new LowerCaseInputStream(new BufferedInputStream(
new FileInputStream("D:\\test.txt")));

while ((c = in.read()) >= 0)
{
System.out.print((char) c);
}

in.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}