Java中的设计模式有哪几种？

Java中一般认为有23种设计模式。总体来说可以分为三大类：

• 1.创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
• 2.结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
• 3.行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

单例模式

一般分为懒汉式，饿汉式等等几种

public class Singleton {
    /***********饿汉式**********/
    /*//直接创建对象
    public static Singleton instance = new Singleton();
    //私有化构造函数
    private Singleton(){}
    //返回对象实例
    public static Singleton getInstance(){
        return instance;
    }*/
    /************懒汉式*********/
    /*//声明对象
    private static Singleton instance = null;
    //私有化构造函数
    private Singleton(){}
    //提供对外方法
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }*/
   /*************双检锁************/

   private static volatile Singleton instance = null;
   private Singleton(){}
   private static Singleton getInstance(){
       if (instance == null){
           synchronized (Singleton.class){
               if (instance == null){
                   instance = new Singleton();
               }
           }
       }
       return instance;
   }
}

工厂设计模式

工厂模式分为工厂方法模式和抽象工厂模式。

工厂方法模式：

工厂方法模式分为三种：

• 普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
• 多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
• 静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

下面是普通工厂模式：

public interface Sender {
    public void send();
}

public class MailSender implements Sender{
    @Override
    public void send() {
        System.out.println("this is mail sender !");
    }
}
public class SmsSender implements Sender{
    @Override
    public void send() {

    }
}
public class SendFactory {
    public Sender produce(String type){
        if ("mail".equals(type)){
            return new MailSender();
        }else {
            return null;
        }
    }
}

多个工厂方法模式：

public class SendFactory {
    /*******多个工厂方法模式*******/
    public Sender produceMail(){
        return new MailSender();
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produceMail();
    }
}

静态工厂方法模式：

public class SendFactory {
    /*****静态工厂方法模式******/
    public static Sender produceMail(){
    }
    public static Sender produceSms(){
        return new SmsSender();
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        Sender sender = SendFactory.produceMail();
        sender.send();
    }
}

抽象工厂模式

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

建造者模式（Builder）

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

适配器模式

适配器模式将某个类的接口转换成客户端期望的另个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

• 类的适配器模式

public class Source {
    public void method1(){
        System.out.println("this is original method !");
    }
}

public interface Targetable {
    //与原类中的方法相同
    public void method1();
    //新类的方法
    public void method2();
}
public class Adapter extends Source implements Targetable{
    @Override
    public void method2() {
        System.out.println("this is targetable method!");
    }
}
public class AdapterTest {
    public static void main(String[] args) {
        Targetable target = new Adapter();
        target.method1();
    }
}

• 对象的适配器模式
  基本思路和类的适配器模式相同，只是将Adapter类做修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。

public class Wrapper implements Targetable{
    private Source source;
    public Wrapper(Source source){
        super();
    }
    @Override
    public void method1() {
        source.method1();
    }
    @Override
    public void method2() {

    }
}


public class AdapterTest {
    public static void main(String[] args) {
        Source source = new Source();
        Targetable target = new Wrapper(source);
        target.method1();
        target.method2();
    }
}

• 接口的适配器模式
  接口的适配器模式是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。

观察者模式（Observer）

观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，意思就是，当你订阅了该文章，如果后续有更新，会及时的通知你。其实，简单来讲就一句话：当一个对象变化时，其他依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。

public interface Observer {
    public void update();
}
public class Observer1 implements Observer{
    @Override
    public void update() {
        System.out.println("Observer1 has received");
    }
}
public class Observer2 implements Observer{
    @Override
    public void update() {

    }
}
public interface Subject {
    //增加观察者
    public void add(Observer observer);
    public void del(Observer observer);
    //通知所有的观察者
    public void notifyObserver();
    //自身的操作
    public void operation();
}

public abstract class AbstractSubject implements Subject{
    private Vector<Observer> vector = new Vector<Observer>();
    @Override
    public void add(Observer observer) {

    }

    @Override
    public void del(Observer observer) {
        vector.remove(observer);
    }

    @Override
    public void notifyObserver() {
        Enumeration<Observer> enumo = vector.elements();
        while (enumo.hasMoreElements()){
            enumo.nextElement().update();
        }
    }
}
public class MySubject extends AbstractSubject{
    @Override
    public void operation() {
        notifyObserver();
    }
}
public class ObserverTest {
    public static void main(String[] args) {
        Subject subject = new MySubject();
        subject.add(new Observer1());
        subject.add(new Observer2());
        subject.operation();
    }
}