java常用设计模式

一、单例模式

1、将采用单例设计模式的类的构造方法私有化（采用private修饰）；
2、在其内部产生该类的实例化对象，并将其封装成private static类型；
3、定义一个静态方法返回该类的实例。

示例代码如下：

class Singleton {  
    private static Singleton instance = new Singleton();// 在内部产生本类的实例化对象 
    public static Singleton getInstance() { // 通过静态方法返回instance对象 
        return instance;  
    }  
   
    private Singleton() { // 将构造方法封装为私有化 
    }  
   
    public void print() {  
        System.out.println("Hello World!!!");  
    }  
}  
   
public class SingletonDemo {  
    public static void main(String args[]) {  
        Singleton s1 = null; // 声明对象 
        Singleton s2 = null; // 声明对象 
        Singleton s3 = null; // 声明对象 
        s1 = Singleton.getInstance(); // 取得实例化对象 
        s2 = Singleton.getInstance(); // 取得实例化对象 
        s3 = Singleton.getInstance(); // 取得实例化对象 
        s1.print(); // 调用方法  
        s2.print(); // 调用方法  
        s3.print(); // 调用方法  
    }  
} 

单例模式的实现有如下四种：
(1)非线程安全

/** 
 * 单例模式的实现：非线程安全  
 *  
 */ 
public class SingletonTest {  
    private SingletonTest() {  
    }  
    private static SingletonTest instance;  
    public static SingletonTest getInstance() {  
        if (instance == null)  
            instance = new SingletonTest();  
        return instance;  
    }  
} 

(2)线程安全，效率非常低

/** 
 * 线程安全，但是效率非常低 
 * 
 */ 
public class SingletonTest {  
    private SingletonTest() {  
    }  
    private static SingletonTest instance;  
    public static synchronized SingletonTest getInstance() {  
        if (instance == null)  
            instance = new SingletonTest();  
        return instance;  
    }  
} 

(3)线程安全，效率高

/** 
 *  
 * 单例模式的实现：线程安全 调用效率高 
 */ 
public class SingletonTest {  
    private SingletonTest() {  
    }  
    // 类初始化时，立即加载这个对象（没有延迟加载的优势），加载类时，天然的线程安全
    private static final SingletonTest instance = new SingletonTest();  
    // 方法不用同步，调用效率高
    public static SingletonTest getInstancei() {  
        return instance;  
    }  
} 

(4)线程安全，效率高

/** 
 * 线程安全  并且效率高 
 * 
 */ 
public class SingletonTest {  
    private static SingletonTest instance;  
    private SingletonTest() {  
    }  
    public static SingletonTest getIstance() {  
        if (instance == null) {  
            synchronized (SingletonTest.class) {  
                if (instance == null) {  
                    instance = new SingletonTest();  
                }  
            }  
        }  
        return instance;  
    }  
} 

二、工厂模式

通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

interface Animal { // 定义一个动物的接口 
    public void say(); // 说话方法 
}  
   
class Cat implements Animal { // 定义子类Cat 
    @Override 
    public void say() { // 覆写say()方法 
        System.out.println("我是猫咪，喵呜！");  
    }  
}  
   
class Dog implements Animal { // 定义子类Dog 
   
    @Override 
    public void say() { // 覆写say()方法 
        System.out.println("我是小狗，汪汪！");  
    }  
}  
   
class Factory { // 定义工厂类 
    public static Animal getInstance(String className) {  
        Animal a = null; // 定义接口对象 
        if ("Cat".equals(className)) { // 判断是哪个子类的标记 
            a = new Cat(); // 通过Cat子类实例化接口 
        }  
        if ("Dog".equals(className)) { // 判断是哪个子类的标记 
            a = new Dog(); // 通过Dog子类实例化接口 
        }  
        return a;  
    }  
}  
   
public class FactoryDemo {  
   
    public static void main(String[] args) {  
        Animal a = null; // 定义接口对象 
        a = Factory.getInstance(args[0]); // 通过工厂获取实例 
        if (a != null) { // 判断对象是否为空 
            a.say(); // 调用方法  
        }  
    }  
} 

三、适配器模式

适配器就是一种适配中间件，它存在于不匹配的二者之间，用于连接二者，将不匹配变得匹配，简单点理解就是平常所见的转接头，转换器之类的存在。
　　适配器模式有两种：类适配器、对象适配器、接口适配器

四、原型模式

在开发过程中，有时会遇到为一个类创建多个实例的情况，这些实例内部成员往往完全相同或有细微的差异，而且实例的创建开销比较大或者需要输入较多参数，如果能通过复制一个已创建的对象实例来重复创建多个相同的对象，这就可以大大减少创建对象的开销，这个时候就需要原型模式。

参考资料：
https://www.cnblogs.com/tytr/p/6119573.html
https://blog.csdn.net/wmq880204/article/details/75106848