你所知道的java设计模式有哪些？我来给你讲常用的

• 你所知道的设计模式有哪些

Java中一般认为有23 种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面写出了所有的设计模式。但需要掌握的设计模式我单独用代码写出来了，当然能掌握的越多越好（一般只需要用一些常用的即可）。
总体来说设计模式分为三大类：

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

单列模式
最好理解的一种设计模式，分为懒汉式和饿汉式。

    //饿汉式：
    public class Singleton {
        //直接创建对象
        public static Singleton instance = new Singleton();

        //私有化构造函数 
        private Singleton() {
        }

        //返回对象实例 
        public static Singleton getInstance() {
            return instance;
        }
    }

     //懒汉式：
    public class Singleton {
        // 声明变量
        private static volatile Singleton singleton = null;
        // 私有构造函数
        private Singleton() { }
        // 提供对外方法
        public static Singleton getInstance() {
            if (singleton == null) {
                if (singleton == null) {
                }
            }
            return singleton;
        }

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

    public interface Sender {
        public void Send();
    }

 public class MailSender implements Sender {
          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();
            return new SmsSender();
        } else {
            return null;
        }
    }

多个工厂方法模式
该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

//接口
public interface Sender {
    //自定义方法描述发送的行为
    void send();
}

//实现接口1
public class MailSender implements Sender{
    @Override
    public void send() {
        System.out.println("发送1...");
    }
}

//实现接口2
public class SmsSender implements Sender{
    @Override
    public void send() {
        System.out.println("发送2...");
    }
}

//工厂类
public class SendFactory {
   
    public Sender produceMail() {
        return new MailSender();
    }
    public Sender produceSms() {
        return new SmsSender();
    }
    return null;
}

静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class SendFactory {
        public Sender produceMail() {
            return new MailSender();
        }
  return new SmsSender();
    }
}

public class FactoryTest {
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produceMail();
    }
}

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

建造者模式（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 the 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 method2() {
        }

        @Override
        public void method1() {
            source.method1();
        }

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 notifyObservers();

        /*自身的操作*/
        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 notifyObservers() {
        Enumeration<Observer> enumo = vector.elements();
        while (enumo.hasMoreElements()) {
            enumo.nextElement().update();
        }
    }
}

public class MySubject extends AbstractSubject {
    @Override
    public void operation() {
        notifyObservers();
    }
}

public class ObserverTest {
    public static void main(String[] args) {
        Subject sub = new MySubject();
        sub.add(new Observer1());
        sub.add(new Observer2());
        sub.operation();
    }
}