JAVA中的几个设计模式

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

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

在这篇文章主要对其中的工厂模式，单例设计模式，适配器模式，装饰器模式进行介绍，剩下的会在后期进行更新。

---

1.工厂设计模式
在这里先介绍一下简单工厂设计模式，也就是在需要创建多个不同类对象的时候，直接用一个工厂类来创建，而不是通过手动去创建，可以更加明确各个类的职责，但是这样做的话如果新增不同的类，那么久要修改工厂中的代码，不利于维护。
示例代码

public class AnimalFactory {
    public static Animal createAnimal(String name) {
        if("dog".equals(name)) {
            return new Dog();
        }else if("cat".equals(name)) {
            return new Cat();
        }else {
            return null;
        }
    }
}
public class Test {
    public static void main(String[] args) {    
    //这里之所以要加强制类型转换是因为创建方法的返回类型是将对象作为Animal类型返回的，属于多态的一种，需要强制转换成另一种属性   
        Dog d = (Dog) AnimalFactory.createAnimal("dog");
        d.eat();

        Cat c = (Cat) AnimalFactory.createAnimal("cat");
        c.eat();
    }

}

接下来谈一谈工厂设计模式，工厂设计模式是创建一个工厂接口，然后让不同的工厂类来继承该接口，最后用相应的工厂类来创建相应的对象，工厂类解决了简单工厂类不方便维护的问题，不过也会增加代码量和工作量。

示例代码

//创建一个工厂接口
public interface Factory {
    public Animal createAnimal();
}   

//相应的工厂类
public class CatFactory implements Factory {

    @Override
    public Animal createAnimal() {

        return new Cat();
    }
}

public class DogFactory implements Factory {

    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}
//这里的强转和上面的原理类似，主要是因为方法是将对象以多态中的另一种状态返回的，我们用一种特定类型的变量来接收，所以需要强转成相同的状态
public class Test {
    public static void main(String[] args) {
        DogFactory df = new DogFactory();
        Dog d = (Dog) df.createAnimal();
        d.eat();
    }
}

---

2.单例设计模式
所谓的单例设计模式，顾名思义也就是在代码中让某些类只存在一个对象的设计模式，其中单例设计模式有两种方法，一种是饿汉式，另外一种是懒汉式，下面分别就这两种方法进行介绍

1.饿汉式
这也是开发常用的一种方法，本质上是将构造方法私有化，在类里面创建一个新的该类对象，然后给予外界一个公共的访问方式，这样无论外界多少次调用该方法，都只会访问到在类内部创建的那个对象（因为JAVA不会重复地去创建对象，如果检测到该对象已经存在，那么便不会再去创建新的对象，只是多了一个指向该对象的指针），也就保证了每个类只会有一个对象的存在

class Singleton {
    //1,私有构造方法,其他类不能访问该构造方法了
    private Singleton(){}
    //2,创建本类对象
    private static Singleton s = new Singleton();
    //3,对外提供公共的访问方法
    public static Singleton getInstance() {             //获取实例
        return s;
    }
}

public class Demo {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();     
        System.out.println(s1 == s2);//在这里比较的是两个对象的地址，结果为True，因为指向的都是s
    }
}

2.懒汉式

class Singleton {
    //1,私有构造方法,其他类不能访问该构造方法了
    private Singleton(){}
    //2,创建本类对象
    private static Singleton s;
    //3,对外提供公共的访问方法
    public static Singleton getInstance() { 
    //先判断是否为null再创建新的对象，相比上面一来就直接创建更节省资源，但是这样会遇到多线程的问题，不建议使用，一般还是使用上面的方法
        if(s==null)   
            s=new Singleton();
        return s;
    }
}

---

3.装饰设计模式
装饰设计模式顾名思义，就是用一种类将某些对象作为构造参数传递，对其进行装饰，使其具有原本没有的属性，其好处是耦合性不强，被装饰的类的变化与进行装饰的类的变化无关。
示例代码

public class Demo {
    public static void main(String[] args) {
        NewStudent ns = new NewStudent(new Student());
        ns.code();
    }

}
//创建一个接口
interface Coder {
    public void code();
}
//新创建一个类应用上面的接口并且重写里面的方法
class Student implements Coder {
    @Override
    public void code() {
        System.out.println("javase");
        System.out.println("javaweb");
    }   
}

class NewStudent implements Coder {
    private Student s;                  
    //在构造方法中传入被装饰类的对象
    public NewStudent(Student s) {
        this.s = s;
    }

    //对原有的功能进行升级
    @Override
    public void code() {
        s.code();
        System.out.println("数据库");
        System.out.println("大数据");
        System.out.println("...");
    }
}