JAVA基础查缺补漏

最新推荐文章于 2023-03-31 14:48:50 发布
最新推荐文章于 2023-03-31 14:48:50 发布
阅读量229 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38256736/article/details/109112313
版权

匿名对象

创建一个对象，没有把它赋值给任何一个变量，只能使用一次。

static

作用：
如果在对象和方法前添加了static，那么它属于类而不属于对象。
特点：

  1. static修饰的内容，是随着类加载而加载的
  2. static修饰的内容，优先于对象存在
  3. static修饰的内容，被该类型的所有对象所共享
  4. static修饰的内容，可直接使用类名

类成员和实例成员的访问：

  • 静态方法只能访问静态成员
  • 非静态方法可以访问静态成员，也可以访问非静态成员

成员变量和局部变量

成员变量

直接在类中定义的变量，有默认初始值。

  1. 类成员变量：在成员变量前加static就是类成员变量
  2. 实例成员变量：不加static就是实例成员变量
    注意：在方法中不能使用static变量
局部变量

定义在方法中的变量、参数或代码块中定义的变量，要手动赋初始值。

this

在一个方法中，要给变量赋值，它会先到方法当中去找有没有该变量，如果有，就给方法内部的变量赋值，就不会向上找了（调用完方法，成员变量中依然没有值）；如果没有，再往它上一级找。
在方法当中变量前加上this，就代表直接给对象当中的字段赋值。

作用：

  1. 要区分成员变量和局部变量的二义性，必须使用this
  2. 在同一个类中，实例方法相互调用，可以省略this
  3. 可以把this作为参数传递
  4. 可以当作返回值返回
  5. static和this不能一起使用
  6. 构造方法的重载互调，this()；此时this代表构造方法的名称，必须写在第一行

super

到父类中去调用指定的方法和属性
注意：

  1. super()构造方法必须要放在第一行
  2. 凡是子类的构造方法中，都会有super();，默认就有。

有关继承的方法调用

  1. 一个类在加载字节码时，先寻找父类，如果有父类，会先把父类加载成字节码放到内存当中，然后再把自己加载到内存当中。

  2. 当子类调用方法时，先在子类中找，没有再到父类中找。

当想输出对象所有属性时，覆盖toString()方法（有可以自动生成的办法）

多态

特点：
把子类对象赋值给父类对象，在运行时期会表现出具体的子类特征调用子类方法

基本实现：

Dog dog=new Dog();
Cat cat=new Cat();
Person per=new Person();
per.feedAnimal(dog);
per.feedAnimal(cat);

class Person{
	void feedAnimal(Animal anim){
		anim.eat();
	}
}

作用：
当把不同的子类对象当作父类类型来看待，可以屏蔽不同子类对象之间的实现差异，从而写出通用代码达到通用编程，以适应需求的不断变化。

注意：

  1. 字段（我理解为属性）不存在多态，对象是什么类型就调用谁的。
  2. 子类对象赋值给父类对象是多态，此时当对象用到自己 特有的方法时需要强制转换成子类的类型再调用方法。

代码块

在类或方法中使用{}括起来的一段代码，称为一个代码块。代码块中定义的变量，称为局部变量。

  1. 局部代码块：直接定义在方法内部的代码块（很少使用）
  2. 初始化代码块：直接在类中定义的代码块，初始化代码块在运行时，还是会被放在构造方法中（很少使用）
  3. 静态代码块：在初始化代码块前加static，在加载字节码时就会自动调用，在主方法之前执行，只执行一次。

final

继承避免了代码重复，但破坏了封装。用final的目的是子类可以继承父类，但不能修改。

final可以修饰属性，方法和类。
修饰属性时子类不可更改父类属性；
修饰方法时子类不可覆盖该方法；
修饰类时该类不能被继承。

注意：

  1. final修饰属性时，属性是没有初始值的，必须手动设置初始值。
  2. final修饰变量时，就代表是一个常量，命名规则：所有字母都大写。
  3. 如果final修饰的是基本数据类型，代表值不能去修改了。
  4. 如果final修饰的是一个引用类型，地址不能再去修改。

设计模式（简）

1. 单例设计模式
一个类在内存当中只有一个对象。
饿汉模式（不能被继承，其他模式可以继承）
①必须要在该类中创建一个对象出来
②私有化自己的构造方法，防止外界通过构造方法创建新的对象
③给外界提供一个方法，能够获取已经创建好的对象（通过类名获取，设置成static）

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


public class Main {
    public static void main(String[] args) {
        ToolUtil.getInstance();
    }
}

工具类

把一些经常使用的功能，写在一个类中，称这个类为工具类。以后使用时直接调用。经常使用的包名有util/utils，tool/tools等。
设计方法：

  1. 工具类当中的方法一般设计成静态方法，直接使用类名来调用。
  2. 如果工具类中的方法没有使用static，一般把工具类设计为单例，通过单例获取对象调用工具方法。
  3. 如果工具类全部使用static修饰，说明工具方法只需要使用工具类名调用即可，此时必须把工具类构造方法私有化，防止对象调用静态方法。

包装类

把基本数据类型包装成一个对象，使功能更强大，以面向对象的思想使用这些类型。
byte-Byte short-Short int-Integer long-Long float-Float double-Double
char-Character boolean-Boolean

装箱操作
把基本数据类型包装成对象

public static void main(String[] args) {
        int a=20;
        Integer num = new Integer(a);
        System.out.println(num);
        System.out.println(num.MAX_VALUE);
        System.out.println(num.MIN_VALUE);
        System.out.println(num.TYPE);
    }

也可以用valueOf()进行装箱操作
具体类和方法可以查文档 JDK API中文版（未下载）

拆箱操作
把包装类对象转换为对象的基本数据类型

int num1=num.intValue();
System.out.println(num1);

自动装箱和自动拆箱

        Integer i=20;//自动装箱
        int i1=i.intValue();//自动拆箱

字符串与其他类型的转换

        //把字符串转成包装类型
        Integer i=new Integer("12");
        Double d=new Double("12.10");

        //把包装类型转换成字符串
        Integer i2 = Integer.valueOf(100);
        String str = i2.toString();

        //基本数据类型转字符串
        int a = 10;
        String str2 = a +"";

        //字符串转基本数据类型
        String str3 = "200";
        int i3 = Integer.parseInt(str3);

        //字符串转布尔类型(除了“true”以外，其他都输出false)
        Boolean b = new Boolean("mama");

基本数据类型和包装类的区别

  1. 默认值不同，int-0 Integer-null
  2. 包装类当中提供了很多方法直接给我们使用，Integer.toBinaryString(s)
  3. 集合框架中不能存放基本数据类型，只能存对象
  4. 在类中，成员变量一般使用包装类型，方法中一般使用基本数据类型（方法中基本数据类型存储在栈中，包装类型存放在堆中）

包装类中的valueOf缓存设计

        //两个地址不一样，每new一个创建一个新的地址
        Integer i = new Integer(100);
        Integer i2 = new Integer(100);
        
        //包装类中的缓存设计,地址相同
        Integer i3 = Integer.valueOf(123);
        Integer i4 = Integer.valueOf(123);
        
        //地址不同，缓存范围只有-128到127，超过这个范围就不会使用缓存，直接创建新地址
        Integer i5 = Integer.valueOf(300);
        Integer i6 = Integer.valueOf(300);

抽象类

多个类有相同的方法，可以抽出一个父类出来，把相同的方法放在父类当中。
但子类的方法体各不相同，所以父类不需要方法体。

抽象方法
在方法前面添加了一个关键字abstract
特点：

  1. 抽象方法没有方法体
  2. 抽象方法必须要定义在抽象类或接口当中
  3. 抽象方法不能是私有的，不能使用final，static修饰
  4. 子类必须要覆盖父类中的抽象方法
    抽象类
    必须有子类才有意义。
    特点：
  5. 抽象类是不能直接创建对象的
  6. 抽象类中可以有抽象方法，也可以有非抽象方法（普通方法：给子类调用的）
  7. 子类没有去覆盖抽象方法，可以把子类也定义成一个抽象类，但孙类要覆盖抽象方法
  8. 构造方法不能定义为私有的（抽象方法必须要子类继承，才能实现内部的方法体）
  9. 抽象类不能用final来修饰
    命名：
    通常在类名前加Abstract，例如AbstractSuperClass

接口

java接口表示一种规范，使用抽象方法去定义一组功能
接口是一个特殊的抽象类，方法前的abstract可以省略不写，在编译时会自动添加上

注意：

  1. 接口没有构造方法，不能创建对象
  2. 接口中定义变量，都是全局的静态常量
    String name = "myxq";
    public static final String name;
  1. 接口中定义的方法都是公共的抽象方法
    void transData();
    public abstract void transData();
  1. 接口是可以继承的，而且可以多继承，类是不能多继承的
    接口继承一般不做方法覆盖
//爬行动物
interface Iwalkable{
    void walk();
}
//水生动物
interface Iswimable{
    void swim();
}
//两栖动物
interface Iamphibiousable extends Iwalkable,Iswimable{
}

子类中方法的权限要比父类权限大或一样大

接口的定义、实现及对象创建

interface Iwalkable{
    String name = "myxq";
    public abstract void walk();
}

interface Iswimable{
    void swim();
}

class Cat implements Iwalkable{
    public void walk(){
        System.out.println("走猫步");
    }
}
class Frog implements Iwalkable,Iswimable{
    public void walk(){
        System.out.println("跳着走");
    }
    public void swim(){
        System.out.println("游啊游");
    }
}
public class InterfaceClass {
    public static void main(String[] args) {
        //多态的写法
        Iwalkable cat = new Cat();
        cat.walk();

        Frog f = new Frog();
        f.walk();
        f.swim();
    }
}
抽象类与接口

相同点：

  1. 都被其他类实现或继承
  2. 都不能实例化
  3. 都可以定义抽象方法，定义的抽象方法子类都必须得要覆盖

不同点：

  1. 接口没有构造方法，抽象类中有构造方法
  2. 抽象类可以包含普通方法和抽象方法，接口中只能有抽象方法，不能有普通方法（带有方法体）
  3. 接口中的成员变量，public static final变量-静态常量；抽象类中成员变量为默认权限（包访问权限）
  4. 接口中默认方法 public abstract 方法名；抽象类中为默认权限（包访问权限）
面向接口编程

把实现类对象赋值给接口类型的变量
多态的好处：屏蔽了不同类之间 的实现差异，从而达到通用编程

interface IUSB{
    public abstract void swapData();
}
class Mouse implements IUSB{
    @Override
    public void swapData() {
        System.out.println("用鼠标");
    }
}
class Keyboard implements IUSB{
    @Override
    public void swapData() {
        System.out.println("敲键盘");
    }
}
class MotherBoard{
    void pluginIn(IUSB u){
        u.swapData();
    }
}

public class InterfaceClass {
    public static void main(String[] args) {
        IUSB m = new Mouse();
        IUSB k = new Keyboard();
        MotherBoard b =new MotherBoard();
        b.pluginIn(m);
        b.pluginIn(k);

    }
}

内部类

定义在类中的一个类

使用内部类的原因：

  1. 增强封装，把内部类隐藏在外部类中，不允许其他类访问这个内部类
  2. 增加了代码的可维护性
  3. 内部类可以直接访问外部类中的成员

内部类可以分为四种：

  1. 实例内部类：直接定义在类当中的一个类，在类中没有任何一个修饰符
class Outter{
    String name = "myxq";
    class In{
        void test(){
            System.out.println(name);
        }
    }
}

public class InnerClass {
    public static void main(String[] args) {
        Outter out = new Outter();
        System.out.println(out.name);
        //创建实例内部类
        //创建内部类对象当中，会有一个外部类的引用
        Outter.In in = out.new In();
    }
}
  1. 静态内部类：在内部类前面加一个static
  2. 局部内部类：定义在方法的内部类
  3. 匿名内部类：属于局部内部类的一种特殊情况
    （具体内容之后再补）

枚举

java枚举：是一个特殊的类，多个常量对象的集合
不使用枚举的例子：


//定义一个星期几的常量类
class WeekDay{
    public static final WeekDay MONDAY = new WeekDay();
    public static final WeekDay TUESDAY = new WeekDay();
    public static final WeekDay WENDESDAY = new WeekDay();
    public static final WeekDay THURSDAY = new WeekDay();
    public static final WeekDay FRIDAY = new WeekDay();
    public static final WeekDay SATURDAY = new WeekDay();
    public static final WeekDay SUNDAY = new WeekDay();
}

class Student{
    private WeekDay restDay;

    public WeekDay getRestDay() {
        return restDay;
    }

    public void setRestDay(WeekDay restDay) {
        this.restDay = restDay;
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setRestDay(WeekDay.TUESDAY);
    }
}

好处：

  1. 安全，不会输入枚举值之外的值
  2. 业务逻辑合理
    使用枚举：
enum Weekday{
    MONDAY,TUESDAY,WENDESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY
}

Main方法

当点击运行时，JVM自动调用main方法

public static void main(String[] args) {
    }

public：被JVM调用的方法，它的权限要足够大
static：被JVM调用的方法，不需要创建对象，直接使用类名调用
void：被JVM调用的方法，不需要有任何返回值
main：方法的名称，只能这样写，不然JVM识别不了
String[] args:以前是指键盘录入

数组拷贝

        int[] src = {1,2,3,4,5,6};
        int[] dest = new int[10];
        System.arraycopy(src,2,dest,2,4);
        System.out.println(Arrays.toString(src));
        System.out.println(Arrays.toString(dest));

src-源数组，2-源数组中的起始位置，dest-目标数组，2-目标数组起始位置，4-要复制的数组元素数量
输出：
[1, 2, 3, 4, 5, 6]
[0, 0, 3, 4, 5, 6, 0, 0, 0, 0]

gc方法与对象销毁（还需要仔细学习）

		//终止正在运行的Java虚拟机，执行到这里下面就不执行了
        System.exit(0);
        //运行垃圾回收器，立即运行垃圾回收器，一个对象并不是立马被回收
        System.gc();//一般不会主动调用该方法

随机数和UUID

        //生成随机数
        Random r = new Random();
        int res = r.nextInt();
        System.out.println(res);
        System.out.println(r.nextBoolean());
        System.out.println(r.nextDouble());

        //相同种子生成的随机数是一样的
        Random r2 = new Random(110);
        System.out.println(r2.nextInt());

        //生成34-229之间的随机数
        //34+[0 195）
        new Random().nextInt(195);

        //UUID:通用唯一识别符
        //在一台机器上生成的数字
        //当前的时间，跟电脑网卡生成一段字符
        String uuid = UUID.randomUUID().toString();
        System.out.println(uuid);

日期

获取当前日期
        Date date = new Date();
        System.out.println(date);//英文日期

        //把一个毫秒值转化为日期类型
        //获取当前时间的毫秒
        long curTime = System.currentTimeMillis();
        //把一个毫秒值转成日期类型
        Date date2 = new Date(curTime);
        System.out.println(date2);

        //中国人喜欢的风格
        String str = date2.toLocaleString();
        System.out.println(str);
生成验证码
//生成验证码
        //5位的随机数  UUID生成的是16进制
        String res = UUID.randomUUID().toString();
        System.out.println(res);
        //截取前5位
        res = res.substring(0,5);
        System.out.println(res);

        String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        str = str + str.toLowerCase();
        str = str + "0123456789";
        System.out.println(str);

        //从所有字符中随机生成5个出来
        //角标要随机的值 （0，62）
        //随机取5个出来
        StringBuilder sb = new StringBuilder();
        for(int i=0;i < 5;i++){
            int index = new Random().nextInt(str.length());
            char ch = str.charAt(index);
            sb.append(ch);
        }
        System.out.println(sb);
日期格式化
//日期格式化
        Date date = new Date();
        System.out.println(date);

        DateFormat df = DateFormat.getInstance();
        //对指定日期进行格式化,具体查api文档
        String time = df.format(date);
        System.out.println(time);

        //长日期：LONG
        //短日期：SHORT
        DateFormat df2 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT);
        String  time2 = df2.format(date);
        System.out.println(time2);
        DateFormat df3 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
        String  time3 = df3.format(date);
        System.out.println(time3);

        //获取时间
        DateFormat df4 = DateFormat.getTimeInstance();
        String time4 = df4.format(date);
        System.out.println(time4);

        //自定义日期模式
        Date date = new Date();
        SimpleDateFormat sd = new SimpleDateFormat();
        //定义自己想要什么格式的日期
        String pattern = "yyyy-MM-dd HH:mm:ss";
        sd.applyPattern(pattern);

        //以指定的模式格式化哪个日期
        String res = sd.format(date);
        System.out.println(res);
xhliuuuuuu
关注
Java基础知识查缺补漏（map、数组、list）
席同学的博客
12-08 630
Map的new为什么是Map map=new HashMap;而不是new Map Map是接口，HashMap是Map的一种实现。接口不能被实例化。 Map map=new HashMap(); 就是将map实例化成一个HashMap。 这样做的好处是调用者不需要知道map具体的实现，map接口与具体实现的映射java帮你做了。 ...
查缺补漏，揭露Redis的秘密，巩固你的Redis知识体系
m0_68850571的博客
06-07 665
无脑下一步即可出现错误：creating server tcp listening socket 127.0.0.1:6379: bind No error解决方案：启动：redis-server.exe redis.windows.conf客户端启动：redis-cli.exe (不修改配置的话默认即可)redis-cli.exe -h 127.0.0.1 -p 6379 -a password 基本文件说明基础命令Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）
查缺补漏
weixin_34043301的博客
10-11 111
1.const //file1.cpp int a; //file2.cpp extern int a; a++ //上述是正确的，但是下面就会出错 //file3.cpp const int a; //file4.cpp extern int a; a++ const会把变量变为局部变量，只允许本文件访问，如果想用const，又不想其为局部变量可以加一个extern修饰con...
查缺补漏。。。
Luckyzhoufangbing的博客
09-16 169
1. es6 和 js 的关系？ es6 又叫 ECMA Script 规范，js 是对这个规范的实现 let a = 3 a = 44 console.log(a) // 44 2. const 定义了不能更改 指的是 基本数据类型，引用数据类型没有这个限制 3. Map 的键可以是任意类型，对象的键只能是字符串 4. 箭头函数简写 const test = v => v 相当于： function test (v) { return v } 箭头函数没写 return
2023年Java后端面试题，备战春招，查缺补漏，吃透16套专题技术栈
最新发布
stone_tmp的博客
03-31 535
这次去阿里面试的是我老东家的好朋友，我们之前都是一个项目组的，一起吃饭，一起洗脚，一起。。。他们公司最近也裁员了，不过他是裁员前去的阿里，不知道谁捞到他简历了，莫名就走了流程，他莫名的就面了7轮过了。他想着行情这么不好，要不就去了，去了之后，他们公司就裁员了。。。总之今年大环境真的很差，大家都时刻做好准备，我朋友简历上是写了精通dubbo的源码，所以你们会发现，面试中dubbo的问题很多，他面经写得算是比较简单，但是真实问的过程肯定会扣肯定细节。
2020年最新最全的Java面试经历整理(一次性查缺补漏个够)
热门推荐
豆汁
12-10 1万+
前言 现在已经是2020年了，相信很多人都在准备面试，，如何拿到心仪的 Offer，进入梦寐以求的大厂，实现自己的职业理想，达到程序员的小康水平。 这篇文章主要介绍了刘哥一月份的几次面经，(一次性查缺补漏个够)，（感谢刘哥的内容提供） 对于面试的那几家公司暂不公布，望理解。 第一家（Zookeeper+微服务+消息中间件+高并发架构设计） 一面 JVM数据存储模型，新生代、年老代的构造？ jav...
Java面试精华：基础到高级知识点全解析
Java面试宝典2017.8版提供了一系列深入浅出的Java基础知识和框架相关问题，旨在帮助求职者进行查缺补漏。以下是一些核心知识点的详细解析： 1. Java源文件结构：一个.java源文件理论上可以包含多个类，但前提是这些...
三，查缺补漏
novaliang的专栏
05-23 279
这篇文章，是本专栏的最后一篇，也没什么太多的需要讲述了，主要的就是大家自己开发中去摸索了。 在这里，我把windows那里面讲的有问题的地方梳理一下，主要是针对工具这块。 首先是CodeLLDBvadimcn.vscode-lldb插件，这个插件其实可以不用装，因为windows上开发面向windows的插件，用微软的编译器也可以，而那个C/C++ for Visual Studio Code已经集成了很多环境了。 其次就是关于Prebuild tools 预构建工具，大家先看看index.js和pa
子查询查缺补漏
kylin_learn的博客
04-18 338
题目来自sqlzoo的子查询题目。网址： https://sqlzoo.net/wiki/SELECT_within_SELECT_Tutorial/zh 表列名含义： name:国家名称 continent:该国家属于哪个洲 area:面积 population:人口 gdp:国内 5.德国(Germany)在欧洲(Europe)國家的人口最多。...
MySQL查缺补漏
hsy_666的博客
06-16 260
数据库：          关系型管理系统：RDBMS（Relational Database Management System）          特点：                  数据以表格的形式出现                  每行为各种记录名称       每列为记录名称所对应的数据域                  许多的行和列组成一张表格   若干的表格组成datab...
（十三）查缺补漏
Luckyzhoufangbing的博客
09-08 189
1. require：也会执行被加载模块中的代码 index.js： require('./test.js') test.js console.log('111') 执行 node index.js 之前主要用法是把 require 的结果赋值，然后调用结果中的对象KEY~ 2.
java查缺补漏
点点的博客
11-13 975
最近有个需求要把项目发布在weblogic12c服务器中，按照网上的教程对springboot项目进行改造后，陆续遇到了几个问题： 1.weblogic报错：afu.com.sun.source.tree.Tree$Kind？ 这个错误 把项目中用到的依赖guava版本更换为24.1-jre解决 2.controller层返回数据的时候，报Jackson转换的错误，nosuchMethod 之类...
python查缺补漏
dainandainan1的博客
05-17 265
python语法 描述 step.iteritems() items()返回的是列表对象，而iteritems()返回的是iterator对象。例如： print dic.items() #[('a', 'hello'), ('c', 'you'), ('b', 'how')] print dic.iteritems() #<dictionary-itemiterator object at 0x020E9A50> ...
【c++】查缺补漏
离光曦的博客
03-09 299
c++中new操作的返回值： new返回一个指针，如int *p=new int;返回一个指向int的指针，int *p=new int[10],返回一个指向含有10个int元素的数组的首地址。 new失败的操作： 在早期c++版本中，如果系统不能够满足用户new的内存需求，则继承c语言的处理方法，返回一个指向NULL的指针；后来c++的版本中，则是跑出bad_alloc异常，所以针...
「查缺补漏」我的2020珍藏的n道多线程并发面试题，给你秋招保驾护航
豆汁
12-10 7150
点关注，不迷路！ 为什么要用线程池？Java的线程池内部机制，参数作用，几种工作阻塞队列，线程池类型以及使用场景 回答这些点： 为什么要用线程池？ Java的线程池原理 线程池核心参数 几种工作阻塞队列 线程池使用不当的问题 线程池类型以及使用场景 为什么要用线程池？ 线程池：一个管理线程的池子。 管理线程，避免增加创建线程和销毁线程的资源损耗。 提高响应速度。 重复利用。 Java的线程池执行原理 为了形象描述线程池执行，打个比喻： 核心线程比作公司正式员工 非核心线程比作外包员工 阻塞.
常见知识点查缺补漏（一）'
wulitaotao96的博客
08-21 1126
1 自旋锁特性及其应用场合 自旋锁是一种特殊的互斥锁，当资源被锁后，其他线程想要再次加锁，此时该线程不会被阻塞睡眠而是陷入循环等待状态（CPU不能做其它事情），循环检查资源持有者是否已经释放了资源，这样做的好处是减少了线程从睡眠到唤醒的资源消耗，但会一直占用CPU的资源。适用于资源的锁被持有的时间短，而又不希望在线程的唤醒上花费太多资源的情况。 自旋锁原本用于多核SMP环境下，在并发时进行临界...
Java模糊查询实现与技巧解析
"本文详细介绍了Java实现模糊查询的方法，通过实例代码展示了如何在不确定用户输入条件时，构建灵活的SQL语句来完成模糊查询操作。" 在Java开发中，尤其是在进行数据库交互时，模糊查询是一种常见的需求，允许用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值