世真
世真

跨越编程界限：C++到JavaSE的平滑过渡

JDK安装

  1. 安装JDK

  2. 配置环境变量：

    Path 内添加 C:\Program Files\Java\jdk1.8.0_201\bin

    添加 JAVA_HOME C:\Program Files\Java\jdk1.8.0_201

    添加 CLASSPATH .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar

第一个Java程序

HelloWorld.java

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello world");
	}
}

保存退出，打开终端

输入：

javac HelloWorld.java

此时多了一个 HelloWorld.class 文件，.class 叫做字节码文件

输入：

java HelloWorld

输出Hello world

解释：

  1. public 访问修饰限定符
  2. class 定义类的关键字
  3. HelloWorld 类名，建议使用大驼峰

如果一个类是 public 修饰的，那么这个类的类名要和文件名一样。

  1. main 函数固定写法 public static void main(String[] args)

  2. System.out.println("Hello world");

    另外两个打印函数：

    System.out.print("Hello world");

    不带ln，区别在于不换行

    System.out.printf("%s", "Hello world");

    格式化输出，同C语言

  3. String[] args

    Java 中的数组使用类型加方括号的形式，方括号中不写数字。

    该参数为命令行参数

Java 程序运行在哪？

Java 程序运行在 Java虚拟机——JVM 之上，同样一个字节码文件可以在任意一台安装了jdk的机器上运行。

注释

单行和多行注释和C语言相同。

文档注释：/** 文档注释 */ 常见于方法和类之上描述方法和类的作用）可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档

/**
 * @author cero
 * @version 1.1
 */

注意：当在文件中写了中文，然后使用 javac 编译的时候报错，这往往是编码问题。

现在我们写代码的环境一般都是utf-8，但是 javac 是 GBK 编码。

在编译时指定编码：-encoding utf-8 即可解决。

使用javadoc工具从Java源码中抽离出注释：

javadoc -d myHello -author -version -encoding UTF-8 -charset UTF-8 HelloWorld.java

-d 创建目录 myHello 为目录名

-author 显示作者

-version 显示版本号

-encoding UTF-8 -charset UTF-8 字符集修改为 UTF-8

IDEA 快捷键：

ctrl + / 行注释

ctrl + shift + / 块注释

标识符

硬性规则：

标识符可以包含数字、字母、下划线、美元符号$；不能以数字开头，也不能是关键字；且严格区分大小写。

软性规则：

类名：采用大驼峰

变量和方法的命名：采用小驼峰

IDEA快捷键：

  • psvm 或 main：生成 main 函数。
  • sout：生成 println 函数，也可以写一个东西然后加个.sout

数据类型

Java数据类型

基本数据类型：

  • 整数：byte short int long
  • 小数：float double
  • 布尔：boolean
  • 字符：char

引用数据类型：

  • 数组，String，类，接口，枚举

注意：

  • 局部变量在使用前一定要初始化，否则会直接报错，这一点不同于 C 语言，体现了 Java 的安全性。
  • 赋值时小类型可以赋值给大类型，反之不行
  • 赋值时，字面值常量的大小不能超过类型的范围，否则会报错
  • 在 Java 中，没有无符号和有符号的说法
  • int 占 4 字节，long 占 8 字节，short 占 2 字节，byte 是区别于 C 语言的一个新的类型，只占 1 个字节
  • Java 中的 char 占 2 字节，所以 Java 中的 char 可以存中文字符
  • Java 中不存在 0 为假，非 0 为真
  • Java 中存在类型转换（包括显式和隐式）和类型提升
  • 所有小于 4 字节的元素在运算时都会提升为 4 字节

打印int的最大值和最小值：

System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);

其中的 Integer 是包装类——基本数据类型所对应的类类型

int 的类类型是 Integer，char 的类类型是 Character，其他的基本数据类型对应的类类型都是首字母大写

字符串

字符串拼接

字符串String之间使用 + 号进行拼接，其他类型，如 int 和 String 进行 + 运算也是拼接，而不会进行数字计算，例：

public class TestDemo {
    public static void main(String[] args) {
        System.out.println("10 + 20 = " + 10 + 20);
        System.out.println("10 + 20 = " + (10 + 20));
        System.out.println(10 + 20 + " = 10 + 20");
    }
}

结果：

10 + 20 = 1020
10 + 20 = 30
30 = 10 + 20

数字，字符串互转

public class TestDemo {
    public static void main(String[] args) {
        // 数字转字符串
        int num = 10;
        // 1. 使用 + 号拼接
        String str1 = num + "";
        System.out.println(str1);
        // 2. 使用 valueOf
        String str2 = String.valueOf(num);
        System.out.println(str2);

        // 字符串转数字
        String str = "123";
        int a = Integer.parseInt(str);
        System.out.println(a + 1);
    }
}

字符串比较

Java 的字符串比较要用 equals() 方法

import java.util.Scanner;

public class TestDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String password = scan.next();
        if (password.equals("123")) {
            System.out.println("输入正确");
        } else {
            System.out.println("输入错误");
        }
    }
}

如果你用 == ，那么实际上比较的是两个 String 的地址

数组

定义方式

int[] array1 = {1, 2, 3, 4, 5};
int[] array2 = new int[]{1, 2, 3, 4, 5};
int[] array3 = new int[10]; // 大小为10，以默认值初始化
System.out.println(array1.length); // 通过.length获取数组长度

前两种写法本质上没有区别，都是手动输入初始化数据，数组长度编译器自动推导，[]内不能写数字

第三种方式使用 new 开辟一个指定大小的数组，以默认值初始化（默认值也就是对应的 0-值，如果是引用类型，那么默认值就是null）

注：

  • 因为 Java 的数组是引用类型，所以数组可以理解为是动态分配的，里面的数据存储在内存中的堆区。
  • Java 会严格检测数组访问越界，一旦越界，就会抛异常。

数组遍历

  1. 使用普通的 for/while 循环

  2. Java 支持 for-each，和 C++11 的语法一样。

  3. 借助 Java 提供的 Arrays 工具类

    import java.lang.reflect.Array;
import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println(Arrays.toString(array));
    }
}

    输出：

    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    Arrays 中的 toString() 方法可以将数组转为字符串，而且还用 , 和 [] 加了格式。

数组拷贝

  1. for 循环

  2. Arrays.copyOf() 方法：

    public static int[] copyOf(int[] original,
                           int newLength)
    // original - 要复制的数组
    // newLength - 要返回的副本的长度
    // newLength 大于original数组长度，则返回的数组会在末尾使用0填充，如果小于，则截断
    // 返回：原始数组的副本

    import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        int[] copy = Arrays.copyOf(array, array.length);
        System.out.println(Arrays.toString(copy));
    }
}

  3. System.arraycopy() 方法：

    copyOf 的实现其实用的就是这个方法

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
// src - 源数组.
// srcPos - 源数组中的起始位置.
// dest - 目标数组.
// destPos - 目标数组中的起始位置.
// length - 要复制的数组元素数.

    我们看不到这个函数的具体实现，因为它由 native 修饰，是一个本地方法，也就是说，它其实是由 C/C++ 实现的。

    import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        int[] copy = new int[array.length];
        System.arraycopy(array, 0, copy, 0, array.length);
        System.out.println(Arrays.toString(copy));
    }
}

  4. clone() 方法

    这是从 Object 继承的方法，能直接对自己拷贝出一个对象并返回

    import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        int[] copy = array.clone();
        System.out.println(Arrays.toString(copy));
    }
}

  5. Arrays.copyOfRange() 方法

    public static int[] copyOfRange(int[] original,
                                int from,
                                int to)
// 从 original 数组的 [from, to) 范围的数据，返回副本数组

数组排序

使用 Arrays.sort()

该方法默认排升序，使用接口可以指定其他排序方式

二分查找

Arrays.binarySearch()

public static int binarySearch(int[] a,
                               int key)
    
public static int binarySearch(int[] a,
                               int fromIndex,
                               int toIndex,
                               int key)

一个是对整个数组的二分查找，一个是指定范围的二分查找。

返回找到的key的下标，如果没找到，则返回 (-(插入点) - 1) 的值。也就是说，找到则返回的是正数，没找到返回负数。

比较数组

public static boolean equals(int[] a,
                             int[] a2)

两个数组相等返回 true ，否则返回 false

数组填充

给数组填充指定的值

public static void fill(int[] a,
                        int val)
    
public static void fill(int[] a,
                    int fromIndex,
                    int toIndex,
                    int val)

二维数组

// 手动给值初始化
int[][] array1 = {{1, 2, 3}, {4, 5, 6}};
int[][] array2 = new int[][]{{1, 2, 3}, {4, 5, 6}};

int[][] array3 = new int[2][3]; // 一个2行3列的数组，默认值初始化

int[][] array4 = new int[3][]; // 可以不给列大小。比如这个3行的数组，每一行都是一个int[]类型的null引用

最后一种方式的定义的数组，可以在稍后给每一行分配不同大小的数组

array4[0] = new int[3];
array4[1] = new int[4];

运算符

  • & 和 | 的左右表达式为 boolean 时，也表示逻辑运算，但与 && || 相比，它们不支持短路求值

  • Java 中的 >>> 是无符号右移，无论正数还是负数，高位都是补0。与之相对的 >> 是有符号右移，高位补的是符号位

标准输入

Java 标准输入首先需要 new 一个 Scanner 对象，IDEA 会帮我们自动 import Scanner 类

使用 System.in 来初始化，表示标准输入。

调用 nextInt() 方法读取一个 int

import java.util.Scanner;

public class TestDemo {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       int n = scanner.nextInt();
   }
}

使用 next() 方法读取一个 String（以空格和换行作为分隔符）

nextLine() 方法是只以换行作为分隔符

import java.util.Scanner;

public class TestDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String name = scan.next();
        System.out.println("姓名：" + name);
    }
}

判断闰年：

import java.util.Scanner;

public class TestDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            int year = scan.nextInt();
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                System.out.println(year + "年是闰年");
            } else {
                System.out.println(year + "年是平年");
            }
        }
    }
}

注：这里使用 hasNext() 来循环输入，在 IDEA 下，使用 ctrl+d 终止。

猜数字：

import java.util.Random;
import java.util.Scanner;

public class TestDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        Random random = new Random();
        int randomNum = random.nextInt(100) + 1; // 生成 [1, 100] 的一个随机int
        while (true) {
            System.out.println("请输入一个数字");
            int num = scan.nextInt();
            if (num > randomNum) {
                System.out.println("猜大了");
            } else if (num < randomNum) {
                System.out.println("猜小了");
            } else {
                System.out.println("猜中了");
                break;
            }
        }
    }
}

生成随机数需要先 new 一个 Random 对象，可以用固定的种子去初始化，如果不填就是随机种子。使用 nextInt(100) 可以生成 [0, 100) 的数。

方法

方法就是函数

  • 在 Java 中，方法必须写在类当中
  • 在 Java 中， 没有方法声明一说

Java 中的方法支持重载，Java 通过方法签名来标识一个方法。

方法签名：经过编译器编译修改过的方法的最终名字，具体为：方法全路径名+参数列表+返回值类型。

public class TestDemo {
    public static int add(int a, int b) {
        return a + b;
    }

    public static double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println(add(1, 2));
        System.out.println(add(1.1, 2.2));
    }
}

编译之后，使用 javap -v TestDemo 指令反汇编：

跨越编程界限：C++到JavaSE的平滑过渡_第1张图片

JVM的内存分布

  • 程序计数器(PC Register)：只是一个很小的空间,保存下一条执行的指令的地址。
  • 虚拟机栈(JVM Stack)：与方法调用相关的一些信息，每个方法在执行时都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如:局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
  • 本地方法栈(Native Method Stack)：本地方法栈与虚拟机栈的作用类似。只不过保存的内容是 Native 方法的局部变量。在有些版本的JVM 实现中(例如HotSpot),本地方法栈和虚拟机栈是一起的。
  • 堆(Heap)：JVM所管理的最大内存区域.使用 new 创建的对象都是在堆上保存(例如前面的new int[]{1, 2, 3})，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。
  • 方法区(Method Area)：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。方法编译出的字节码就是保存在这个区域。

其中，方法区和堆是由所有线程共享的，其他数据区是线程隔离的。

Java 堆上开辟的内存，不需要我们手动释放，JVM 本身有垃圾回收器，帮我们释放内存。

引用

如果我们直接打印一个对象：

int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.println(array);

输出：

[I@1b6d3586

这个结果就是这个数组对象的地址的哈希值。@ 前的 [I 表示这是一个 int 数组，[ 就是表示数组。

其中的 array 就是引用变量（简称引用），这里的引用是存在虚拟机栈上的，存的内容是数组对象的地址。数组的内容，即数组对象，存在堆上。

引用变量使用前也必须初始化，可以 new 一个对象来初始化，也可以是 null 初始化：

int[] array = null; // 一个不指向任何对象的引用

int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] array2 = array1;
// 指向同一个对象的两个引用

int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] array2 = {2, 3, 4, 5};
array1 = array2;
// array1和array2都指向都指向了第二个对象，此时第一个对象没有被引用，会被垃圾回收器自动回收

小练习：

  1. 下面的程序输出什么？

    public static void func1(int[] arr) {
    arr = new int[]{11, 12, 13, 14};
}
public static void main(String[] args) {
    int[] arr = {1, 2, 3, 4};
    func1(arr);
    System.out.println(Arrays.toString(arr));
}

    答案：[1, 2, 3, 4]

    解析：形参的改变不会影响实参，虽然形参指向了另一个对象，但是实参指向的还是原来的对象，所以不变。

  2. 下面的程序输出什么？

    public static void func2(int[] arr) {
    arr[0] = 99;
}
public static void main(String[] args) {
    int[] arr = {1, 2, 3, 4};
    func2(arr);
    System.out.println(Arrays.toString(arr));
}

    答案：[99, 2, 3, 4]

    解析：形参的引用和实参的引用指向了同一个对象，形参使用[]+下标的方式修改了这个对象的一个值，最后打印的就是修改后的结果。

重写toString

我们知道打印一个引用变量会输出它的地址，我们也可以让它输出别的

查看 println 的源码：

public void println(Object x) {
    String s = String.valueOf(x);
    synchronized (this) {
        print(s);
        newLine();
    }
}

看到它调用了 valueOf()，那么我们再去查看 valueOf() 方法

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

可以看到，println 实际上是调用了转入参数的 toString，这个方法是从 Object 类继承的，我们可以重写。

例：

class Test {
    @Override
    public String toString() {
        System.out.println("一个重写的toString方法");
        return "haha";
    }
}

public class TestDemo {
    public static void main(String[] args) {
        System.out.println(new Test());
    }
}

输出

一个重写的toString方法
haha

类和对象

Java 的类和对象

软性要求

  • 一般一个文件当中只定义一个类
  • main 方法所在的类一般要使用 public 修饰
  • 不要轻易修改 public 修饰的类的名称，如要修改，要通过开发工具修改（IDEA 中右键文件名->Refactor->Rename File…）

硬性要求

  • public 修饰的类必须要和文件名相同
  • 访问修饰限定符要写在各个属性和方法的前面，这一风格和 C++ 不同

特性

  • Java 同样可以在属性后面用 = 来指定初始值，这称作就地初始化

  • 编译器会给每个类生成不带参的默认构造方法，如果你为一个类提供了构造方法，编译器便不再为这个类生成默认构造方法了。

  • IDEA 右键可以生成你想要的构造方法，get set方法等

  • this 还可以用来调用本类中的其他的构造方法，以 this() 的形式，必须写在一个构造方法的第一行

    • this 不能形成环，例：

      public Date() {
    this(2023, 11, 11);
}

public Date(int year, int month, int day) {
    this();
}

      当对象创建的时候，要调用一个构造方法A，构造方法A要调用构造方法B，而B又要调用A，这就死循环了，所以不行。

  • 虽然可以在构造方法 new 自己类的对象，但在运行时会栈溢出

Java 构造一个对象的过程：

  1. 检测对象对应的类是否加载了，如果没有加载则加载

  2. 为对象分配内存空间

  3. 处理并发安全问题

    比如：多个线程同时申请对象，JVM 要保证给对象分配的空间不冲突

  4. 初始化所分配的空间

    即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值（零值）

  5. 设置对象头信息

  6. 调用合适的构造方法

封装

访问限定符

Java 提供了 4 种访问限定符

范围 private default protected public
同一包中的同一类 ✅ ✅ ✅ ✅
同一包中的不同类 ✅ ✅ ✅
不同包中的子类 ✅ ✅
不同包中的非子类 ✅
  • 一个方法或属性的前面没有指定访问限定符，那么它相当于被 default 修饰
  • default 权限叫做默认权限，又叫包访问权限，可以正好将可访问范围限定为当前这个包
  • protected 主要用在继承中，只要在同一个包或者是这个类的子类就可以访问
  • 访问权限除了可以限定类中成员的可见性，也可以控制类的可见性
  • 类只能用 public 修饰或默认修饰，被 public 修饰的类可以被任意 java 文件导入，默认修饰是类只能被同一包中的 java 文件导入

包

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。类似于文件夹。

Java 中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

import

import 就是用来导入某个包中的类，比如 import java.util.Arrays 导入 java 包中的 util 包中的 Arrays 类。

也可以写 import java.util.* 表示导入 java.util 包下的所有类。

不写 import 也可以用其他包下的类，只是每次使用都要指定所在的包：

java.util.Date date = new java.util.Date();

注：如果导入了两或多个名称相同的类，则必须要在每次使用时都指定所在的包。

静态导入（不建议使用）

使用 import static 可以导入包中的静态方法和字段

比如：导入 Math 类下的静态方法

import static java.lang.Math.*;

public class TestDemo {
    public static void main(String[] args) {
        double result = sqrt(pow(3, 2) + pow(4, 2));
        System.out.println(result);
    }
}

本来我们调用 sqrt() 和 pow() 方法是要在前面加 Math. 的，静态导入后就不需要了。

自己创建包

  • IDEA 右键一个文件名->New->Package

跨越编程界限：C++到JavaSE的平滑过渡_第2张图片

  • 包名一般以域名倒过来写，如 com.cero.demo1
  • 包名要和代码路径相匹配，例如创建 com.cero.demo1 的包，那么会存在一个对应的路径 com/cero/demo1 来存储代码

我们可以创建出这样一个结构：

跨越编程界限：C++到JavaSE的平滑过渡_第3张图片

  • 包中的java文件开头都会用 package 声明自己所在的包
  • 如果没有 package 语句，则该类被放到一个默认包中（src 之下）

TestDemo1.java

package com.cero.demo1;

public class TestDemo1 {
}

不同的包中的类也可以互相导入并使用：

TestDemo2.java

package com.cero.demo2;

import com.cero.demo1.TestDemo1;

public class TestDemo2 {
    TestDemo1 testDemo = new TestDemo1();
}

常见的包

  1. java.lang 系统常用基础类（String、Object），此包自 JDK1.1 后自动导入
  2. java.lang.reflect java 反射编程包
  3. java.net 网络编程开发包
  4. java.sql 数据库开发包
  5. java.util java 工具程序包 。（重要）
  6. java.io I/O 编程开发包

static

静态成员变量

  • static 修饰的成员变量叫做静态成员变量，也叫类变量。存储在方法区。和 C++ 一样，是所有对象共享的。
    • 静态成员变量可以通过类名访问，也可以通过对象访问，更推荐通过类名访问
  • 静态成员变量的生命周期伴随整个类，也就是程序的声明周期，在进程启动时初始化，进程结束时销毁

特殊案例：

public class Student {
    String name;
    String sex;
    String no;
    public static String classes;
}

public class TestDemo {
    public static void main(String[] args) {
        Student student1 = null;
        student1.classes = "计算机231"; // 虽然 student1 引用 null，但是并不会抛出空指针异常
        System.out.println(student1.classes);
    }
}

静态方法

  • static 修饰的方法叫做静态方法
  • 静态方法没有 this 引用，不能访问非静态成员

静态成员变量初始化

静态成员变量可以就地初始化，也可以通过代码块初始化。

代码块

使用 {} 定义的一段代码称为代码块，根据代码块定义的位置以及关键字，又可分为以下四种

  1. 普通代码块（本地代码块）

    定义在方法中的代码块

    public class TestDemo {
    public static void main(String[] args) {
        {
            System.out.println("haha");
        }
    }
}

    这种用法比较少。

  2. 实例代码块（构造代码块）

    写在类中，优先于构造方法执行，类似于 C++ 的初始化列表

    例：

    public class Student {
    private String name;
    private int age;
    private double score;
    public static String classes;

    {
        name = "haha";
        age = 20;
        score = 100;
        System.out.println("实例代码块，一般用来初始化实例（普通）成员变量");
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("调用带有3个参数的构造方法");
    }
}

    public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student("张三", 20, 88.5);
    }
}

    输出：

    实例代码块，一般用来初始化实例（普通）成员变量
调用带有3个参数的构造方法

    如果一个类有多个实例代码块，则按照定义的顺序执行

  3. 静态代码块

    一般用于初始化静态数据成员，比实例代码块更早执行

    static {
    classes = "计算机231";
    System.out.println("静态代码块，一般用于初始化静态数据成员");
}

    输出

    静态代码块，一般用于初始化静态数据成员
实例代码块，一般用来初始化实例（普通）成员变量
调用带有3个参数的构造方法

    注意：

    • 一个类的静态代码块最多只会执行一次，无论你 new 多少个这个类的对象
    • 如果一个类有多个静态代码块，则根据定义的顺序来执行
    • 实例代码块只在创建对象时执行，而静态代码块在第一次使用类的时候执行（可以不创建对象）

  4. 同步代码块（用不到）

内部类

定义在一个类的内部的类叫做内部类。当一个事物的内部有一部分需要一个完整的结构来描述，那么这个完整结构可以使用内部类。

内部类经过编译会生成独立的字节码文件 外部类名$内部类名.class

内部类分为四种

  1. 实例内部类（成员内部类）

    在外部需要使用 外部类名.内部类名 变量名 = 外部类对象的引用.new InnerClass() 的形式来实例化内部类对象

    class OuterClass {
    public int data1 = 10;
    private int data2 = 20;
    public static int data3 = 30;
    // 实例内部类
    class InnerClass {
        public int data4 = 40;
        private int data5 = 50;
        public  InnerClass() {
            System.out.println("InnerClass的构造方法");
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
    }
}

    输出：

    InnerClass的构造方法

    注意：

    • 实例内部类中不能定义静态成员变量，但是可以定义常量（static final 修饰）

    • 实例内部类中不能定义静态方法

    • 实例内部类可以直接访问外部类的任何成员，如果实例内部类的成员变量和外部类的成员变量重名，优先使用内部类自己的。如果非要使用外部类的，语法为 外部类类名.this.变量名。这说明：实例内部类中不仅包含自己的this，也包含了外部类的this

      class OuterClass {
    public int data1 = 10;
    private int data2 = 20;
    public static int data3 = 30;
    
    class InnerClass {
        public int data4 = 40;
        private int data5 = 50;
        private int data3 = 60; // data3重名
        
        public  InnerClass() {
            System.out.println("InnerClass的构造方法");
        }

        public void method() {
            System.out.println(data3); // 打印自己的data3
            System.out.println(OuterClass.this.data3); // 打印外部类的data3
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
        innerClass.method();
    }
}

      输出

      InnerClass的构造方法
60
30

    • 外部类不能直接访问内部类的成员，但是可以通过实例化内部类对象来访问

      // 一个外部类的方法
public void method() {
    InnerClass innerClass = new InnerClass();
    System.out.println(innerClass.data4);
}

    • 实例内部类所处的位置与外部类的成员是相同的，所以也可以用访问限定符修饰

  2. 静态内部类：被 static 修饰

    你可以将静态内部类当成外部类的一个静态成员，所以静态内部类的实例化不依赖于对象

    class OuterClass {
    public int data1 = 10;
    private int data2 = 20;
    public static int data3 = 30;
    
    static class InnerClass {
        public int data4 = 40;
        private int data5 = 50;
        public static int data6 = 60;

        InnerClass() {
            System.out.println("InnerClass()");
        }

        public void method() {
            System.out.println("innerclass的method方法");
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        // 静态内部类实例化
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
    }
}

    注意

    • 静态内部类没有外部类的this引用，所以不能直接访问外部类的非静态成员，如果要访问，可以先 new 一个外部类的对象出来

  3. 局部内部类：

    定义在方法中的内部类，几乎不用。

    只能在所在方法内部使用；不能被访问限定符修饰，static 修饰

  4. 匿名内部类

继承

Java 的父类与子类，构造

Java 中继承的关键字是 extends，Java 不支持多继承，即一个子类不可以有多个父类

class Animal {
    public String name;
    public int age;
    public String sex;

    public void eat() {
        System.out.println(this.name + "eat()");
    }
}
// 继承自Animal类
class Dog extends Animal {
    public void mew() {
        System.out.println(this.name + "cat::mew()");
    }
}
// 继承自Animal类
class Cat extends Animal {
    public void bark() {
        System.out.println("dog::bark()");
    }
}

  • 如果子类和父类中的成员重名，则优先访问自己的，如果要访问父类的，使用 super 关键字，super 可以看做是对子类对象的父类部分的引用

    class Base {
    public int a = 1;
    public int b = 2;
}

class Derived extends Base {
    public int a = 3;
    public int d = 4;

    public void test() {
        System.out.println(a); // 访问自己的a
        System.out.println(super.a); // 访问父类的a
    }
}

public class TestDemo2 {
    public static void main(String[] args) {
        new Derived().test();
    }
}

    输出

    3
1

super

  • super 和 this 一样，不能在静态方法中使用

  • super() 用来调用父类的构造方法，和 this() 一样，必须放在构造方法的第一行。用户不写 super()，编译器也会隐式地调用父类的默认构造，但是 this() 用户不写则没有；这说明：子类的构造，是先构造父类部分，然后再构造自己特有的部分

  • 编译器给子类中生成的默认构造相当于：

    class B extends A {
    B() {
        super();
    }
}

注意：

  • 父类中的 private 成员，在子类中无法访问，并不是因为没有继承这个成员，只是受到了访问限定符的限制

  • 如果父类和子类中都写了各自的静态代码块，实例代码块，构造方法。那么构造子类时的执行顺序是：

    父类的静态 子类的静态 父类的实例 父类的构造 子类的实例 子类的构造

    总结一下就是，首先静态优先，其次父类优先，最后实例优先

final

  • final 修饰的类叫做 密封类，不可被继承。
  • final 修饰的变量叫常量，不可被修改，注意：final 修饰数组时，表示这个数组引用的指向不可变，并不是表示数组里的内容不可变
  • final 修饰方法，表示该方法不可被重写

多态

向上转型

父类的引用可以指向子类的对象，这叫做向上转型，达成向上转型的方式有：直接赋值，方法转参和方法的返回值

向上转型后的父类引用依然只能访问父类自己的成员

重写

子类与父类中的两个方法，如果返回类型相同，方法名相同，参数列表相同，但实现的方法体不同，则这两个方法构成重写，称子类重写了父类的方法。

重写的方法上面加 @Override 注解，可以用来帮助我们进行合法性校验

构成重写的两个方法的方法名和参数列表都相同，当向上转型后的父类引用要调用时，实际上调用的是子类重写的那个，而不会调用父类原本的方法。

注意：

  • 静态方法、private 方法、被 final 修饰的方法 不能进行重写
  • 重写的子类方法的访问修饰符限定范围要大于等于父类
  • 协变：即使返回类型不同，也有可能构成重写：当这两个方法的返回值也是父子关系，且父类中的被重写的方法的返回值是父，子类中进行重写的方法的返回值是子，那么也构成重写，也叫协变关系。

多态

通过父类引用调用重写的方法，在代码运行时，传递不同类的子类对象可以调用不同的方法，这就是多态的体现

class Animal {
    public void eat() {
        System.out.println("进食");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("吃狗粮");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃猫粮");
    }
}

public class TestDemo {

    static void function(Animal animal) {
        animal.eat(); // 同样一个语句，却输出了两种结果
    }
    public static void main(String[] args) {
        function(new Dog());
        function(new Cat());
    }
}

输出

吃狗粮
吃猫粮

注：

静态绑定：也称前期绑定（早绑定），即在编译时，根据用户所传递实参类型就确定了具体调用的方法。典型代表是方法重载

动态绑定：也称后期绑定（晚绑定），即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用哪个类的方法

向下转型

Java 也可以向下转型，但用得比较少，而且不安全

class Animal {
    public void eat() {
        System.out.println("进食");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("吃狗粮");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃猫粮");
    }
}

class Bird extends Animal {
    public void fly() {
        System.out.println("正在飞");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Animal animal = new Bird();
        Bird bird = (Bird) animal; // 向下转型，将父类转回子类，需要强制类型转换
        bird.fly();
    }
}

输出：

正在飞

不安全在哪里呢？如果你这样写：

public class TestDemo {
    public static void main(String[] args) {
        Animal animal = new Dog(); // new 的是 Dog 类
        Bird bird = (Bird) animal;
        bird.fly();
    }
}

编译通过，但是运行时会抛 ClassCastException 异常，狗转成鸟，这不合理，当然不能强制转换。

为了提高向下转型的安全性，可以使用 instanceof 判断一个对象是不是一个类的实例：

public class TestDemo {
    public static void main(String[] args) {
        Animal animal = new Dog();
        if (animal instanceof Bird) { // 判断animal指向的对象是不是Bird类的实例，这里不是，返回false
            Bird bird = (Bird) animal;
            bird.fly();
        }
    }
}

多态的优点案例

public static void drawShapes() {
    Rect rect = new Rect();
    Cycle cycle = new Cycle();
    Flower flower = new Flower();
    String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
    for (String shape : shapes) {
        if (shape.equals("rect")) {
            rect.draw();
        } else if (shape.equals("cycle")) {
            cycle.draw();
        } else if (shape.equals("flower")){
            flower.draw();
        }
    }
}

可改写为

public static void drawShapes() {
    Rect rect = new Rect();
    Cycle cycle = new Cycle();
    Flower flower = new Flower();
    Shape[] shapes = {cycle, rect, cycle, rect, flower};
    for (Shape shape : shapes) {
        shape.draw();
    }
}

多态的坑

class B {
    public B() {
        func();
    }

    public void func() {
        System.out.println("B.func()");
    }
}

class D extends B {
    @Override
    public void func() {
        System.out.println("D.func()");
    }
}

public class Test {
    public static void main(String[] args) {
        new D();
    }
}

输出：

D.func()

解析：new D() 会调用 D 的构造方法，D 的构造方法会先调用 B 的构造方法，B 的构造方法调用 func() ，打印了 D.func()。这说明它调用的是 D 的 func() 而不是 B 它自己的。为什么？因为这里触发了动态绑定，因为子类重写了就去调用子类的了（即使子类对象还没构造完成）

所以，尽量不要在构造方法里调用其他成员方法

抽象类和接口

抽象类

在面向对象的概念中，所有的对象都是由类来描绘的，但反过来，并不是所有的类都是用来描绘对象的。当一个类不能完整地描述一个对象时，这个类就是抽象类

抽象类使用 abstract 关键字修饰，abstract 修饰的方法，就是抽象方法

  • 抽象类不能被实例化；普通类能够定义的成员，抽象类也可以定义
  • 抽象类存在的最大意义就是为了被继承，被继承的抽象类也是父类，可以发生向上转型、多态
  • final 和 abstract 关键字不能共存，抽象方法也不能是 private 访问权限
  • 当一个普通的类，继承了抽象类之后，那么这个普通类必须重写抽象类中所有的抽象方法
  • 当一个抽象类 A，继承了抽象类 B，那么 A 可以不重写 B 的抽象方法，如果有一个普通类继承了 A，那么它必须重写所有的抽象方法
  • 抽象类不一定有抽象方法，抽象方法所在的类一定是抽象类

接口

Java 中，接口可以看成是多个类的公共规范，是一种引用数据类型，接口不是类，但可以看成一种特殊的类

接口定义

接口使用 interface 关键字来定义

  • 接口中的方法只能是抽象方法。所有的方法，默认都是 public abstract 修饰
  • 接口中的成员变量，默认都是 public static final 修饰
  • 接口中使用 default 来修饰的方法叫做默认方法，你可以在接口中实现默认方法，后续的实现类可以选择性地重写默认方法
  • 接口中的静态方法，也可以有具体的实现
interface IShape {
    // 成员变量
    int a = 10; // public static final 修饰的成员变量
    // 成员方法
    // 默认方法，有实现
    default void func() {
        System.out.println("默认的方法");
    }
	// 静态方法，有实现
    public static void staticFunc() { 
        System.out.println("静态方法");
    }

    void draw(); // public abstract 修饰的方法
}
  • 接口不能进行实例化，那么当然也不能有代码块和构造方法

实现接口

  • 一个普通类，可以通过 implements 来实现接口，且必须实现所有的抽象方法，否则你只能把它定义为抽象类

例：

// USB接口
interface USB {
    void openDevice();
    void closeDevice();
}

//鼠标类，实现USB接口
class Mouse implements USB {
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }

    public void click() {
        System.out.println("鼠标点击");
    }
}

class KeyBoard implements USB {
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }

    public void inPut() {
        System.out.println("键盘输入");
    }
}

class Computer {
    public void powerOn() {
        System.out.println("打开电脑");
    }

    public void powerOff() {
        System.out.println("关闭电脑");
    }

    public void useDevice(USB usb) {
        usb.openDevice();
        if (usb instanceof Mouse) {
            Mouse mouse = (Mouse) usb;
            mouse.click();
        } else if (usb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }

}

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();
        // 使用鼠标设备
        computer.useDevice(new Mouse());
        // 使用键盘设备
        computer.useDevice(new KeyBoard());

        computer.powerOff();
    }
}

输出：

打开电脑
打开鼠标
鼠标点击
关闭鼠标
打开键盘
键盘输入
关闭键盘
关闭电脑
  • 接口虽然不是类，但是编译完的字节码文件也是 .class 后缀

一个类实现多个接口

一个类可以实现多个接口，这是 Java 对单继承的一个补充

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println("进食");
    }
}

interface IFlying {
    void fly();
}

interface IRunning {
    void run();
}

interface ISwimming {
    void swim();
}

// 狗类实现跑和游泳两个接口
class Dog extends Animal implements IRunning, ISwimming {
    @Override
    public void run() {
        System.out.println(this.name + " 正在跑");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳");
    }
}

接口也可以发生向上转型，实现多态

package demo1;

class Animal {
    public Animal() {}
    public Animal(String name) {
        this.name = name;
    }
    public String name;
    public void eat() {
        System.out.println("进食");
    }
}

interface IFlying {
    void fly();
}

interface IRunning {
    void run();
}

interface ISwimming {
    void swim();
}

// 狗类实现跑和游泳两个接口, 表示狗是动物，具备跑和跳的能力
class Dog extends Animal implements IRunning, ISwimming {
    public Dog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + " 正在跑");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳");
    }
}

// 鸟是动物，能飞
class Bird extends Animal implements IFlying {
    public Bird(String name) {
        super(name);
    }

    @Override
    public void fly() {
        System.out.println(this.name + " 正在飞");
    }
}

// 机器人不是动物，能跑、游泳、飞
class Robot implements IRunning, ISwimming, IFlying {
    @Override
    public void fly() {
        System.out.println("机器人正在飞");
    }

    @Override
    public void run() {
        System.out.println("机器人正在跑");
    }

    @Override
    public void swim() {
        System.out.println("机器人 正在游泳");
    }
}

public class Test {
    // 具备飞能力的就可以调用这个方法
    static void func1(IFlying iFlying) {
        iFlying.fly();
    }

    // 具备游泳能力的可以调用这个方法
    static void func2(ISwimming iSwimming) {
        iSwimming.swim();
    }

    // 具备跑能力的可以调用这个方法
    static void func3(IRunning iRunning) {
        iRunning.run();
    }

    // 动物可以调用这个方法
    static void func4(Animal animal) {
        animal.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("旺旺");
        Bird bird = new Bird("唧唧");
        Robot robot = new Robot();
        func1(bird);
        func2(robot);
        func3(dog);
    }
}

接口继承

接口之间可以用 extends 来继承

interface A {
    void funcA();
}

interface B {
    void funcB();
}

// C 拓展了 A、B
interface C extends A, B {
    void funcC();
}

// 实现C的普通类，要重写所有抽象方法
class AA implements C {
    @Override
    public void funcA() {
        
    }

    @Override
    public void funcB() {

    }

    @Override
    public void funcC() {

    }
}

常用接口

Comparable

下面介绍一个常用接口，Comparable，T 为模板参数

一个类通过重写这个接口中的 compareTo() 方法，来实现对这个类的对象的比较。

// 实现 Comparable 接口
class Student implements Comparable<Student> {
    public String name;
    public int age;
    public double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    // 重写接口中的 compareTo() 方法，指定按 age 比较
    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}

然后，我们就可以使用 Arrays.sort() 对 Student 对象按 age 进行排序

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan", 66, 78.9);
        students[1] = new Student("lisi", 32, 96.4);
        students[2] = new Student("wangwu", 100, 25.5);

        Arrays.sort(students);

        System.out.println(Arrays.toString(students));
    }
}

输出

[Student{name='李四', age=32, score=96.4}, Student{name='张三', age=66, score=78.9}, Student{name='王五', age=100, score=25.5}]

将 return this.age - o.age; 改为 return o.age - this.age; 则按降序排序

注：

  • Java 不支持运算符重载，如果使用小于号 <，比较的只是两个对象的引用

  • 我们所熟知的 String 数据类型也实现了 Comparable，所以我们可以使用 compareTo() 来进行字符串比较

    String str1 = "apple";
String str2 = "banana";

// 使用 compareTo 方法比较字符串
int result = str1.compareTo(str2);
// result 的值为负数，因为 "apple" 在字典顺序中小于 "banana"
Comparator

类似于 C++ 中的仿函数，我们可以在 Student 类外，来指定比较方法

class Student {
    public String name;
    public int age;
    public double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

// 实现了Comparator接口的类
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan", 66, 78.9);
        students[1] = new Student("lisi", 32, 96.4);
        students[2] = new Student("wangwu", 100, 25.5);

        Arrays.sort(students, new AgeComparator()); // 传入第二个参数，指定比较方式

        System.out.println(Arrays.toString(students));
    }
}
Cloneable接口和深拷贝

Cloneable 是一个空接口，又叫标记接口，里面没有方法。

一个类实现 Cloneable 表示该类是可以被克隆的。

然后，我们需要重写从 Object 类继承下来的 clone() 方法

package demo3;


class Money {
    public double money = 99.9;
}

// 实现 Cloneable 接口，表示该类的对象是可以被克隆的
class Person implements Cloneable {
    public String id = "1234";
    public Money m = new Money();

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                ", money=" + m +
                '}';
    }

    // 重写clone方法，返回值可以是任意引用类型，因为原clone方法返回类型是Object，这里利用了协变
    @Override
    public Person clone() {
        try {
            Person clone = (Person) super.clone();
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = person1.clone(); // 产生一个副本

        // 改变 person2 的 m.money
        person2.m.money = 100;
        // 打印两个 Person 的 m.money 会发现都变成 100 了
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
        // 打印两个 Person 的 m 引用，发现一样
        System.out.println(person1.m);
        System.out.println(person2.m);
    }
}

输出：

100.0
100.0
demo3.Money@1b6d3586
demo3.Money@1b6d3586

但是这只是一个浅拷贝，并没有创建一个新的 Money 对象，只是多个一个引用而已，所以两个 Person 对象会共享一个 money。

注意到 IDEA 在自动生成的 clone() 方法里面贴心地写了个 TODO 注释，让我们稍后在这个地方完成深拷贝。

具体步骤，在克隆的时候，将 m 也克隆一次，然后赋给新对象的 m 引用，为了使 m 可以克隆，需要让 Money 类实现 Cloneable 接口，并重写 clone() 方法

// 将 Money 也标记为可克隆的，并重写clone()方法
class Money implements Cloneable{
    public double money = 99.9;

    @Override
    public Money clone() {
        try {
            return (Money) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

// 实现 Cloneable 接口，表示该类的对象是可以被克隆的
class Person implements Cloneable {
    public String id = "1234";
    public Money m = new Money();

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                ", money=" + m +
                '}';
    }

    // 重写clone方法
    @Override
    public Person clone() {
        try {
            Person clone = (Person) super.clone();
            clone.m = this.m.clone(); // 将 m 也克隆一份，传给新对象里的 m
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = person1.clone(); // 产生一个副本

        // 改变 person2 的 m.money
        person2.m.money = 100;
        // 打印两个 Person 的 m.money 会发现不一样了，深拷贝成功
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
    }
}

输出

99.9
100.0

Object 类

Object 类是所有类的父类，所以 Object 类型的引用可能指向任意引用类型的对象

一个存了不同类型的对象的数组：

public class Test {
    public static void main(String[] args) {
        // 创建 Object 数组
        Object[] objectArray = new Object[3];

        // 存储不同类型的对象
        objectArray[0] = "Hello";
        objectArray[1] = 42;
        objectArray[2] = new SomeObject();

        // 访问数组中的对象
        for (Object obj : objectArray) {
            System.out.println(obj);
        }
    }
}

class SomeObject {
    // 这是一个简单的自定义类
}

输出：

Hello
42
demo3.SomeObject@1b6d3586

可以存 int 是因为这里发生了自动装箱，int 被转成 Integer 类了。

下面简单介绍 Object 类的几个常用方法

获取对象信息

toString() 在 Object 类中的实现：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

我们可以根据自己的需要去重写这个方法

equals()方法

equals() 在 Object 类中的实现：

public boolean equals(Object obj) {
    return (this == obj);
}

这个实现和直接用 == 没区别，都是比较引用，要比较对象内的数据，需要我们自己去重写这个方法。

hashcode()方法

这是一个本地方法，用来计算一个对象的 hash 值

String 类

  • Java 中，没有 \0 是字符串结尾的说法

常用操作

字符串构造

// 使用常量字符串构造
String s1 = "Hello";
// 使用 new 构造
String s2 = new String("Hello");
// 使用字符数组构造
char[] array = {'a', 'b', 'c'};
String s3 = new String(array);

查看 String 的实现，其实用的是字符数组来存储数据

跨越编程界限：C++到JavaSE的平滑过渡_第4张图片

字符串比较

// 比较两个字符串的引用
s1 == s2;
// 比较两个字符串是否相同
s1.equals(s2);
// 比较两个字符串的大小
s1.compareTo(s2);
// 忽视大小写比较是否相同
s1.equalsIgnoreCase(s2);

字符串查找

方法 功能
char charAt(int index) 返回下标 index 处的字符
int indexOf(int ch) 返回 ch 第一次出现的位置，没有返回-1
int indexOf(int ch, int fromIndex) 从 fromIndex 位置开始找 ch 第一次出现的位置，没有返回-1
int indexOf(String str) 返回 str 第一次出现的位置，没有返回-1
int indexOf(String str, int fromIndex) 从 fromIndex 位置开始找 str 第一次出现的位置，没有返回-1
int lastIndex() 从后往前找，提供的重载和上面相同

转化

数值字符串转化

// 1.字符串转整数
String str1 = "123";
int intValue1 = Integer.parseInt(str1);
    // 或使用 valueOf 方法，该方法会将返回值装箱
Integer intValue2 = Integer.valueOf(str1);
// 2.字符串转浮点数
String str2 = "123.45";
float floatValue1 = Float.parseFloat(str2);
    // 或使用 valueOf 方法，该方法会将返回值装箱
Float floatValue2 = Float.valueOf(str2);
// 3.整数转字符串
int intValue3 = 123;
String str3 = String.valueOf(intValue3);
    // 或者使用 Integer 类的 toString 方法：
String str4 = Integer.toString(intValue3);
// 4.浮点数转字符串
float floatValue3 = 123.45f;
String str5 = String.valueOf(floatValue3);
    // 或者使用 Float 类的 toString 方法：
String str6 = Float.toString(floatValue3);

大小写转换

// 1.将字符串转换为大写
String originalString = "Hello, World!";
String upperCaseString = originalString.toUpperCase();
System.out.println(upperCaseString);
// 输出: HELLO, WORLD!

// 2.将字符串转换为小写
String lowerCaseString = originalString.toLowerCase();
System.out.println(lowerCaseString);
// 输出: hello, world!

// 3.将字符转换为大写
char originalChar1 = 'a';
char upperCaseChar = Character.toUpperCase(originalChar1);
System.out.println(upperCaseChar);
// 输出: A

// 4.将字符转换为小写
char originalChar2 = 'A';
char lowerCaseChar = Character.toLowerCase(originalChar2);
System.out.println(lowerCaseChar);
// 输出: a

注意，这些方法返回新的字符串或字符，而不是修改原始的字符串或字符。

字符串与数组间的转换

// 1.字符串转换为字符数组
String str1 = "Hello, World!";
char[] charArray1 = str1.toCharArray();
System.out.println(Arrays.toString(charArray1));
// 输出: [H, e, l, l, o, ,,  , W, o, r, l, d, !]

// 2.字符串转换为字节数组（使用默认字符集）
byte[] byteArray = str1.getBytes();
System.out.println(Arrays.toString(byteArray));
// 输出: [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]

// 3.字节数组转换为字符串（使用默认字符集）
String str2 = new String(byteArray);
System.out.println(str2);
// 输出: Hello, World!

// 4.字符数组转换为字符串
char[] charArray2 = {'H', 'e', 'l', 'l', 'o'};
String str = new String(charArray2);
System.out.println(str);
// 输出: Hello

格式化

// 1.基本格式化
String name = "Alice";
int age = 30;
String formattedString1 = String.format("Name: %s, Age: %d", name, age);
System.out.println(formattedString1);
// 输出: Name: Alice, Age: 30

// 2.指定小数点后的位数
double pi = Math.PI;
String formattedString2 = String.format("Value of pi: %.2f", pi);
System.out.println(formattedString2);
// 输出: Value of pi: 3.14

// 3.日期格式化
Date currentDate = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
String formattedDate = dateFormat.format(currentDate);
System.out.println(formattedDate);
// 输出类似: 2023-11-12

// 4.左对齐、宽度补齐
String text = "Java";
String formattedString3 = String.format("|%10s|", text);
System.out.println(formattedString3);
// 输出: |      Java|

// 5.使用位置参数
String firstName = "John";
String lastName = "Doe";
String formattedString4 = String.format("Last Name: %2$s, First Name: %1$s", firstName, lastName);
System.out.println(formattedString4);
// 输出: Last Name: Doe, First Name: John

替换

String originalString = "Hello, World!";
String replacedString = originalString.replace("World", "Java");

System.out.println("Original String: " + originalString);
System.out.println("Replaced String: " + replacedString);
/*输出：
Original String: Hello, World!
Replaced String: Hello, Java!
*/

分割字符串

String str = "abc def ghi";
String[] strings = str.split(" "); // 按空格分割
for (String s : strings) {
    System.out.println(s);
}
/*输出：
abc
def
ghi
*/
  • 如果分割符是 . | * + \，需要加上转义字符，比如要表示 . ，就应该写成 \\. 要表示 \ 应该写成 \\\\
  • 如果一个字符串中有多个分隔符，可以用 | 作为连字符

字符串截取

String str = "abcdefghi";
String ret = str.substring(2, 7); // 截取下标 [2, 7) 范围的字符串
System.out.println(ret);
// 输出：cdefg

去掉左右空格

String str = "  Hello world   ";
String ret = str.trim();
System.out.println(ret);
//输出：Hello world

字符串常量池

String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");
System.out.println(str1 == str2); // true
System.out.println(str1 == str3); // false

为什么 str1 和 str2 引用的是同一个，而 str3 不是呢？这就和字符串常量池有关了

  • 字符串常量池就是 StringTable，存储在堆区，StringTable 是一个哈希表，它的键是字符串的内容，而值是对字符串对象的引用。
  • 只要是双引号引起来的元素，全都存放在常量池中，且只有一份
  • 当你使用双引号创建字符串常量时，Java 会尝试在字符串池中查找是否已经存在相同内容的字符串，如果存在，就返回对该字符串的引用，如果不存在，就在字符串池中创建一个新的字符串并返回引用。

上述代码的存储结构：

跨越编程界限：C++到JavaSE的平滑过渡_第5张图片

创建 s1 的时候，从 StringTable 中找 “hello”，没找到，创建 String 对象，存入 StringTable，返回引用给 s1

创建 s2 的时候，从 StringTable 中找 “hello”，找到了，所以直接返回 String 对象的引用，所以 s1 引用和 s2 引用相同

创建 S3 ，因为是显式地 new 出来，所以会创建一个新的 String 对象并返回引用，然后从 StringTable 中找“hello”，找到后返回引用给到 String 对象里的 value 数组引用。所以 s3 和 s1、s2 不同，但 s3 指向的对象里的 value 和它们是相同的

总结：只要 new 的对象，返回的引用都是唯一的；使用常量字符串创建 String 对象的效率更高，而且更节省空间。

特殊案例：

String str1 = "hello";
String str2 = "he" + "llo"; // 因为是常量，在编译的时候就被当做 "hello" 了
System.out.println(str1 == str2); // true

String str1 = "hello";
String str2 = "he";
String str3 = "llo";
String str4 = str2 + str3; // 因为是变量，在编译的时候，还不知道结果是什么
System.out.println(str1 == str4); // false

str2 + str3 是在运行时拼起来的，而不是通过 "" 创建的，所以它的结果不会放在常量池，返回的引用也就不一样

intern 方法

intern 是一个 native 方法，该方法的作用是手动将创建的 String 对象添加到常量池中

char[] ch = {'h', 'e', 'l', 'l', 'o'};
String str1 = new String(ch);
str1.intern();
String str2 = "hello";
System.out.println(str1 == str2); // true

第 2 行，由于不是常量字符串，“hello” 并不会加入常量池

第 3 行，使用 intern 手动加入常量池，会将 <"hello", str1> 这个键值对存入 StringTable。

第 4 行，从常量池中找 “hello”，找到，直接返回 String 对象的引用，也就是第 2 行创建的那个引用

所以最后的 str1 和 str2 相等。

字符串不可变

  • String 类中的字符实际上是由一个 value 字符数组存储，这个数组由 private final 修饰，表示这是私有成员，我们无法访问，value 的指向也不能发生改变。
  • String 类提供的修改操作都不是原地修改，而是返回了一个新的 String 对象

这意味着，String 对象是不可变（immutable）的，一旦创建了 String 对象，它的内容就不能被修改。

String str = "Hello";
str = str + " World"; // 创建了一个新的字符串对象给str引用，而不是修改原始字符串，原字符串对象将被回收

为什么 String 要设计成不可变的？

  • 方便实现字符串对象池，如果 String 可变，那么对象池就需要考虑写时拷贝的问题
  • 不可变对象是线程安全的
  • 不可变对象更方便缓存 hashcode，作为 key 时可以更高效地保存到 HashMap 中。

既然 String 是不可变，那么如果我写出这样的代码：

public static void main(String[] args) {
    String str = "hello";
    for (int i = 0; i < 10; ++i) {
        str += i;
    }
}

这段代码在循环中使用 += 拼接字符串，会产生大量的临时对象，性能是非常低的。

StringBuilder和StringBuffer

对于需要频繁修改的字符串，建议使用 StringBuilder

public static void main(String[] args) {
    StringBuilder str = new StringBuilder("hello");
    for (int i = 0; i < 10; ++i) {
        str.append(i);
    }
    System.out.println(str);
}

StringBuilder 和 StringBuffer 类是可变的字符串类。这两个类允许你进行高效的字符串操作，而不会频繁创建新的对象。在这两者之间，StringBuilder 是非线程安全的，而 StringBuffer 是线程安全的，但在单线程环境中，通常建议使用 StringBuilder，因为它的性能更好。

逆置字符串

reverse() 方法是 String 中没有的，StringBuilder 和 StringBuffer 中有，并且是原地修改

StringBuffer str = new StringBuffer("hello");
str.reverse();
System.out.println(str);
// 输出：olleh

拼接字符串

public static void main(String[] args) {
    StringBuilder stringBuilder = new StringBuilder();

    // 追加字符串
    stringBuilder.append("Hello");
    stringBuilder.append(" World");

    System.out.println(stringBuilder); // 输出 "Hello World"
}

面试题：

  1. String、StringBuffer、StringBuilder 的区别

    • String 的内容不可修改，StringBuffer 与 StringBuilder 的内容可以修改
    • StringBuffer 与 StringBuilder 大部分功能是相似的
    • StringBuffer 采用同步处理，属于线程安全操作；而 StringBuilder 未采用同步处理，属于线程不安全操作

  2. 以下代码创建了几个对象

    String str = new String("a");

    创建了两个对象，字符串常量池中的对象和强制 new 出来的堆中的对象。这种做法通常是不推荐的

    String str = new String("a") + new String("b");

    创建了6个对象，字符串常量池中的1个“a”对象，1个“b”对象，堆中的1个“a”对象，1个“b”对象，一个拼接的StringBuilder对象“ab”，为了赋给str转为String的对象“ab”

异常

Java 异常结构图

跨越编程界限：C++到JavaSE的平滑过渡_第6张图片

  1. Throwable：异常体系的顶层类，其派生出两个重要的子类，Error 和 Exception
  2. Error：指 JVM 无法解决的严重问题，如 JVM 内部错误，资源耗尽等。典型代表：StackOverflowError 和 OutOfMemoryError
  3. Exception：异常产生后程序可以通过代码进行处理，使程序继续执行

异常的分类

受查异常（编译时异常）

在程序编译期间发生的异常，称为受查异常，如 clone 方法，会抛出此异常。上图蓝色部分即受查异常

非受查异常（运行时异常）

在程序运行期间发生的异常，称为非受查异常，如空指针异常，数组越界异常。上图红色部分即非受查异常

异常的处理

防御式编程

LBYL：Look Before You Leap，每一步操作都进行检查

事后认错型

EAFP：It’s Easier to Ask Forgiveness than Permission，先把操作都放在一块，遇到了问题再处理

public static void main(String[] args) {
    int[] array = {1, 2, 3, 4, 5};
    try {
        System.out.println(array[9]);
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("捕获到一个数组越界的异常！");
        e.printStackTrace();
    }
}
/*输出：
捕获到一个数组越界的异常！
java.lang.ArrayIndexOutOfBoundsException: 9
	at demo3.Test.main(Test.java:7)
*/

异常也可以抛出，但如果抛给 JVM 了，程序就会异常终止。

static void func() {
    throw new NullPointerException();
}
public static void main(String[] args) {
    int[] array = {1, 2, 3, 4, 5};
    try {
//            System.out.println(array[9]);
        func();
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("捕获到一个数组越界异常！");
        e.printStackTrace();
    } catch (NullPointerException e) {
        System.out.println("捕获到一个空指针异常！");
        e.printStackTrace();
    }
}

多个 catch 块，分别处理异常

static void func() {
    throw new NullPointerException();
}
public static void main(String[] args) {
    int[] array = {1, 2, 3, 4, 5};
    try {
//            System.out.println(array[9]);
        func();
    } catch (ArrayIndexOutOfBoundsException | NullPointerException e) { // 一条catch可以捕获多种异常，用 | 分隔
        System.out.println("捕获到一个数组越界异常或空指针异常！");
        e.printStackTrace();
    }
}

一条catch可以捕获多种异常，用 | 分隔。

使用 throws 可以声明一个方法会抛异常，如果有多种异常会抛出，可以用 , 分隔

static void func() throws NullPointerException{
    throw new NullPointerException();
}

注意：

  • throw 必须写在方法体内部
  • 抛出的对象必须是 Exception 类或者其子类的对象
  • 运行时异常可以不用处理，交给 JVM 来处理，异常终止程序
  • 如果你使用了一个可能抛出编译时异常的方法，那么要么使用 try-catch 块捕获这个异常，要么在方法签名中使用 throws 关键字声明这个异常，否则无法通过编译。

finally

在 catch 的最后，还可以写一个 finally 块。

不管异常是否发生，finally 都会在方法结束的前执行。

finally 常用来关闭资源

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    try {
        System.out.println("一些代码");
    } catch (Exception e) {
        System.out.println("一些异常处理");
    } finally {
        scanner.close();
    }
}

特殊案例：

public static int func() {
    try {
        return 10;
    } finally {
        return -1;
    }
}
public static void main(String[] args) {
    System.out.println(func());
}
// 输出：-1

因为 finally 是一定会被执行的，所以就算 try 里面 return 了，方法也不会结束，而是继续执行 finally 的语句，所以返回值被 -1 覆盖了

注：尽量不要在 finally 里使用 return

异常处理流程

  • 程序先执行 try 中的代码
  • 如果 try 中的代码出现异常，就会结束 try 中的代码，看 catch 中的异常类型是否匹配
  • 如果找到匹配的异常类型，就会执行 catch 中的代码，执行完 catch 块，程序继续运行 catch 块后面的代码
  • 如果没有找到匹配的异常类型，就会将异常向上传递给上层调用者
  • 无论是否找到匹配的异常类型，finally 块都会被执行（在该方法结束前）
  • 如果上层调用者也没有处理异常，就继续向上传递
  • 直到 main 方法也没有处理异常，就会交给 JVM 来处理，此时程序就会异常终止

自定义异常

如果要自定义一个异常，那么需要继承一个异常类，一般建议继承这2个中的一个：

  1. Exception 【默认是一个编译时异常】
  2. RuntimeException【默认是一个运行时异常】
public class UserNameErrorException extends RuntimeException{
    public UserNameErrorException() {
    }

    public UserNameErrorException(String message) {
        super(message);
    }
}

public class PasswordErrorException extends RuntimeException {
    public PasswordErrorException() {
    }

    public PasswordErrorException(String message) {
        super(message);
    }
}

class Login {
    private String userName = "admin";
    private String password = "123456";
    public void loginInfo(String userName, String password) throws UserNameErrorException {
        if (!this.userName.equals(userName)) {
            throw new UserNameErrorException("这是一个用户名异常的参数");
        }
        if (!this.password.equals(password)) {
            throw new PasswordErrorException("这是一个密码异常的参数");
        }
    }
}

public class TestDemo {
    public static void main(String[] args) {
        try {
            new Login().loginInfo("admin1", "12345");
        } catch (UserNameErrorException | PasswordErrorException e) {
            e.printStackTrace();
        }
    }
}

/*输出：
    Exception in thread "main" demo4.UserNameErrorException: 这是一个用户名异常的参数
	at demo4.Login.loginInfo(TestDemo.java:8)
	at demo4.TestDemo.main(TestDemo.java:18)
*/

你可能感兴趣的:(Java,开发语言,java,intellij-idea,jvm)

  • 基于javaweb的城乡居民基本医疗信息管理系统设计与开发论文 小蒜学长 javatomcatmavencsshtml5vue.js
    摘要信息数据从传统到当代，是一直在变革当中，突如其来的互联网让传统的信息管理看到了革命性的曙光，因为传统信息管理从时效性，还是安全性，还是可操作性等各个方面来讲，遇到了互联网时代才发现能补上自古以来的短板，有效的提升管理的效率和业务水平。传统的管理模式，时间越久管理的内容越多，也需要更多的人来对数据进行整理，并且数据的汇总查询方面效率也是极其的低下，并且数据安全方面永远不会保证安全性能。结合数据内
  • org.apache.commons.lang.math.NumberUtils#isNumber 解释 秋夫人 javajava
    源码/***CheckswhethertheStringavalidJavanumber.**Validnumbersincludehexadecimalmarkedwiththe0x*qualifier,scientificnotationandnumbersmarkedwithatype*qualifier(e.g.123L).**NullandemptyStringwillreturn*fa
  • Spring系列之设计模式 johnny233 设计模式Springspring设计模式
    Spring作为Java世界当之无愧的No.1开源框架，其架构设计非常优秀，使用很多设计模式。注：本文参考Spring-6.1.5版本源码；本文目录设置参考设计模式三大类来划分，Spring家族包括Spring、SpringMVC、SpringBoot、SpringCloud、SpringData等，总之Spring源码博大精深；某一种设计模式会在若干个Spring接口、类、或模块里有所体现，不可
  • SpringBoot JPA Puny丶微芒
    定义JPA是JavaPersistenceAPI的简称，中文名Java持久层API，是JDK5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA的总体思想和现有Hibernate、TopLink、JDO等ORM框架大体一致。总的来说，JPA包括以下3方面的技术：1.ORM映射元数据JPA支持XML和JDK注解两种元数据的形式，元数据描述对象和表之间的映射关系，
  • 构造函数初始化列表 Jowney
    一、抛砖引玉--抛转在写C++类的时候你应该有一个疑问！C++中,类的成员变量在定义的时候为什么不直接初始化?为什么？为什么？为什么？classStu//声明一个学生类{private://私有成员关键字charName[32]="张三";//姓名intID=1;//学号intScore=001;//成绩};因为Java是自动挡汽车，C++是手动挡汽车。在java里这样写是没毛病的，因为Java已
  • JavaScript 中，不同的赋值方式适用场景 前端小芬芬 javascript
    在JavaScript中，不同的赋值方式适用于不同的场景。以下是每种赋值方式的详细解释和使用场景：1.使用扩展运算符...进行浅拷贝letobj={...data};功能：创建一个新的对象，并将data对象的所有可枚举属性复制到新对象中。适用场景：适用于简单对象的浅拷贝，特别是当对象的属性不包含嵌套对象或数组时。示例：letdata={a:1,b:2};letobj={...data};conso
  • springboot 单体服务运行bat脚本 bencolyy javaspringbootjavalinux
    springboot服务一般是打包成jar运行在windows服务器上面一般是cmd窗口输入命令启动服务，或者注册成windows服务开机启动，今天写了一个简单的bat脚本,输入参数重新运行指定jar包@echooffsetlocalenabledelayedexpansionchcp65001echo=echospringboot服务运行脚本echo=echo注意运行命令前需要配置【java环境
  • 记一次 mvn sonar:sonar做代码审查时的异常处理 ...Runtime only recognizes class file versions up to 52.0 阿松哥哥2018 javamaven
    记一次mvnsonar:sonar做代码审查时的异常处理Causedby:java.lang.UnsupportedClassVersionError:org/sonarsource/scanner/maven/SonarQubeMojohasbeencompiledbyamorerecentversionoftheJavaRuntime(classfileversion55.0),thisver
  • 【spring】Spring的aop 闲着无聊整些资料 Springspringjava后端
    之前的文章中我们介绍了Spring的控制反转和依赖注入，今天来详细说说Spring的aop。aop（AspectOrientedProgramming）即面向切面编程，它是Spring提出的一种思想，是为了在不修改源代码的基础上对原代码进行增强，Springaop是aop思想的实现。我们知道java一贯接收的是OOP（ObjectOrientedProgramming，面向对象开发）思想，在开发过
  • java篇 常用工具类 0x03：Iterator 与 Iterable 接口 Kevin骑熊猫打老虎 javajava
    文章目录Iterator接口Iterable接口手动实现Iterable接口示例Iterator接口Iterator接口在java.util包中。实现了Iterator接口的类就可以支持遍历操作。publicinterfaceIterator{//只需要关注到这两个抽象方法booleanhasNext();//还有没有下一个元素Enext();//返回下一个元素}Iterable接口Iterabl
  • [0790]基于JAVA的吊车出租财务智慧管理系统的设计与实现 阿鑫学长 java开发语言课程设计毕业设计
    毕业设计（论文）开题报告表姓名学院专业班级题目基于JAVA的吊车出租财务智慧管理系统的设计与实现指导老师（一）选题的背景和意义在当前信息化社会背景下，企业的精细化管理和智能化运营已成为提升核心竞争力的关键。吊车出租行业作为我国基础设施建设、物流运输等领域的重要支撑力量，在日常经营活动中面临着大量复杂的数据处理和业务管理需求。传统的手工管理模式效率低下，易出错，且难以实现资源的有效整合与利用。因此，
  • Scala之高阶面向对象编程 WHYBIGDATA Scalascalajava开发语言
    Scala之高阶面向对象编程文章目录Scala之高阶面向对象编程写在前面继承封装抽象单例对象特质基本语法动态混入（方便扩展程序功能）初始化叠加功能叠加扩展写在前面操作系统：Windows10JDK版本：jdk1.8Maven版本：Maven-3.5.4Scala版本：Scala-2.12.11IDE工具：IntelliJIDEA2019.2.3继承和Java一样，Scala中的继承也是单继承，且使
  • java8 探讨与分析匿名内部类、lambda表达式、方法引用的底层实现 罗蜜斯丹 java学习Java8lambda
    问题解决思路：查看编译生成的字节码文件本文本来我是发布在博客园，现在移植到CSDN；原文链接文章目录测试匿名内部类的实现小结测试lambda表达式小结测试方法引用小结三种实现方式的总结对于lambda表达式，为什么java8要这样做？理论上的性能实测的性能总结思路一：编译javacfileName.java反编译javap-v-pfileName.class;这一步可以看到字节码。思路二：运行阶段
  • JDK8优化JVM总结 闫小甲 jvm
    JDK8优化JVM总结默认垃圾回收器：当前大多数应用仍然使用JDK1.8，并且默认的年轻代垃圾回收器是ParallelScavenge。ParallelScavenge回收器旨在最大化吞吐量，适合对CPU使用率有较高要求的应用场景。AdaptiveSizePolicy：默认情况下，ParallelScavenge回收器启用了AdaptiveSizePolicy，该策略会动态调整Eden区和Surv
  • springboot2.x到spring3.x的一些变化和示例说明 闫小甲 springspringbootspringcloud
    最近在做微服务版本升级工作，整理springboot2.x到spring3.x（spring5.x到spring6.x）的一些变化和示例说明。1.Java版本要求SpringBoot2.5.0：支持Java8及以上版本。SpringBoot3.3.0：要求Java17及以上版本，并且支持Java21。这意味着在升级过程中，首先需要确保JDK版本符合要求，并可能需要进行JDK的升级。2.底层依赖更新
  • flaresolverr环境搭建 野生猕猴桃 FlareSolverrflareSolverrcloudflare爬虫跳过cloudflare
    FlareSolverr是一个基于浏览器自动化技术的反爬虫解决方案。它可以应对一些比较复杂的反爬虫策略，如Cloudflare、hCaptcha等，并提供了简单易用的API接口。具体来说，FlareSolverr就是一个被动式的浏览器渲染服务，它使用了HeadlessChrome和Puppeteer技术来模拟人工操作浏览器的行为，并通过自定义的JavaScript脚本和与浏览器进行交互，最终获取网
  • 推荐一篇 学习SQL 的文章 @Carey java零基础开始sql数据库
    学习java，当然避不开数据库的知识，个人认为好学好理解的一篇文章，推荐给大家SQL语法基础知识总结|JavaGuide「Java学习+面试指南」一份涵盖大部分Java程序员所需要掌握的核心知识。准备Java面试，首选JavaGuide！https://javaguide.cn/database/sql/sql-syntax-summary.html#sql-%E8%AF%AD%E6%B3%95希
  • 银行卡四要素验证如何用Java调用 loosenivy 银联类接口java银行卡四要素银行卡四要素验证银行卡四要素认证银行卡实名认证银行卡认证银行卡核验
    一、什么是银行卡四要素验证？银行卡四要素验证又叫银行卡四要素核验，银行卡实名核验，银行卡四元素验证，传入银行卡卡号、姓名、身份证号码、手机号，验证此四要素是否一致，支持所有带银联标识的银行卡。二、银行卡四要素验证适用场景有哪些？例如：金融领域：1.网络支付：在各类线上支付平台，验证用户银行卡信息的真实性，确保交易安全进行，例如电商购物支付场景中，快速核实用户身份与银行卡匹配情况，防止盗刷风险，保障
  • 社会(逻辑)的本质,层(方法和类) 庖丁解java java系统架构
    从javaSE,到中间件,再到系统间对接,我本觉得逻辑已经完备,以后的工作就是慢慢填补细节,直到把整个java语言,彻底解析清除.从而使得工作能够变得游刃有余,最后再公司混个架构师当当...哈哈,想得有点远了.后来越看越不对,因为我在想javaSE的时候,发现一个东西,就是utils(工具类)这个东西,似乎不太属于javaSE基础内容.但你说他属于业务内容吧,也不太对.但一回想我的具体工作,发现u
  • java maven 多环境+jenkins参数化构建 flyingshuai 自动化接口mavenjava多环境接口自动化
    背景：运维提出以后会有多套环境，自动化接口测试将会是一套代码在多个服务器环境上跑。需要根据jenkins的命令，实现发布多套环境。首先搜索到的是maven项目的多环境切换，但是帖子都只有怎么配置多环境。具体java代码里怎么读到环境参数却是没提。后来又搜索java代码怎么读取pom的环境配置，以及怎么替换当前环境，终于把整个流程串下来了，记录如下。思路：jenkins参数化构建，传递环境参数给ma
  • Java设计模式——建造者模式 九千七 设计模式设计模式建造者模式
    目录前言一、什么是建造者模式二、建造者模式的核心角色三、建造者模式的优点四、具体实现1、抽象建造者类2、具体建造者类3、产品类4、指挥者类5、客户端代码总结前言在软件工程中，我们经常遇到需要创建复杂对象的情况。这些对象可能由多个部件组成，各个部件的创建和组装可能涉及复杂的逻辑。为了解决这个问题，我们可以使用一种设计模式：建造者模式（BuilderPattern）。它使用多个简单的对象一步一步构建成
  • 汇编、C/C++编译过程 迷的人 c++
    前言最近安装汇编环境的时候了解到代码的执行与编译过程，对自己曾经学习过语言的编译过程无法准确的回答，借此进行一些简单的梳理。一、汇编的编译过程汇编作为我们能够接触到最底层的语言、低级语言，汇编语言的编译方法多是基于对于寄存器的控制，可以直接翻译成机器代码，它同样是其他高级语言的基础，高级语言如Python、C++和Java与汇编语言的关系是一对多。比如，C++的一条语句就会扩展为多条汇编指令。故汇
  • HarmonyOS开发实战：Node-API扩展能力接口 小小煤球 鸿蒙开发HarmonyOSOpenHarmonymicrosoft鸿蒙华为harmonyos前端鸿蒙系统开发语言
    前言：扩展能力接口进一步扩展了Node-API的功能，提供了一些额外的接口，用于在Node-API模块中与JavaScript进行更灵活的交互和定制。这些接口可以用于创建自定义JavaScript对象等场景。基本概念在理解Node-API扩展能力接口之前，需要了解一些基本概念：模块:一个模块是一个可重用的、独立的代码单元。它封装了相关功能，并可以被其他模块引用和使用。命名空间:命名空间是一种用于组
  • HarmonyOS JS实现图片上传后端并调用 Brave！ harmonyos华为
    前言鸿蒙中能实现图片上传的方法有很多，调用Java端实现的效果更好。本次是使用纯JS将图片转成base64编码并存储后端，之后转成图片保存调用路径下。正文1.创建鸿蒙JS端空项目2.添加权限"reqPermissions":[{"name":"ohos.permission.DISTRIBUTED_DATASYNC"},{"name":"ohos.permission.GET_NETWORK_IN
  • pyhton - PyHive 凌不了云 pythonpythonhive
    简介PyHive是一组PythonDB-API和SQLAlchemy接口，可用于Presto和Hive。它为Python提供了一个与Presto和Hive进行交互的平台，使得数据分析师和工程师可以更方便地进行数据处理和分析。安装在安装PyHive之前，你需要确保已经安装以下软件：PipPythonJDK（JavaDevelopmentKit）Hive或Presto在安装完成上述软件之后，你可以使用
  • hadoop常用地址 静听山水 Sparkhadoop
    java："/opt/homebrew/Cellar/openjdk/22.0.1/libexec/openjdk.jdk/Contents/Home"hadoop：1】sbin:/opt/homebrew/sbin2】home:/opt/homebrew/Cellar/hadoop/3.4.02】log:/opt/homebrew/Cellar/hadoop/3.4.0/libexec/logs
  • 【模板方法模式】设计模式系列：构建可扩展的算法骨架(打造可定制的算法框架) 无理 Java #设计模式模板方法模式设计模式行为型设计模式后端java面试
    文章目录Java设计模式之模板方法模式：理解与应用1.引言2.模板方法模式定义2.1定义与意图2.2模式的参与者3.模板方法模式结构3.1类图解析3.2代码示例3.3模式变体4.模板方法模式的应用场景4.1应用背景4.2实际案例分析4.3使用模式的好处5.模板方法模式的优势与劣势5.1优势5.2劣势6.与其他模式的关系6.1与策略模式的区别6.2与工厂模式的结合6.3与装饰器模式的对比7.最佳实践
  • VUE3笔记 一介书生. 前端javascriptvue.js前端
    前端系列一、HTML5二、CSS3三、JavaScript四、jQuery五、BootStrap六、Element七、Ajax八、JSON九、VUE3第一章、基础一、vue简介1、学习阶段vue2基础vue-cli（vue的手脚架，专门做工程化开发）vue-router（实现前端路由的）vuex（vue存储数据的）element-ui（ui组件库）vue32、vue的特点采用组件化模式，提高代码复
  • 深入剖析Java核心API——io类，一篇文章总结清楚 欺霜 Java核心APIjava开发语言
    在前面几天中我们都在不断的学习Java中一个重要的API——io类，现在我们进行总结读入与写出首先我们来了解一下什么是数据的读入与写出，为什么要有io流来读入写出这些数据。我们先来认识一下在计算机内部中数据都是以二进制来存储与传递的，因此我们不能直接对数据进行操作，需要借助io类中的一些标准的读写操作来完成对不同设备的读写数据工作。java将IO按照方向划分为输入与输出,参照点是我们写的程序.输入
  • java 读取mysql中的表并按照指定格式导出excel 战族狼魂 Springbootjava数据库javamysqlexcel
    在Java中读取MySQL中的数据表并将其导出到Excel文件中，你需要以下几个步骤：连接MySQL数据库：使用JDBC驱动程序连接到MySQL数据库。执行SQL查询：获取表数据。使用ApachePOI库生成Excel文件：将数据写入Excel格式。保存Excel文件：将生成的Excel文件保存到指定路径。我们将使用以下技术和库来完成此任务：JDBC：用于连接MySQL数据库并执行SQL查询。Ap
  • Linux的Initrd机制 被触发 linux
    Linux 的 initrd 技术是一个非常普遍使用的机制，linux2.6 内核的 initrd 的文件格式由原来的文件系统镜像文件转变成了 cpio 格式，变化不仅反映在文件格式上， linux 内核对这两种格式的 initrd 的处理有着截然的不同。本文首先介绍了什么是 initrd 技术，然后分别介绍了 Linux2.4 内核和 2.6 内核的 initrd 的处理流程。最后通过对 Lin
  • maven本地仓库路径修改 bitcarter maven
    默认maven本地仓库路径：C:\Users\Administrator\.m2 修改maven本地仓库路径方法：     1.打开E:\maven\apache-maven-2.2.1\conf\settings.xml     2.找到        
  • XSD和XML中的命名空间 darrenzhu xmlxsdschemanamespace命名空间
    http://www.360doc.com/content/12/0418/10/9437165_204585479.shtml http://blog.csdn.net/wanghuan203/article/details/9203621 http://blog.csdn.net/wanghuan203/article/details/9204337 http://www.cn
  • Java 求素数运算 周凡杨 java算法素数
    网络上对求素数之解数不胜数，我在此总结归纳一下，同时对一些编码，加以改进，效率有成倍热提高。 第一种：   原理: 6N(+-)1法         任何一个自然数，总可以表示成为如下的形式之一： 6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)   
  • java 单例模式 g21121 java
    想必单例模式大家都不会陌生，有如下两种方式来实现单例模式：   class Singleton { private static Singleton instance=new Singleton(); private Singleton(){} static Singleton getInstance() { return instance; }
  • Linux下Mysql源码安装 510888780 mysql
    1.假设已经有mysql-5.6.23-linux-glibc2.5-x86_64.tar.gz (1)创建mysql的安装目录及数据库存放目录       解压缩下载的源码包，目录结构，特殊指定的目录除外：           
  • 32位和64位操作系统 墙头上一根草 32位和64位操作系统
    32位和64位操作系统是指：CPU一次处理数据的能力是32位还是64位。现在市场上的CPU一般都是64位的，但是这些CPU并不是真正意义上的64 位CPU，里面依然保留了大部分32位的技术，只是进行了部分64位的改进。32位和64位的区别还涉及了内存的寻址方面，32位系统的最大寻址空间是2 的32次方= 4294967296（bit）= 4（GB）左右，而64位系统的最大寻址空间的寻址空间则达到了
  • 我的spring学习笔记10-轻量级_Spring框架 aijuans Spring 3
    一、问题提问：     → 请简单介绍一下什么是轻量级？     轻量级（Leightweight）是相对于一些重量级的容器来说的，比如Spring的核心是一个轻量级的容器，Spring的核心包在文件容量上只有不到1M大小，使用Spring核心包所需要的资源也是很少的，您甚至可以在小型设备中使用Spring。  
  • mongodb 环境搭建及简单CURD antlove WebInstallcurdNoSQLmongo
    一 搭建mongodb环境 1. 在mongo官网下载mongodb 2. 在本地创建目录 "D:\Program Files\mongodb-win32-i386-2.6.4\data\db" 3. 运行mongodb服务 [mongod.exe --dbpath "D:\Program Files\mongodb-win32-i386-2.6.4\data\
  • 数据字典和动态视图 百合不是茶 oracle数据字典动态视图系统和对象权限
    数据字典（data dictionary）是 Oracle 数据库的一个重要组成部分，这是一组用于记录数据库信息的只读（read-only）表。随着数据库的启动而启动,数据库关闭时数据字典也关闭   数据字典中包含   数据库中所有方案对象（schema object）的定义(包括表，视图，索引，簇，同义词，序列，过程，函数，包，触发器等等) 数据库为一
  • 多线程编程一般规则 bijian1013 javathread多线程java多线程
           如果两个工两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。        不要滥用同步。如果在一个对象内的不同的方法访问的不是同一个数据，就不要将方法设置为synchronized的。
  • 将文件或目录拷贝到另一个Linux系统的命令scp bijian1013 linuxunixscp
    一.功能说明        scp就是security copy，用于将文件或者目录从一个Linux系统拷贝到另一个Linux系统下。scp传输数据用的是SSH协议，保证了数据传输的安全，其格式如下：        scp 远程用户名@IP地址：文件的绝对路径
  • 【持久化框架MyBatis3五】MyBatis3一对多关联查询 bit1129 Mybatis3
    以教员和课程为例介绍一对多关联关系，在这里认为一个教员可以叫多门课程，而一门课程只有1个教员教，这种关系在实际中不太常见，通过教员和课程是多对多的关系。   示例数据：   地址表：   CREATE TABLE ADDRESSES ( ADDR_ID INT(11) NOT NULL AUTO_INCREMENT, STREET VAR
  • cookie状态判断引发的查找问题 bitcarter formcgi
    先说一下我们的业务背景： 1.前台将图片和文本通过form表单提交到后台，图片我们都做了base64的编码，并且前台图片进行了压缩 2.form中action是一个cgi服务 3.后台cgi服务同时供PC，H5，APP 4.后台cgi中调用公共的cookie状态判断方法（公共的，大家都用，几年了没有问题） 问题：（折腾两天。。。。） 1.PC端cgi服务正常调用，cookie判断没
  • 通过Nginx,Tomcat访问日志(access log)记录请求耗时 ronin47
    一、Nginx通过$upstream_response_time $request_time统计请求和后台服务响应时间 nginx.conf使用配置方式： log_format main '$remote_addr - $remote_user [$time_local] "$request" ''$status $body_bytes_sent "$http_r
  • java-67- n个骰子的点数。 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 bylijinnan java
    public class ProbabilityOfDice { /** * Q67 n个骰子的点数 * 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 * 在以下求解过程中，我们把骰子看作是有序的。 * 例如当n=2时，我们认为（1，2）和（2，1）是两种不同的情况 */ private stati
  • 看别人的博客，觉得心情很好 Cb123456 博客心情
       以为写博客，就是总结，就和日记一样吧，同时也在督促自己。今天看了好长时间博客:    职业规划:    http://www.iteye.com/blogs/subjects/zhiyeguihua      android学习:    1.http://byandby.i
  • [JWFD开源工作流]尝试用原生代码引擎实现循环反馈拓扑分析 comsci 工作流
        我们已经不满足于仅仅跳跃一次，通过对引擎的升级，今天我测试了一下循环反馈模式，大概跑了200圈，引擎报一个溢出错误      在一个流程图的结束节点中嵌入一段方程，每次引擎运行到这个节点的时候，通过实时编译器GM模块，计算这个方程，计算结果与预设值进行比较，符合条件则跳跃到开始节点，继续新一轮拓扑分析，直到遇到
  • JS常用的事件及方法 cwqcwqmax9 js
    事件 描述 onactivate 当对象设置为活动元素时触发。 onafterupdate 当成功更新数据源对象中的关联对象后在数据绑定对象上触发。 onbeforeactivate 对象要被设置为当前元素前立即触发。 onbeforecut 当选中区从文档中删除之前在源对象触发。 onbeforedeactivate 在 activeElement 从当前对象变为父文档其它对象之前立即
  • 正则表达式验证日期格式 dashuaifu 正则表达式IT其它java其它
    正则表达式验证日期格式 function isDate(d){ var v = d.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/i); if(!v) { this.focus(); return false; } } <input value="2000-8-8" onblu
  • Yii CModel.rules() 方法 、validate预定义完整列表、以及说说验证 dcj3sjt126com yii
    public array rules () {return} array 要调用 validate() 时应用的有效性规则。 返回属性的有效性规则。声明验证规则，应重写此方法。 每个规则是数组具有以下结构：array('attribute list', 'validator name', 'on'=>'scenario name', ...validation
  • UITextAttributeTextColor = deprecated in iOS 7.0 dcj3sjt126com ios
    In this lesson we used the key "UITextAttributeTextColor" to change the color of the UINavigationBar appearance to white. This prompts a warning "first deprecated in iOS 7.0." Ins
  • 判断一个数是质数的几种方法 EmmaZhao Mathpython
    质数也叫素数，是只能被1和它本身整除的正整数，最小的质数是2，目前发现的最大的质数是p=2^57885161-1【注1】。 判断一个数是质数的最简单的方法如下： def isPrime1(n): for i in range(2, n): if n % i == 0: return False return True 但是在上面的方法中有一些冗余的计算，所以
  • SpringSecurity工作原理小解读 坏我一锅粥 SpringSecurity
      SecurityContextPersistenceFilter   ConcurrentSessionFilter   WebAsyncManagerIntegrationFilter   HeaderWriterFilter   CsrfFilter   LogoutFilter   Use
  • JS实现自适应宽度的Tag切换 ini JavaScripthtmlWebcsshtml5
    效果体验：http://hovertree.com/texiao/js/3.htm   该效果使用纯JavaScript代码，实现TAB页切换效果，TAB标签根据内容自适应宽度，点击TAB标签切换内容页。 HTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"
  • Hbase Rest API : 数据查询 kane_xie RESThbase
    hbase（hadoop）是用java编写的，有些语言（例如python）能够对它提供良好的支持，但也有很多语言使用起来并不是那么方便，比如c#只能通过thrift访问。Rest就能很好的解决这个问题。Hbase的org.apache.hadoop.hbase.rest包提供了rest接口，它内嵌了jetty作为servlet容器。   启动命令：./bin/hbase rest s
  • JQuery实现鼠标拖动元素移动位置（源码+注释） 明子健 jqueryjs源码拖动鼠标
    欢迎讨论指正！   print.html代码： <!DOCTYPE html> <html> <head> <meta http-equiv=Content-Type content="text/html;charset=utf-8"> <title>发票打印</title> &l
  • Postgresql 连表更新字段语法 update qifeifei PostgreSQL
    下面这段sql本来目的是想更新条件下的数据，可是这段sql却更新了整个表的数据。sql如下： UPDATE tops_visa.visa_order SET op_audit_abort_pass_date = now() FROM tops_visa.visa_order as t1 INNER JOIN tops_visa.visa_visitor as t2 ON t1.
  • 将redis,memcache结合使用的方案? tcrct rediscache
    公司架构上使用了阿里云的服务，由于阿里的kvstore收费相当高，打算自建，自建后就需要自己维护，所以就有了一个想法，针对kvstore(redis)及ocs(memcache)的特点，想自己开发一个cache层，将需要用到list，set，map等redis方法的继续使用redis来完成，将整条记录放在memcache下，即findbyid，save等时就memcache，其它就对应使用redi
  • 开发中遇到的诡异的bug wudixiaotie bug
    今天我们服务器组遇到个问题： 我们的服务是从Kafka里面取出数据，然后把offset存储到ssdb中，每个topic和partition都对应ssdb中不同的key，服务启动之后，每次kafka数据更新我们这边收到消息，然后存储之后就发现ssdb的值偶尔是-2,这就奇怪了，最开始我们是在代码中打印存储的日志，发现没什么问题，后来去查看ssdb的日志，才发现里面每次set的时候都会对同一个key
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他