KS1_S11_单例模式

最新推荐文章于 2022-10-06 10:10:24 发布
最新推荐文章于 2022-10-06 10:10:24 发布
阅读量153 收藏
点赞数
分类专栏： 11_源码探究and设计模式 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZhouD_Sir/article/details/117885066
版权

2021-06-13_KS1_S11_单例模式

18、彻底玩转单例模式

需要了解的知识：饿汉式、DCL懒汉式，深究：单例模式、枚举

1、饿汉式单例，代码

  1. // 饿汉式单例
public class HungrySingleton {
    // 可能会浪费空间
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];

    // 构造器私有化——只要是单例模式
    private HungrySingleton() {
    }

    private final static HungrySingleton HUNGRYSINGLETON = new HungrySingleton();

    public static HungrySingleton getInstance() {
        return HUNGRYSINGLETON;
    }
}

2、DCL_懒汉式单例，代码：

1. 普通懒汉单例模式

  1. 懒汉式单例_基础版本：单线程中OK

    // 懒汉式单例_基础版本：单线程中OK
public class LazyMan_01 {
    
    // 构造器私有化
    private LazyMan_01() {
        System.out.println(Thread.currentThread().getName() +"OK");
    }

    // 提供一个实例，但并不创建对象
    private static LazyMan_01 lazyMan_01;

    private static LazyMan_01 getInstance() {
        if (lazyMan_01 == null) {
            lazyMan_01 = new LazyMan_01();
        }

        return lazyMan_01;
    }
	/* 懒汉式单例_基础版本：单线程中OK */
    public static void main(String[] args) {
            LazyMan_01 instance1 = LazyMan_01.getInstance();
            LazyMan_01 instance2 = LazyMan_01.getInstance();
            LazyMan_01 instance3 = LazyMan_01.getInstance();
            LazyMan_01 instance4 = LazyMan_01.getInstance();
            LazyMan_01 instance5 = LazyMan_01.getInstance();

            System.out.println(instance1.hashCode());
            System.out.println(instance2.hashCode());
            System.out.println(instance3.hashCode());
            System.out.println(instance4.hashCode());
            System.out.println(instance5.hashCode());
    }
}

  2. 懒汉式单例_基础版本：单线程下普通懒汉单例模式OK，但在多线程并发下有问题（暴露问题：但在多线程并发下有问题）

    // 懒汉式单例_基础版本：单线程下普通懒汉单例模式OK，但在多线程并发下有问题（**暴露问题**：但在多线程并发下有问题）
public class LazyMan_01 {

    // 构造器私有化
    private LazyMan_01() {
        System.out.println(Thread.currentThread().getName() +"OK");
    }

    // 提供一个实例，但并不创建对象
    private static LazyMan_01 lazyMan_01;

    private static LazyMan_01 getInstance() {
        if (lazyMan_01 == null) {
            lazyMan_01 = new LazyMan_01();
        }

        return lazyMan_01;
    }

    /* 懒汉单例OK:多线程并发下的问题暴露 */
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                LazyMan_01.getInstance();
            }).start();
        }
    }
}
2. 懒汉式单例_DCL

  1. 懒汉式单例_DCL（解决问题：多线程并发下的懒汉问题1；暴露问题：但在多线程并发下有指令重排问题）

    懒汉式单例_DCL（**解决问题**：多线程并发下的懒汉问题1；**暴露问题**：但在多线程并发下有指令重排问题）
public class LazyMan_02 {
    // 构造器私有化
    private LazyMan_02() {
        System.out.println(Thread.currentThread().getName() +"OK");
    }

    // 提供一个实例，但并不创建对象
    private static  LazyMan_02 lazyMan_02;
    
     /* 
     	不是原子性操作：
           1.分配内存空间
           2.执行构造方法，初始化对象
           3.把这个对象指向这个空间
           123
           321 A——指令重排
               B——此时插入 lazyManSingleton 还没有完成构造
    */
    // 双层检测锁模式——DCL懒汉懒汉模式
    private static LazyMan_01 getInstance() {
        if (lazyMan_01 == null) {
            lazyMan_01 = new LazyMan_01();
        }

        return lazyMan_01;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                LazyMan_02.getInstance();
            }).start();
        }
    }
}

  2. 懒汉式单例_DCL（解决问题：解决多线程并发下指令重排问题）

    // 提供一个实例，但并不创建对象。volatile：对于同一个变量，在一个线程中值发生了改变，则在另一个线程中立即生效，可以大幅度避免线程重排的问题，但不排除极端情况
private volatile static  LazyMan_02 lazyMan_02;

  3. 懒汉式单例_DCL（暴露问题：用反射能够破坏单例模式1）

    // 懒汉式单例_DCL（**暴露问题**：用反射能够破坏单例模式1）
public class LazyMan_03 {

    // 构造器私有化
    private LazyMan_03() {
        System.out.println(Thread.currentThread().getName() +"OK");
    }

    // 提供一个实例，但并不创建对象。volatile：对于同一个变量，在一个线程中值发生了改变，则在另一个线程中立即生效，可以大幅度避免线程重排的问题，但不排除极端情况
    private volatile static LazyMan_03 lazyMan_03;

    // 双层检测锁模式——DCL懒汉懒汉模式
    private static LazyMan_03 getInstance() {
        if (lazyMan_03 == null) {
            synchronized (LazyManSingleton.class) {
                if (lazyMan_03 == null) {
                    lazyMan_03 = new LazyMan_03();
                }
            }
        }
        return lazyMan_03;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        LazyMan_03 instance1 = LazyMan_03.getInstance();

        Constructor<LazyMan_03> declaredConstructor = LazyMan_03.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan_03 instance2 = declaredConstructor.newInstance();

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
        System.out.println(instance1 == instance2);
    }
}

  4. 懒汉式单例_DCL（解决问题：通过在无参构造中加锁，解决反射破坏单例模式1）

    // 构造器私有化
private LazyMan_03() {
    synchronized (LazyMan_03.class) {
        if (lazyMan_03 != null) {
            throw new RuntimeException("异常：不要试图使用反射破坏");
        }
    }
    System.out.println(Thread.currentThread().getName() +"OK");
}

  5. 懒汉式单例_DCL（暴露问题：用反射能够进一步破坏单例模式2）

    // 懒汉式单例_DCL（**暴露问题**：用反射能够进一步破坏单例模式2）
public class LazyMan_04 {
    // 构造器私有化
    private LazyMan_04() {
        synchronized (LazyMan_04.class) {
            if (lazyMan_04 != null) {
                throw new RuntimeException("异常：不要试图使用反射破坏");
            }
        }
        System.out.println(Thread.currentThread().getName() +"OK");
    }

    // 提供一个实例，但并不创建对象。volatile：对于同一个变量，在一个线程中值发生了改变，则在另一个线程中立即生效，可以大幅度避免线程重排的问题，但不排除极端情况
    private volatile static LazyMan_04 lazyMan_04;

    // 双层检测锁模式——DCL懒汉懒汉模式
    private static LazyMan_04 getInstance() {
        if (lazyMan_04 == null) {
            synchronized (LazyManSingleton.class) {
                if (lazyMan_04 == null) {
                    lazyMan_04 = new LazyMan_04();
                }
            }
        }
        return lazyMan_04;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        Constructor<LazyMan_04> declaredConstructor = LazyMan_04.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan_04 instance1 = declaredConstructor.newInstance();
        LazyMan_04 instance2 = declaredConstructor.newInstance();

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
        System.out.println(instance1 == instance2);
    }
}

  6. 懒汉式单例_DCL（解决问题：用反射能够进一步破坏单例模式2）

    懒汉式单例_DCL（**解决问题**：用反射能够进一步破坏单例模式2）
public class LazyMan_04 {

    private static boolean zhout = false;

    // 构造器私有化
    private LazyMan_04() {
        synchronized (LazyMan_04.class) {
            if (zhout) {
                zhout = true;
            } else {
                throw new RuntimeException("异常：不要试图使用反射破坏");
            }
        }
        System.out.println(Thread.currentThread().getName() +"OK");
    }

    // 提供一个实例，但并不创建对象。volatile：对于同一个变量，在一个线程中值发生了改变，则在另一个线程中立即生效，可以大幅度避免线程重排的问题，但不排除极端情况
    private volatile static LazyMan_04 lazyMan_04;

    // 双层检测锁模式——DCL懒汉懒汉模式
    private static LazyMan_04 getInstance() {
        if (lazyMan_04 == null) {
            synchronized (LazyManSingleton.class) {
                if (lazyMan_04 == null) {
                    lazyMan_04 = new LazyMan_04();
                }
            }
        }
        return lazyMan_04;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<LazyMan_04> declaredConstructor = LazyMan_04.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan_04 instance1 = declaredConstructor.newInstance();
        LazyMan_04 instance2 = declaredConstructor.newInstance();

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
        System.out.println(instance1 == instance2);
    }
}

  7. 懒汉式单例_DCL（暴露问题：用反射能够进二步破坏单例模式3）

    // 懒汉式单例_DCL（**暴露问题**：用反射能够进二步破坏单例模式3）
public class LazyMan_05 {

    private static boolean zhout = false;

    public static boolean isZhout() {
        return zhout;
    }

    // 构造器私有化
    private LazyMan_05() {
        synchronized (LazyMan_05.class) {
//            if (lazyMan_05 != null) {
            if (zhout) {
                throw new RuntimeException("异常：不要试图使用反射破坏");
            } else {
                zhout = true;
            }
//            }
        }
        System.out.println(Thread.currentThread().getName() +"OK");
    }

    // 提供一个实例，但并不创建对象。volatile：对于同一个变量，在一个线程中值发生了改变，则在另一个线程中立即生效，可以大幅度避免线程重排的问题，但不排除极端情况
    private volatile static LazyMan_05 lazyMan_05;

    // 双层检测锁模式——DCL懒汉懒汉模式
    private static LazyMan_05 getInstance() {
        if (lazyMan_05 == null) {
            synchronized (LazyManSingleton.class) {
                if (lazyMan_05 == null) {
                    lazyMan_05 = new LazyMan_05();
                }
            }
        }
        return lazyMan_05;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {

        Constructor<LazyMan_05> declaredConstructor = LazyMan_05.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan_05 instance1 = declaredConstructor.newInstance();

        Field zhout = LazyMan_05.class.getDeclaredField("zhout");
        zhout.setAccessible(true);
        zhout.set(instance1, false);

        LazyMan_05 instance2 = declaredConstructor.newInstance();

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
        System.out.println(instance1 == instance2);
    }
}

3、枚举类的单例

  1. 反射无法破坏枚举的单例

    1. 创建枚举类：

      public enum  EnumSingleton {

    INSTANCE;

    public EnumSingleton getInstance() {
        return INSTANCE;
    }
}

    2. 创建测试类：报错=java.lang.NoSuchMethodException: com.zhout.single_zhout.EnumSingleton.()

      class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingleton instance = EnumSingleton.INSTANCE;

        Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingleton instance2 = declaredConstructor.newInstance();

        // java.lang.NoSuchMethodException: com.zhout.single_zhout.EnumSingleton.<init>()
        System.out.println(instance);
        System.out.println(instance2);
    }
}

    3. javap -p 反编译（查看IDEA的target）

      E:\singleton-model\target\classes\com\zhout\single>javap -p EnumSingleton.class
Compiled from "EnumSingleton.java"
public final class com.zhout.single.EnumSingleton extends java.lang.Enum<com.zhout.single.EnumSingleton> {
  public static final com.zhout.single.EnumSingleton INSTANCE;
  private static final com.zhout.single.EnumSingleton[] $VALUES;
  public static com.zhout.single.EnumSingleton[] values();
  public static com.zhout.single.EnumSingleton valueOf(java.lang.String);
  private com.zhout.single.EnumSingleton();
  public com.zhout.single.EnumSingleton getInstance();
  static {};
}

    4. javap -p 反编译结果图

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4tcK2sXv-1623586465778)(…/…/KS1_Step11_%E6%BA%90%E7%A0%81%E6%8E%A2%E7%A9%B6and%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/KS1_S11_%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F/KS1_S11_%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F.assets/1623572008472.png)]

    5. 最后用专业工具jad进行反编译，发现枚举类的构造函数入参有两个值(String.class,int.class);

    6. 更新测试类：

      class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingleton instance = EnumSingleton.INSTANCE;

        Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingleton instance2 = declaredConstructor.newInstance();

        // java.lang.NoSuchMethodException: com.zhout.single_zhout.EnumSingleton.<init>()
        System.out.println(instance);
        System.out.println(instance2);
    }
}

    7. 输出报错信息：枚举类不能被反射实例化

      Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)

    8. newInstance的源码

      if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");

    9. 小结：反射无法破坏枚举的单例

4、静态内部类

  1. 静态内部类——因为反射也不是安全的

    // 静态内部类——因为反射也不是安全的
public class Holder {

    //  构造器私有化——只要是单例模式
    private Holder() {

    }

    public static Holder getInstance() {
        return TheInnerClass.HOLDER;
    }

    public static class TheInnerClass {
        private static final Holder HOLDER = new Holder();
    }
}
ZhouD_Sir
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
谱半径一定大于0_S11大于0怎么回事
weixin_30667831的博客
12-30 1022
用HFSS仿真天线时的S11时，算出来的值大于0是怎么回事呀？S11应该是反射功率与入射功率的比值的dB形式吧！大于0就表示反射的比入射的功率还大，不可能吧，怎么回事呀？哪位高人可以指点一下呀？好像不是dB吧只是一个比值而已0到1之间你找本微波工程看下我就是看那个里面有才借的你的参考阻抗是复数的话，s11可能会大于1，帮助文档里有，你可以看一下HFSS帮助中有这么一段话：When the refe...
C++ 线程安全的单例模式总结
s11show_163的博客
01-21 850
1. 什么是线程安全？ 在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。 2. 如何保证线程安全？ 给共享的资源加把锁，保证每个资源变量每时每刻至多被一个线程占用。 让线程也拥有资源，不用去共享进程中的资源。如： 使用threadlocal可以为每个线程的维护一个私有的本地变量。 3. 什么是单例模式？ 单例模式指在整个系统生命周期里，保证一个类只能产生一个实例，确保该类的唯一性。 3.1. 单例模式分类 单例模式可以分为
设计模式之单例模式（java）
未见山的博客
01-14 186
单例模式 概念： 一个系统中只有一个类的实例对象可以被获取和使用（且该实例对象是自行创建的）。单例模式分为饿汉式和懒汉式两种。 饿汉式： 直接创建实例对象，线程安全。 1. 枚举类 package com.sk.singleton; public enum Singleton { INSTANCE } 2. 直接实例化（两种对外提供实例的方式） package com.sk.singleton; public class Singleton { public static fina
设计模式之单例模式
qq1156148707的博客
10-06 87
static设计模式应用
单例模式线程安全版
m0_53658634的博客
08-09 43
代码】单例模式线程安全版。
01单例模式
hcwdd的博客
01-10 130
单例模式有五种实现方式 饿汉式–线程安全，调用效率高，不能延迟加载 懒汉式–线程安全，调用效率低，可以延迟加载 双重检测锁–线程安全，同时具备调用效率高和可以延迟加载的优点，但是由于底层原因，偶尔会出现问题，不建议使用 静态内部类–线程安全，调用效率高，同时可以延迟加载 枚举类–线程安全，调用效率高，不支持延迟加载 /** * 饿汉式 */ public class SingletonDemo1 { // 构造器私有化 private SingletonDemo1() { }
【编程素质】设计模式-单例模式（Singleton pattern）
午后阳光
07-25 579
1，概念 单例模式（Singleton pattern，单件模式，单子模式）： 确保有一个类只有一个实例，并提供一个全局访问点。 单例设计模式是设计模式中简单且常用的一种。 2，场景 1）场景 单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。 ① 资源共享的情况下，避免由于资源操作时导致的性......
单例模式
qq_19925065的博客
07-21 261
参考原文博客：点击进入在此谢过原博主。单例模式有5种形式；分别是饿汉模式、懒汉模式、双重检测锁模式、静态内部类模式，枚举模式。其中双重检测锁本人不清楚这么做的原因，并且原博主建议在JDK修复同步块嵌套漏洞之前不使用。静态内部类模式咋一看还不如写回饿汉模式，但是静态内部类模式实现了延迟加载，提供了系统性能。 以下是代码： （1）饿汉模式package cn.test.Singleton.one;/
单例设计模式--java实现
upupday19的博客
03-15 212
单例设计模式是一种常见的软件设计模式，通过这种模式，可以保证系统中，该类只有一个实例对象。对于系统中的某些类来说，只有一个实例很重要，比如一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务。为了保证一个类只有一个实例对象，需要满足以下三个条件：    1、外界无法创建该类对象，所以该类对象的构造函数是私有的，外界无法使用。    2、既然外界无法创建该类对象，并且要保证该类只有一个实例对...
M_to_fig.zip_s11_切比雪夫 耦合_耦合系数
07-14
根据切比雪夫低通原型滤波器的直接耦合系数画出他的响应曲线
s11.rar_10点DFT_s11
07-15
DFT验证频谱泄漏特性程序 2．x(n)的10点离散傅里叶变换
ZADACA_S11:第 11 周任务
06-29
任务_S11 第 11 周任务 任务 2 使用 Streams 进行读写。 要编写可序列化的 Person 类，您需要找到要覆盖的方法，以便对象在打印到文件时的格式为 {attribute1:, attribute2:} 任务1 * 可选的 目标是编写一个...
S参数反演程序 .rar_S 参数_S参数 磁导率_s11_s参数反演算法_电 反演
07-14
利用S参数，即S11和S21反演介质的有效介电常数和有效磁导率
Toshiba_VF_S11.rar_单片机开发_Visual_C++_
08-12
本文将深入探讨东芝VF-S11变频器的原理及其在单片机开发中的应用，结合使用Visual C++编程语言进行详细解析。东芝VF-S11是一款高效、功能强大的变频器，广泛应用于工业自动化领域，其内部结构和工作原理对于理解电机...
2024年公关服务行业分析报告.pptx
07-09
行业报告
惠州市建筑物矢量数据（Shp格式+带高度）.txt
最新发布
07-09
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。
Matlab语言教程及案例
07-09
项目总结 本文详细介绍了Matlab的基础知识和一个完整的数据分析与可视化案例。内容包括： 1. **基本操作**：基本算术运算和矩阵操作。 2. **绘图**：二维和三维绘图。 3. **函数和脚本**：编写和运行Matlab函数和脚本。 4. **案例分析**：生成模拟数据，进行数据预处理、绘图和统计分析。 通过这个项目，读者可以掌握Matlab的基本使用方法，并了解如何在Matlab中进行数据分析和可视化。这对于初学者入门Matlab编程、提升数据处理和分析能力非常有帮助。希望本文能为读者提供有价值的参考，提升其Matlab编程和数据分析技能。
KB8825英文数据手册
07-09
三星KB8825英文数据手册
if (bS11En) { N5230C.SCPI.CALCulate.PARameter.SELect.Command(null, strTestName + "_S11"); N5230C.SCPI.CALCulate.FORMat.Command(null, "MLOGarithmic"); //Thread.Sleep(100); N5230C.SCPI.CALCulate.DATA.QueryAsciiReal(null, "FDATA", out result_data_db_s11); //this.txtLog.AppendText("the result of S11" + "(db):\r\n"); showLog("the result of S11" + "(db):\r\n"); Console.WriteLine("data.Length:" + result_data_db_s11.Length); for (int i = 0; i < result_data_db_s11.Length; i++) { strDat = strDat + result_data_db_s11[i].ToString() + ","; } //this.txtLog.AppendText(strDat + "\r\n"); showLog(strDat); N5230C.SCPI.CALCulate.FORMat.Command(null, "PHASe"); //Thread.Sleep(100); N5230C.SCPI.CALCulate.DATA.QueryAsciiReal(null, "FDATA", out result_data_ph_s11); showLog("the result of S11" + "(deg):\r\n"); Console.WriteLine("data.Length:" + result_data_ph_s11.Length); strDat = ""; for (int i = 0; i < result_data_ph_s11.Length; i++) { strDat = strDat + result_data_ph_s11[i].ToString() + ","; } showLog(strDat); N5230C.SCPI.CALCulate.FORMat.Command(null, "MLOGarithmic"); }啥意思
07-10
这段代码是一个条件语句，它首先检查变量 bS11En 是否为真。如果 bS11En 为真，那么它会执行一系列操作。 首先，它调用了 N5230C 仪器的 SCPI 命令，选择了参数为 strTestName + "_S11" 的参数。接着，它通过调用 CALCulate.FORMat.Command 方法将数据格式设置为 "MLOGarithmic"。然后，它通过调用 CALCulate.DATA.QueryAsciiReal 方法查询数据，并将查询结果保存到 result_data_db_s11 变量中。接下来，它展示了 S11 数据的结果，将结果输出到日志中，并打印出数据的长度。 接着，它使用一个循环来将 result_data_db_s11 数组中的元素转换为字符串，并将这些字符串拼接在一起。然后，它展示了 S11 相位数据的结果，将结果输出到日志中，并再次打印出数据的长度。 最后，它通过调用 CALCulate.FORMat.Command 方法将数据格式设置回 "MLOGarithmic"。 总体来说，这段代码的目的是在 bS11En 为真时执行一系列操作，包括选择参数、设置数据格式、查询数据并将结果展示出来。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值