java模式分类_java23种设计模式详解

1、创建型模式

首先介绍一下一下简单工厂模式，简单工厂模式不属于23种设计模式之一。

简单工厂模式

(1)单方法

简单工厂模式就是创建一个工厂类，对实现了同一个接口的实现类进行实例化。

<1> 关系图1>

<2>首次创建接口：2>

public interface ISend { public void send();}

<3> 然后创建实现类：3>

/** * 邮件发送实现类 * @author Administrator * */public class MailSend implements ISend{ @Override public void send() { System.out.println('邮件发送信息！'); }}

/** *短信发送实现类 * @author Administrator * */public class MessageSend implements ISend{ @Override public void send() { System.out.println('短信发送信息！'); }}

<4>创建简单工厂类：4>

/** * 简单工程类 * @author Administrator * */public class SigleMethodFactory { public ISend produce(String type){ if('mail'.equals(type)){ return new MailSend(); }else if('message'.equals(type)){ return new MessageSend(); } return null; }}<5>测试5>

public class SimpleFactoryTest { public static void main(String[] args){ ISend send = new SigleMethodFactory().produce('mail'); send.send(); }}输出：邮件发送信息！

(2)多方法

是对单方法简单工厂方法模式的改进，如果但方法传入的字符串不正确，则不能创建出对象，而多个方法的简单工厂模式，是提供多个工厂方法来创建不同的对象。

<1>关系图1>

<2>接口及实现类同单方法的简单工厂。2>

<3>工厂类：3>

public class MutiMethodSimpleFatory { public ISend produceMessage(){ return new MessageSend(); } public ISend produceMail(){ return new MailSend(); }}<4>测试4>

public class MutilMethodSmpFactoryTest { public static void main(String[] args) { ISend send = new MutiMethodSimpleFatory().produceMessage(); send.send(); }}输出：短信发送信息！

(3)静态方法

静态方法的简单工厂模式就是把工厂类里面的方法都修改为静态方法，直接调用，无需手动实例化简单工厂类。

总结：简单工厂模式适用于需要有大量的类需要实例化，而且这些类具有共同的接口，在以上三种中，第一种情况，如果传入的字符串错误，则不能正确创建对象，

第三种情况相对于第二种情况来讲，不需要实例化工厂类。所以大多数情况下使用第三种方式。

1.1 工厂方法模式(Factory Method)

简单工厂模式，类的创建依赖工厂类，如果要实现类的扩展，就必须修改工厂类，所以违反了设计模式的对修改关闭，对扩展开放的设计原则，这个这个问题使用

工厂方法模式就可以解决，创建一个工厂接口类和创建多个工厂的实现类，如果需要增加新的功能，直接增加工厂类即可解决。

<1>关系图1>

<2>发送的接口及实现类同简单工厂模式2>

<3>创建工厂类接口3>

public interface IFactoryMethod { public ISend produce();}<4>创建工厂类实现类4>

public class MailFatory implements IFactoryMethod{ @Override public ISend produce(){ return new MailSend(); } }

public class MessageFacory implements IFactoryMethod { @Override public ISend produce() { return new MessageSend(); }}<5>测试5>

public class FactoryMethodTest { public static void main(String[] args){ IFactoryMethod factory = new MailFatory(); ISend send = factory.produce(); send.send(); }}输出：短信发送信息！

1.2 抽象工厂模式(Abstact Factory)

工厂方法与抽象工厂的区别：

工厂方法模式：

一个抽象产品类，可以派生出多个具体的产品类。

一个抽象工厂类，可以派生出多个具体的工厂类。

抽象工厂模式：

多个抽象产品类，每个抽象产品都可以派生出多个具体的实现类。

一个抽象工厂类，可以派生出多个具体的工厂类。

区别：

工厂方法只有一个抽象产品，抽象工厂有多个。

工厂方法的具体实现类只能创建一个类的实例，而抽象工厂可以创建多个。

工厂方法侧重于怎么创建，抽象工厂侧重于创建那些。

比如利用抽象工厂实现对数据库访问的不同实现(jdbc,hibernate)等。

<1>关系图1>

<2>工厂接口类2>

public interface IAbstractFactory { public IMouse createMouse(); public IKeyBoard createKeyBoard();}<3>工厂接口的实现类3>

public class IntellFactory implements IAbstractFactory{ @Override public IMouse createMouse() { return new IntellMouse(); } @Override public IKeyBoard createKeyBoard() { return new IntellKeyBoard(); }}

public class LenevoFactory implements IAbstractFactory { @Override public IMouse createMouse() { return new LenevoMouse(); } @Override public IKeyBoard createKeyBoard() { return new LenevoKeyBoard(); }}<4>实体类接口4>

public interface IMouse { public void click();}

public interface IKeyBoard { public void hit();}<5>实体类接口实现类5>

public class LenevoMouse implements IMouse{ @Override public void click() { System.out.println('lenevo mouse'); } }

public class IntellMouse implements IMouse{ @Override public void click() { System.out.println('intell mouse'); }}

public class LenevoKeyBoard implements IKeyBoard{ @Override public void hit() { System.out.println('lenevo keyBoard'); }}

public class IntellKeyBoard implements IKeyBoard { @Override public void hit() { System.out.println('intell keyBoard'); }}<5>测试5>

public class AbstractFatoryTest { public static void main(String[] args) { IAbstractFactory factory = new IntellFactory(); IKeyBoard keyBoard = factory.createKeyBoard(); IMouse mouse = factory.createMouse(); keyBoard.hit(); mouse.click(); }}输出：

intell keyBoard

intell mouse

1.3 单例模式(Sigleton)

单例模式的特点:

单例类必须只有一个实例；

单例类必须自己创建自己的实例；

单例类必须给其他所有实例提供这一个对象。

单例模式就是要保证某个类只有一个实例，并且自行实例化并向系统提供这个实例。在计算及系统中，线程池，日志，

缓存，打印机等常被设计成单例类。

<1>懒汉式单例1>

/** * 线程不安全的 * @author Administrator * */public class LazySingleton { //私有的静态变量，防止被引用 private static LazySingleton instance = null; //私有的构造器，防止被实例化 private LazySingleton(){ } private static LazySingleton getInstance(){ if(instance == null){ instance = new LazySingleton(); } return instance; }}

/** * 线程安全的懒汉式 * @author Administrator * */public class SafeLazySingleton { private static SafeLazySingleton instance = null; private static synchronized SafeLazySingleton init(){ if(instance == null){ return new SafeLazySingleton(); } return instance; } public static SafeLazySingleton getInstance(){ if(instance == null){ init(); } return instance; }}

<2>饿汉式单例2>

public class HungrySingle { private static HungrySingle instance = new HungrySingle(); private HungrySingle(){ } public static HungrySingle getInstance(){ return instance; }}

1.4 建造者模式(Builder)    工厂模式提供的是创建单个类的模式，建造者模式将多个产品集中起来进行管理，用来创建集合对象。