Java设计模式

1. 设计模式的理解

刚开始“不懂”为什么要把很简单的东西搞得那么复杂。后来随着软件开发经验的增加才开始明白我所看到的“复杂”恰恰就是设计模式的精髓所在，我所理解的“简单”就是一把钥匙开一把锁的模式，目的仅仅是着眼于解决现在的问题，而设计模式的“复杂”就在于它是要构造一个“万能钥匙”，目的是提出一种对所有锁的开锁方案。在真正理解设计模式之前我一直在编写“简单”的代码.
这个“简单”不是功能的简单，而是设计的简单。简单的设计意味着缺少灵活性，代码很钢硬，只在这个项目里有用，拿到其它的项目中就是垃圾，我将其称之为“一次性代码”。
要想然自己的代码被复用就需要使用设计模式来设计自己的代码。
我们也不能陷入模式的陷阱，为了使用模式而去套模式，那样会陷入形式主义。我们在使用模式的时候，一定要注意模式的意图（intent），而不 要过多的去关注模式的实现细节，因为这些实现细节在特定情况下，可能会发生一些改变。不要顽固地认为设计模式一书中的类图或实现代码就代表了模式本身。

2. 设计模式的分类

总体来说设计模式分为三大类：

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

3. 设计模式的六大原则

• 开闭原则

开闭原则就是说：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔效果。想要达到这样的效果，我们需要使用接口和抽象类。

• 里氏代换原则

任何基类出现的地方，子类一定可以出现。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化。基类与子类的继承关系就是抽象画的具体实现，所以里氏代换原则就是对实现抽象化的具体步骤的规范。

• 依赖倒转原则

这个原则的基础具体内容是：针对接口编程，依赖于抽象而不依赖于具体。

• 接口隔离原则

使用多个隔离的接口，比使用单个接口要好，降低类之间的耦合度。

• 迪米特法则（最少知道原则）

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统模块相对独立。

• 合成复用原则

原则是尽量使用合成/聚合的方式，而不是使用集成。

补充：

1.逻辑代码独立到单独的方法中，注重封装性–易读，易复用。

不要在一个方法中，写下上百行的逻辑代码。把各小逻辑代码独立出来，写于其它方法中，易读其可重复调用。

2.写类，写方法，写功能时，应考虑其移植性，复用性：防止一次性代码！

是否可以拿到其它同类事物中应该？是否可以拿到其它系统中应该？

3.熟练运用继承的思想：

找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；

继承的思想，也方便将自己的逻辑建立于别人的成果之上。如ImageField extends JTextField；

熟练运用接口的思想：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

4. 设计模式：单例模式

Java的单例设计模式要保证一下特点：

• 单例类只能有一个实例

• 单例类必须自己创建自己的唯一实例

• 单例类必须给其他对象提供这一实例

在网上有很多中单利模式的实现方式，这里只减少三种实现单例的方法，一般情况下使用内部类实现的方式。

public class DesignPatterns1 {
    public static void main(String[] args) {
        System.out.print(Singleton.getInstance() == Singleton.getInstance() ? true : false); // true
        System.out.print(Singleton1.getInstance() == Singleton1.getInstance() ? true : false); // true
        System.out.print(Singleton2.getInstance() == Singleton2.getInstance() ? true : false); // true
    }
}

// 懒汉式线程安全的单例(双重锁)
class Singleton {
    private Singleton() {}
    private static Singleton single = null;
    public static Singleton getInstance() {
        if (single == null) {
            synchronized (Singleton.class) {
                if (single == null) {
                   single = new Singleton();
                }
            }
        }
        return single;
    }
}
// 懒汉是式线程安全单例（静态内部类）
class Singleton1 {
    private Singleton1() {}
    private static class LazyHolder {
        private static final  Singleton1 INSTANCE = new Singleton1();
    }
    public static final Singleton1 getInstance() {
        return LazyHolder.INSTANCE;
    }
}
// 饿汉式线程安全单例（耗费资源）
class Singleton2 {
    private Singleton2() {}
    private static final Singleton2 single = new Singleton2();
    public static Singleton2 getInstance() {
        return single;
    }
}

5. 设计模式：工厂方法模式

普通工厂模式

public interface FruitProduct {
    void product();
}

public class AppleProduct implements FruitProduct {
    @Override
    public void product() {
        System.out.println("apple");
    }
}

public class BananaProduct implements FruitProduct {
    @Override
    public void product() {
        System.out.println("banana");
    }
}

public class FruitFactory {
    public FruitProduct product(String type) {
        if ("apple".equals(type)) {
            return new AppleProduct();
        } else if ("banana".equals(type)) {
            return new BananaProduct();
        } else {
            return null;
        }
    }
}

public class Test1 {
    public static void main(String[] args) {
        FruitFactory factory = new FruitFactory();
        FruitProduct product = factory.product("apple");
        product.product();
    }
}

多个工厂方法模式

public interface FruitProduct {
    void product();
}

public class AppleProduct implements FruitProduct {
    @Override
    public void product() {
        System.out.println("apple");
    }
}

public class BananaProduct implements FruitProduct {
    @Override
    public void product() {
        System.out.println("banana");
    }
}

public class FruitFactory1 {
    public FruitProduct productApply() {
        return new AppleProduct();
    }

    public FruitProduct productBanana() {
        return new BananaProduct();
    }
}

public class Test2 {
    public static void main(String[] args) {
        FruitFactory1 factory1 = new FruitFactory1();
        FruitProduct product = factory1.productApply();
        product.product();
    }
}

静态工厂方法模式

public interface FruitProduct {
    void product();
}

public class AppleProduct implements FruitProduct {
    @Override
    public void product() {
        System.out.println("apple");
    }
}

public class BananaProduct implements FruitProduct {
    @Override
    public void product() {
        System.out.println("banana");
    }
}

public class FruitFactory3 {
    public static FruitProduct productApply() {
        return new AppleProduct();
    }

    public static FruitProduct productBanana() {
        return new BananaProduct();
    }
}

public class Test3 {
    public static void main(String[] args) {
        FruitProduct product = FruitFactory3.productApply();
        product.product();
    }
}

6. 设计模式：抽象工厂模式

public interface Sender {
    void send();
}

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

public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("Sms");
    }
}

public interface Provider {
    Sender produce();
}

public class SendMailFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

public class SendSmsFactory implements Provider {
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

public class Test {
    public static void main(String[] args) {
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.send();
    }
}