☀️一张思维图带大家了解Java常见设计模式☀️《❤️记得收藏❤️》

Posted 苏州程序大白

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了☀️一张思维图带大家了解Java常见设计模式☀️《❤️记得收藏❤️》相关的知识，希望对你有一定的参考价值。

☀️一张思维图带大家了解Java常见设计模式☀️《❤️记得收藏❤️》

目录

🏳️‍🌈开讲啦！！！！🏳️‍🌈

🏳️‍🌈1、前言

设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解，本文主要列举了常用的几种设计模式。

🚂2、单例模式

🚃2.1、单例模式的定义与特点

单例（Singleton）模式的定义：

指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

单例模式有 3 个特点：

  • 单例类只有一个实例对象；

  • 该单例对象必须由单例类自行创建；

  • 单例类对外提供一个访问该单例的全局访问点；

🚄2.2、单例模式的结构与实现

单例模式是设计模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

🚅2.3、单例模式的结构

单例模式的主要角色如下：

  • 单例类：包含一个实例且能自行创建这个实例的类。

  • 访问类：使用单例的类。

🚆2.4、单例模式的实现

Singleton 模式通常有两种实现形式。

1 、懒汉式单例

该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下：

public class LazySingleton { private static volatile LazySingleton instance=null; 
 //保证 instance 在所有线程中同步
 private LazySingleton(){} 
 //private 避免类在外部被实例化 
 public static synchronized LazySingleton getInstance() 
{ 
//getInstance 方法前加同步 
if(instance==null) 
{ 
   instance=new LazySingleton();
} 
 return instance; 
 }
 }

注意：如果编写的是多线程程序，则必须有上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。这两个关键字保证了线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

2 、饿汉式单例

该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

public class HungrySingleton 
{ 
private static final HungrySingleton instance=new HungrySingleton();
private HungrySingleton(){} 
public static HungrySingleton getInstance() 
 { 
 return instance;
 } 
 }

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

单例模式的应用实例

用懒汉式单例模式模拟产生董事长对象。

public class SingletonLazy
{ 
public static void main(String[] args) 
{ President zt1=President.getInstance(); zt1.getName(); 
//输出董事长名字 
President zt2=President.getInstance(); zt2.getName(); 
//输出董事长名字 
if(zt1==zt2) 
 { 
System.out.println("他们是同一人！"); 
 } 
else
 { 
System.out.println("他们不是同一人！"); } 
  }
 } 
 class President 
 {
  private static volatile President instance=null; 
  //保证instance在所有线程中同步 
  //private避免类在外部被实例化 
  private President()
   { 
   System.out.println("产生一个董事长！"); 
   } 
   public static synchronized President getInstance() 
   { 
   //在getInstance方法上加同步 if(instance==null)
   { instance=new President(); 
   }
    else 
    { System.out.println("已经有一个董事长，不能产生新董事长！"); }
     return instance; 
    } 
    public void getName() 
    { System.out.println("我是董事长：xxx。"); 
    } 
    }

运行结果：

🚇3、原型模式

🚈3.1、原型模式的定义与特点

原型（Prototype）模式的定义如下：

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。

🚉3.2、原型模式的结构与实现

由于 Java提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。

1、模式的结构：

原型模式包含以下主要角色：

  • 抽象原型类：规定了具体原型对象必须实现的接口。

  • 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。

  • 访问类：使用具体原型类中的 clone() 方法来复制新的对象。

2、 模式的实现

原型模式的克隆分为浅克隆和深克隆，Java 中的 Object 类提供了浅克隆的 clone() 方法，具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆，这里的 Cloneable 接口就是抽象原型类。其代码如下：

//具体原型类 
class Realizetype implements Cloneable 
{ 
Realizetype() { System.out.println("具体原型创建成功！"); 
} 
public Object clone() throws CloneNotSupportedException 
{ 
System.out.println("具体原型复制成功！"); return (Realizetype)super.clone(); 
} 
} 
//原型模式的测试类 
public class PrototypeTest 
  { 
public static void main(String[] args)throws CloneNotSupportedException 
  { 
Realizetype obj1=new Realizetype(); 
Realizetype obj2=(Realizetype)obj1.clone();
System.out.println("obj1==obj2?"+(obj1==obj2));
 }
  }

运行结果：

🚊3.3、原型模式的应用实例

用原型模式生成“三好学生”奖状。

public class ProtoTypeCitation 
{
 public static void main(String[] args) throws CloneNotSupportedException 
 { 
 citation obj1=new citation("小红","同学：在2020学年第一学期中表现优秀，被评为三好学生。","信息学院"); 
 obj1.display(); 
 citation obj2=(citation) obj1.clone(); 
 obj2.setName("小明"); 
 obj2.display(); 
 } 
 } 
 //奖状类 
 class citation implements Cloneable 
 { 
 String name; String info; 
 String college; citation(String name,String info,String college) 
 { 
 this.name=name; this.info=info;
  this.college=college;
   System.out.println("奖状创建成功！");
   } 
   void setName(String name) 
   {
    this.name=name; 
    } 
    String getName()
     { 
    return(this.name);
     } 
     void display() 
     { 
     System.out.println(name+info+college);
      }
       public Object clone() throws CloneNotSupportedException 
       {
        System.out.println("奖状拷贝成功！"); 
        return (citation)super.clone();
         } 
         }

运行结果：

🚝4、工厂方法模式

🚞4.1、工厂方法模式的定义与特点

工厂方法（FactoryMethod）模式的定义：

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点，被创建的对象称为“产品”，把创建产品的对象称为“工厂。

工厂方法模式的主要优点和缺点有：

  • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程

  • 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

  • 其缺点是：每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

🚋4.2、工厂方法模式的结构与实现

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。

1、模式的结构：

工厂方法模式的主要角色如下：

  • 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。

  • 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。

  • 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

2、模式的实现

/** 
* 冰箱接口 
* */ 
public interface IRefrigerator 
{ 
//获取品牌名
 String getBrandName(); 
 //获取价格 
 double getPrice();
  }

/**
 * 冰箱工厂接口
 */
public interface IRefrigeratorFactory {

    IRefrigerator getIRefrigerator();
}
/** * 海尔冰箱 */
 public class HaiErRefrigerator implements IRefrigerator { 
 @Override 
 public String getBrandName() { return "海尔冰箱"; 
 }
 @Override 
 public double getPrice() { return 5999; 
 } 
 } 
 /** * 美的冰箱 */
  public class MeiDiRefrigerator implements IRefrigerator { 
  @Override
  public String getBrandName() { return "美的冰箱";
   } 
    @Override 
    public double getPrice() { return 2999;} 
     } 
     /** * 格力冰箱 */ 
     public class GeLiRefrigerator implements IRefrigerator 
     { 
     @Override 
     public String getBrandName() { 
     return "格力冰箱";
      } 
      @Override
       public double getPrice()
        { 
        return 3999; 
        } 
        }

/** * 海尔冰箱工厂 */ 
public class HaiErRefrigeratorFactory implements IRefrigeratorFactory 
{
 @Override 
 public IRefrigerator getIRefrigerator() 
 { 
 return new HaiErRefrigerator(); 
 } 
 } 
 /** * 美的冰箱工厂 */ 
 public class MeiDiRefrigeratorFactory implements IRefrigeratorFactory { 
 @Override 
 public IRefrigerator getIRefrigerator() { 
 return new MeiDiRefrigerator(); 
 } 
 }
  /** * 格力冰箱工厂 */
   public class GeLiRefrigeratorFactory implements IRefrigeratorFactory 
   { 
   @Override
   public IRefrigerator getIRefrigerator() 
   { 
   return new GeLiRefrigerator(); 
   } 
   }
/** * 测试类 */ 
public class Test { 
public static void main(String[] args) 
{ 
IRefrigeratorFactory refrigeratorFactory = new HaiErRefrigeratorFactory(); 
IRefrigeratorFactory refrigeratorFactory2 = new GeLiRefrigeratorFactory();
 IRefrigeratorFactory refrigeratorFactory3 = new MeiDiRefrigeratorFactory(); 
 IRefrigerator refrigerator = refrigeratorFactory.getIRefrigerator();

 System.out.println("您购买了：" + refrigerator.getBrandName() + "，您需要支付：" + refrigerator.getPrice()); 
 }
  }

运行结果：

🚌5、抽象工厂模式

🚍5.1、抽象工厂模式的定义与特点

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件。

系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。

🚎5.2、抽象工厂模式的结构与实现

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。

1、抽象工厂模式的结构

抽象工厂模式的主要角色如下：

  • 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。

  • 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。

  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。

  • 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。

2、抽象工厂模式的实现

  • 1、抽象工厂：提供了产品的生成方法。
interface AbstractFactory
{
    public Product1 newProduct1();
    public Product2 newProduct2();
}
  • 2、具体工厂：实现了产品的生成方法。
class ConcreteFactory1 implements AbstractFactory 
{
 public Product1 newProduct1()
  { 
  System.out.println("具体工厂 1 生成-->具体产品 11..."); 
  return new ConcreteProduct11(); 
  } 
  public Product2 newProduct2()
   { 
   System.out.println("具体工厂 1 生成-->具体产品 21...");
    return new ConcreteProduct21();
     } 
     }
  • 3、抽象工厂模式的应用实例
/** * 为形状创建一个接口 */
 public interface Shape 
 {
  void draw(); 
  } 
  ** * 为颜色创建一个接口 */ 
  public interface Color 
  { 
  void fill();
   }
/** * 创建实现接口的实体类 */ 
public class Rectangle implements Shape 
{
 @Override 
 public void draw() 
 {
 System.out.println("Inside Rectangle::draw() method."); 
 }
 } 
 public class Square implements Shape
  {
   @Override 
   public void draw() { 
   System.out.println("Inside Square::draw() method."); 
   } 
   } 
   public class Circle implements Shape
   { 
   @Override
   public void draw()
     { 
     System.out.println("Inside Circle::draw() method.");
     } 
     } 
     /** * 创建实现接口的实体类 */
      public class Red implements Color 
      {
       @Override
        public void fill() 
        { 
        System.out.println("Inside Red::fill() method.");   } 
        }
         public class Green implements Color 
         { 
         @Override
          public void fill() { 
          System.out.println("Inside Green::fill() method.");  } 
          } 
          public class Blue implements Color 
          {
           @Override public void fill() 
           { 
           System.out.println("Inside Blue::fill() method."); 
           } 
           }
/** * 为 Color 和 Shape 对象创建抽象类来获取工厂 */ 
interface AbstractFactory 
{ 
 public Color getColor(String color);
 public Shape getShape(String shape) ;
  }
/** * 创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象 */ 
public class ShapeFactory extends AbstractFactory {
 @Override 
 public Shape getShape(String shapeType){ 
 if(shapeType == null){ 
 return null; 
 } 
 if(shapeType.equalsIgnoreCase("CIRCLE")){
  return new Circle(); 
  } 
  else if(shapeType.equalsIgnoreCase("RECTANGLE"))
  {
  return new Rectangle(); }
   else if(shapeType.equalsIgnoreCase("SQUARE"))
   {
    return new Square
以上是关于☀️一张思维图带大家了解Java常见设计模式☀️《❤️记得收藏❤️》的主要内容，如果未能解决你的问题，请参考以下文章
 

 Midjourney? 文心一格? 一张思维导图带你了解图片生成AI


 ☀️大白话学习JVM☀️（02）| 2张图带你彻底弄懂面试必问类加载


 ☀️大白话学习JVM☀️（02）| 2张图带你彻底弄懂面试必问类加载


 ❤️思维导图整理大厂面试高频数组13: 3种方法彻底解决最大子序和问题, 了解线段树的思想, 力扣53❤️


 ❤️思维导图整理大厂面试高频数组13: 3种方法彻底解决最大子序和问题, 了解线段树的思想, 力扣53❤️


 就够了