java设计模式

java java设计模式

创建时间:2020-01-16 17:22

阅读:

一.java设计模式分类
二.设计模式代码实现

一.java设计模式分类

1.创建型模式，共五种：

工厂方法模式、 抽象工厂模式、 单例模式、 建造者模式、原型模式。

2.结构型模式，共七种：

适配器模式、装饰器模式、 代理模式、外观模式、桥接模式、组合模式、 享元模式。

3.行为型模式，共十一种：

策略模式、模板方法模式、 观察者模式、迭代子模式、责任链模式、

命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

二.设计模式代码实现

1.单例模式

1.1 模式概念：

类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.2模式要求：

(1)、单例类只能有一个实例。

(2)、单例类必须自己创建自己的唯一实例。

(3)、单例类必须给所有其他对象提供这一实例。

1.3模式使用介绍：

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：

1、一个班级只有一个班主任。

2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。

3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、要求生产唯一序列号。

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

1.4代码实现

public class SingleObject {
    //创建对象
     private static SingleObject instance = new SingleObject();
     //构造函数为private，这样该类就不会被实例化
     private SingleObject(){};
     //获取唯一可用对象
     public static SingleObject getInstance(){
         return instance;
     }
     public void show(){
         System.out.println("单例模式");
     }
}
public class TestSingleDemo {
    public static void main(String[] args) {
        //不合法的构造函数
        //编译时错误：构造函数 SingleObject() 是不可见的
        //    SingleObject singleObject = new SingleObject();

        //获取唯一可用对象
        SingleObject object = SingleObject.getInstance();
        object.show();
    }
}

2工厂模式

2.1模式概念

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

2.2模式使用介绍

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

应用实例：

1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现.

2、Hibernate 换数据库只需换方言和驱动就可以。

优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景：

1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

3、设计一个连接服务器的框架，需要三个协议，”POP3”、”IMAP”、”HTTP”，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

2.3代码实现

public interface Factory {
    public void draw();
}
public class Circle implements Factory{
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("display Circle");
    }
}
public class Square implements Factory{
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("display Square");
    }
}
public class FactoryObject {    
    public static Factory getObject(String type){
        if("Square".equals(type)){
            return new Square();
        }
        if("Circle".equals(type)){
            return new Circle();
        }
        if(type.isEmpty() || type==""){
            return null;
        }
        return null;
    }
}
public class TestFactoryDemo {
    public static void main(String[] args) {
        FactoryObject factoryObject = new FactoryObject();
        Circle circle = (Circle) factoryObject.getObject("Circle");
        circle.draw();
        Square square = (Square) factoryObject.getObject("Circle");
        square.draw();        
    }
}

3.原型模式

3.1模式概念

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节

3.2模式使用介绍

由于 Java 提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。

原型模式包含以下主要角色

(1).抽象原型类：规定了具体原型对象必须实现的接口。

(2).具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。

(3).访问类：使用具体原型类中的 clone() 方法来复制新的对象。

3.3代码实现

public class RealizeType implements Cloneable{
    public RealizeType(){
        System.out.println("具体原型创建成功!");
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        System.out.println("具体原型复制成功!");
        return (RealizeType)super.clone();
    }
}
public class ProtoTypeMain {
    public static void main(String[] args) throws CloneNotSupportedException {
        RealizeType type = new RealizeType();
        RealizeType    type2 =(RealizeType) type.clone();
        System.out.println(type==type2);//false 说明对象不是同一个
    }
}

参考网址一

参考网址二

参考网址三