设计模式自身一直不是很了解, 但其实我们时刻都在使用这些设计模式的, java 有 23 种设计模式和 6 大原则.
设计模式是一套被反复使用, 多数人知晓的, 经过分类编目的, 代码设计经验的总结. 使用设计模式是为了可重用代码, 让代码更容易被他人理解, 保证代码可靠性, 程序的重用性.
其中包含
创建型模式, 共五种: 单例模式, 工厂方法模式, 抽象工厂模式, 建造者模式, 原型模式.
结构型模式, 共七种: 适配器模式, 装饰器模式, 代理模式, 外观模式, 桥接模式, 组合模式, 享元模式.
行为型模式, 共十一种: 策略模式, 模板方法模式, 观察者模式, 迭代子模式, 责任链模式, 命令模式, 备忘录模式, 状态模式, 访问者模式, 中介者模式, 解释器模式.
我们今天就来说说我们的创建型模式
单例模式: 是 Java 中最简单的设计模式之一. 它提供了一种创建对象的最佳方式.
这种模式涉及到一个单一的类, 该类负责创建自己的对象, 同时确保只有单个对象被创建. 这个类提供了一种访问其唯一的对象的方式, 可以直接访问, 不需要实例化该类的对象.
用一种其它的方式来记忆吧, 单例模式犹如我们吃的土豆, 只有一个土豆, 你叫他土豆也行, 叫他马铃薯也可以, 还可以叫 Potato, 但最终还是那一个土豆.
注意:
1, 单例类只能有一个实例.
2, 单例类必须自己创建自己的唯一实例.
3, 单例类必须给所有其他对象提供这一实例.
代码实现:
饿汉式单例模式:
- package Single;
- public class CarBean {
- public static CarBean carBean = new CarBean();
- private String name;
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- // 关闭构造方法. 防止 New 对象
- private CarBean() {
- System.out.println("CarBean 构造方法只走一次");
- }
- public static CarBean getInstance() {
- return carBean;
- }
- }
- package Single;
- public class MainTest {
- /**
- * 饿汉式静态常量式单例模式
- * 优点: 这种写法在 JVM 装载类的时候就实例化了, 避免了线程同步的问题
- * 缺点: 在类装载的时候就实例化, 没有达到延时加载的效果, 造成内存浪费
- * @param args
- */
- public static void main(String[] args) {
- CarBean car1 = CarBean.getInstance();
- CarBean car2 = CarBean.getInstance();
- car1.setName("兰博基尼");
- car2.setName("玛莎拉蒂");
- System.out.println(car1.getName());
- System.out.println(car2.getName());
- }
- }
懒汉式单例模式 (非同步):
- package Single2;
- public class CarBean {
- public static CarBean carBean = null;
- private String name;
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- // 关闭构造方法. 防止 New 对象
- private CarBean() {
- System.out.println("CarBean 构造方法只走一次");
- }
- public static CarBean getInstance() {
- if(carBean == null) {
- carBean = new CarBean();
- }
- return carBean;
- }
- }
- package Single2;
- public class MainTest {
- /**
- * 懒汉式单例模式: 非同步
- * 优点: 在调用的时候初始化该单例
- * 缺点: 并非线程同步, 不建议使用
- * @param args
- */
- public static void main(String[] args) {
- CarBean car1 = CarBean.getInstance();
- CarBean car2 = CarBean.getInstance();
- car1.setName("兰博基尼");
- car2.setName("玛莎拉蒂");
- System.out.println(car1.getName());
- System.out.println(car2.getName());
- }
- }
懒汉式单例模式 (同步):
- package Single3;
- public class CarBean {
- public static CarBean carBean = null;
- private String name;
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- // 关闭构造方法. 防止 New 对象
- private CarBean() {
- System.out.println("CarBean 构造方法只走一次");
- }
- /**
- * 方法 1
- * 该方式使用 synchronized 同步锁将整个方法同步 实现线程同步 但同步整个方法在高并发的情况下会造成阻塞效率低下
- * 不推荐使用
- * @return
- */
- public static synchronized CarBean getInstance1() {
- if (carBean == null) {
- carBean = new CarBean();
- }
- return carBean;
- }
- /**
- * 方法 2 使用 synchronized 同步实例化改单例的代码块; 但该方法不能完全实现同步, 可能会产生多个实例;
- * 例如: 在第一次创建时多个线程同时进入 if(lazySingleton == null) 则会产生多个实例
- * 不推荐使用
- * @return
- */
- public static CarBean getInstance2() {
- if (carBean == null) {
- synchronized (CarBean.class) {
- carBean = new CarBean();
- }
- }
- return carBean;
- }
- /**
- * 方法 3: 双重检查法, 同步代码块中再次检查一次是否 w 为 null 解决了上述问题 推荐使用
- */
- public static CarBean getInstance3() {
- if (carBean == null) {
- synchronized (CarBean.class) {
- if (carBean == null) {
- carBean = new CarBean();
- }
- }
- }
- return carBean;
- }
- }
里面具体的优缺点我都写在代码注释里了.
后面会把每一个模式都写一次.
来源: https://www.cnblogs.com/cxiaocai/p/11572564.html